Struct snarkvm_algorithms::signature::schnorr::SchnorrSignature

pub struct SchnorrSignature<G: Group, D: Digest> {
    pub parameters: SchnorrParameters<G, D>,
}

Fields

parameters: SchnorrParameters<G, D>

Trait Implementations

impl<G: Group, D: Digest> Clone for SchnorrSignature<G, D> where
    G: Group,
    D: Digest, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Group, D: Digest> Debug for SchnorrSignature<G, D> where
    G: Group,
    D: Digest, 

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

Formats the value using the given formatter.

impl<G: Group, D: Digest> Eq for SchnorrSignature<G, D> where
    G: Group,
    D: Digest, 

impl<G: Group, D: Digest> From<SchnorrParameters<G, D>> for SchnorrSignature<G, D>

fn from(parameters: SchnorrParameters<G, D>) -> Self

Performs the conversion.

impl<G: Group, D: Digest> PartialEq<SchnorrSignature<G, D>> for SchnorrSignature<G, D> where
    G: Group,
    D: Digest, 

fn eq(&self, other: &Self) -> 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<G: Group + Hash + CanonicalSerialize + CanonicalDeserialize, D: Digest + Send + Sync> SignatureScheme for SchnorrSignature<G, D> where
    <G as Group>::ScalarField: PrimeField, 

type Output = SchnorrOutput<G>

type Parameters = SchnorrParameters<G, D>

type PrivateKey = <G as Group>::ScalarField

type PublicKey = SchnorrPublicKey<G>

fn setup<R: Rng>(rng: &mut R) -> Result<Self, SignatureError>

fn parameters(&self) -> &Self::Parameters

fn generate_private_key<R: Rng>(
    &self,
    rng: &mut R
) -> Result<Self::PrivateKey, SignatureError>

fn generate_public_key(
    &self,
    private_key: &Self::PrivateKey
) -> Result<Self::PublicKey, SignatureError>

fn sign<R: Rng>(
    &self,
    private_key: &Self::PrivateKey,
    message: &[u8],
    rng: &mut R
) -> Result<Self::Output, SignatureError>

fn verify(
    &self,
    public_key: &Self::PublicKey,
    message: &[u8],
    signature: &Self::Output
) -> Result<bool, SignatureError>

fn randomize_public_key(
    &self,
    public_key: &Self::PublicKey,
    randomness: &[u8]
) -> Result<Self::PublicKey, SignatureError>

fn randomize_signature(
    &self,
    signature: &Self::Output,
    randomness: &[u8]
) -> Result<Self::Output, SignatureError>