Struct schnorr_fun::Signature

pub struct Signature<S = Public> {
    pub R: XOnly,
    pub s: Scalar<S, Zero>,
}

A Schnorr signature.

Fields

R: XOnly

The x-coordinate of the signature's public nonce. When verifying it is interpreted as the Point.

s: Scalar<S, Zero>

The challenge response part of the signature.

Implementations

impl<S> Signature<S>

pub fn to_bytes(&self) -> [u8; 64]

Serializes the signature as 64 bytes -- First the 32-byte nonce x-coordinate and then the 32-byte challenge response scalar.

Examples

let bytes = signature.to_bytes();
assert_eq!(signature.R.as_bytes(), &bytes[..32]);
assert_eq!(signature.s.to_bytes().as_ref(), &bytes[32..]);

pub fn as_tuple(&self) -> (&XOnly, &Scalar<S, Zero>)

Gets a reference to the signature components as a tuple.

Examples

let (R, s) = signature.as_tuple();

#[must_use]pub fn mark<M: Secrecy>(self) -> Signature<M>

Marks the signature with a Secrecy. If it is marked as Secret the operations (e.g. verification) on the signature should be done in constant time.

Examples

use schnorr_fun::{fun::marker::*, Signature};
let signature = Signature::random(&mut rand::thread_rng());
let secret_sig = signature.mark::<Secret>();

impl Signature<Public>

pub fn random<R: RngCore + CryptoRng>(rng: &mut R) -> Self

Generates a uniformly distributed signature. It will be valid for an infinite number of messages on every key but computationally you will never be able to find one! Useful for testing.

Examples

use schnorr_fun::Signature;
let random_signature = Signature::random(&mut rand::thread_rng());

pub fn from_bytes(bytes: [u8; 64]) -> Option<Self>

Deserializes a signature from the byte representation produced by to_bytes.

This returns None if the first 32 bytes were not a valid XOnly or the last 32 bytes were not a valid scalar.

Examples

match Signature::from_bytes(bytes) {
    Some(signature) => println!("the bytes were a valid encoding of a signature!"),
    None => eprintln!("the bytes did *not* encode a valid signature"),
}

Trait Implementations

impl<S: Clone> Clone for Signature<S>

fn clone(&self) -> Signature<S>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for Signature<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the type as hex and any markers on the type.

impl<'de, S: Secrecy> Deserialize<'de> for Signature<S>

fn deserialize<Deser: Deserializer<'de>>(
    deserializer: Deser
) -> Result<Signature<S>, Deser::Error>

Deserialize this value from the given Serde deserializer.

impl<S> Display for Signature<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Displays as hex.

impl<S: Secrecy> FromStr for Signature<S>

type Err = HexError

The associated error which can be returned from parsing.

fn from_str(hex: &str) -> Result<Signature<S>, HexError>

Parses the string as hex and interprets tries to convert the resulting byte array into the desired value.

impl<S1, S2> PartialEq<Signature<S2>> for Signature<S1>

fn eq(&self, rhs: &Signature<S2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<S> Serialize for Signature<S>

fn serialize<Ser: Serializer>(
    &self,
    serializer: Ser
) -> Result<Ser::Ok, Ser::Error>

Serialize this value into the given Serde serializer.