Struct BluePallas 

pub struct BluePallas<M>(pub(crate) PhantomData<M>);

The BluePallas ciphersuite, which uses the Pallas curve and Poseidon hash function.

Note that this ciphersuite is used for FROST signatures in the Mina protocol and has a lot of Mina-specific logic This library SHOULD not be treated as a general-purpose BluePallas ciphersuite, but rather as a Mina-specific implementation.

Tuple Fields

0: PhantomData<M>

Trait Implementations

impl<M> Ciphersuite for BluePallas<M>

where M: ChallengeMessage,

fn pre_commitment_aggregate<'a>( signing_package: &'a SigningPackage<Self>, binding_factor_list: &'a BindingFactorList<Self>, ) -> Result<Cow<'a, SigningPackage<Self>>, Error<Self>>

This performs the same functionality as Self::pre_commitment_sign, but instead only negates commitments because the coordinator is not able to receive any nonces. Naturally, this is called by the coordinator in the crate::aggregate function.

fn pre_commitment_sign<'a>( signing_package: &'a SigningPackage<Self>, signing_nonces: &'a SigningNonces<Self>, binding_factor_list: &'a BindingFactorList<Self>, ) -> Result<(Cow<'a, SigningPackage<Self>>, Cow<'a, SigningNonces<Self>>), Error<Self>>

This functions computes the group commitment and checks whether the y-coordinate of the group commitment is even, as required by the Mina protocol. If the group commitment is not even, it negates the nonces and commitments This will be called by each individual signer during round2::sign

const ID: &'static str = CONTEXT_STRING

The ciphersuite ID string. It should be equal to the contextString in the spec. For new ciphersuites, this should be a string that identifies the ciphersuite; it’s recommended to use a similar format to the ciphersuites in the FROST spec, e.g. “FROST-RISTRETTO255-SHA512-v1”.

type Group = PallasGroup

The prime order group (or subgroup) that this ciphersuite operates over.

type HashOutput = [u8; 32]

A unique byte array of fixed length.

type SignatureSerialization = [u8; 32]

A unique byte array of fixed length that is the Group::ElementSerialization + Group::ScalarSerialization

fn H1(m: &[u8]) -> <<Self::Group as Group>::Field as Field>::Scalar

H1 for a FROST ciphersuite.

fn H2(_m: &[u8]) -> <<Self::Group as Group>::Field as Field>::Scalar

H2 for a FROST ciphersuite.

fn H3(m: &[u8]) -> <<Self::Group as Group>::Field as Field>::Scalar

H3 for a FROST ciphersuite.

fn H4(m: &[u8]) -> Self::HashOutput

H4 for a FROST ciphersuite.

fn H5(m: &[u8]) -> Self::HashOutput

H5 for a FROST ciphersuite.

fn HDKG(m: &[u8]) -> Option<<<Self::Group as Group>::Field as Field>::Scalar>

Hash function for a FROST ciphersuite, used for the DKG.

fn HID(m: &[u8]) -> Option<<<Self::Group as Group>::Field as Field>::Scalar>

Hash function for a FROST ciphersuite, used for deriving identifiers from strings.

fn challenge( r: &Element<Self>, verifying_key: &VerifyingKey<Self>, message: &[u8], ) -> Result<Challenge<Self>, Error<Self>>

Optional. Generates the challenge as is required for Schnorr signatures. Called by [round2::sign()] and [crate::aggregate()].

fn single_sign<R>( signing_key: &SigningKey<Self>, rng: R, message: &[u8], ) -> Signature<Self>

where R: RngCore + CryptoRng,

Optional. Do regular (non-FROST) signing with a [SigningKey]. Called by [SigningKey::sign()]. This is not used by FROST. Can be overridden if required which is useful if FROST signing has been changed by the other Ciphersuite trait methods and regular signing should be changed accordingly to match.

fn verify_signature( message: &[u8], signature: &Signature<Self>, public_key: &VerifyingKey<Self>, ) -> Result<(), Error<Self>>

Optional. Verify a signature for this ciphersuite. Called by [VerifyingKey::verify()]. The default implementation uses the “cofactored” equation (it multiplies by the cofactor returned by Group::cofactor()).

fn pre_sign<'a>( signing_package: &'a SigningPackage<Self>, signer_nonces: &'a SigningNonces<Self>, key_package: &'a KeyPackage<Self>, ) -> Result<(Cow<'a, SigningPackage<Self>>, Cow<'a, SigningNonces<Self>>, Cow<'a, KeyPackage<Self>>), Error<Self>>

Optional. Pre-process [round2::sign()] inputs. The default implementation returns them as-is. Cow is used so implementations can choose to return the same passed reference or a modified clone.

fn pre_aggregate<'a>( signing_package: &'a SigningPackage<Self>, signature_shares: &'a BTreeMap<Identifier<Self>, SignatureShare<Self>>, public_key_package: &'a PublicKeyPackage<Self>, ) -> Result<(Cow<'a, SigningPackage<Self>>, Cow<'a, BTreeMap<Identifier<Self>, SignatureShare<Self>>>, Cow<'a, PublicKeyPackage<Self>>), Error<Self>>

Optional. Pre-process [crate::aggregate()] and [crate::verify_signature_share()] inputs. In the latter case, “dummy” container BTreeMap and PublicKeyPackage are passed with the relevant values (PublicKeyPackage.min_signers will be None). The default implementation returns them as-is. Cow is used so implementations can choose to return the same passed reference or a modified clone.

fn pre_verify<'a>( msg: &'a [u8], signature: &'a Signature<Self>, public_key: &'a VerifyingKey<Self>, ) -> Result<(Cow<'a, [u8]>, Cow<'a, Signature<Self>>, Cow<'a, VerifyingKey<Self>>), Error<Self>>

Optional. Pre-process [VerifyingKey::verify()] inputs. The default implementation returns them as-is. Cow is used so implementations can choose to return the same passed reference or a modified clone.

fn generate_nonce<R>( rng: &mut R, ) -> (<<Self::Group as Group>::Field as Field>::Scalar, <Self::Group as Group>::Element)

where R: RngCore + CryptoRng,

Optional. Generate a nonce and a commitment to it. Used by [SigningKey] for regular (non-FROST) signing and internally by the DKG to generate proof-of-knowledge signatures.

fn compute_signature_share( _group_commitment: &GroupCommitment<Self>, signer_nonces: &SigningNonces<Self>, binding_factor: BindingFactor<Self>, lambda_i: <<Self::Group as Group>::Field as Field>::Scalar, key_package: &KeyPackage<Self>, challenge: Challenge<Self>, ) -> SignatureShare<Self>

Optional. Compute the signature share for a particular signer on a given challenge. Called by [round2::sign()].

fn verify_share( _group_commitment: &GroupCommitment<Self>, signature_share: &SignatureShare<Self>, identifier: Identifier<Self>, group_commitment_share: &GroupCommitmentShare<Self>, verifying_share: &VerifyingShare<Self>, lambda_i: <<Self::Group as Group>::Field as Field>::Scalar, challenge: &Challenge<Self>, ) -> Result<(), Error<Self>>

Optional. Verify a signing share. Called by [crate::aggregate()] if cheater detection is enabled.

fn serialize_signature( signature: &Signature<Self>, ) -> Result<Vec<u8>, Error<Self>>

Optional. Converts a signature to its Ciphersuite::SignatureSerialization in bytes.

fn deserialize_signature(bytes: &[u8]) -> Result<Signature<Self>, Error<Self>>

Optional. Converts bytes as Ciphersuite::SignatureSerialization into a Signature<C>.

fn post_dkg( key_package: KeyPackage<Self>, public_key_package: PublicKeyPackage<Self>, ) -> Result<(KeyPackage<Self>, PublicKeyPackage<Self>), Error<Self>>

Post-process the output of the DKG for a given participant.

fn post_generate( secret_shares: BTreeMap<Identifier<Self>, SecretShare<Self>>, public_key_package: PublicKeyPackage<Self>, ) -> Result<(BTreeMap<Identifier<Self>, SecretShare<Self>>, PublicKeyPackage<Self>), Error<Self>>

Post-process the output of the key generation for a participant.

impl<M> Clone for BluePallas<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for BluePallas<M>

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

Formats the value using the given formatter.

impl<M: PartialEq> PartialEq for BluePallas<M>

fn eq(&self, other: &BluePallas<M>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<M> Copy for BluePallas<M>

impl<M: Eq> Eq for BluePallas<M>

impl<M> StructuralPartialEq for BluePallas<M>