Struct Scheme 

pub struct Scheme<P: PublicKey, V: Variant> { /* private fields */ }

BLS12-381 multi-signature implementation of the Scheme trait.

Implementations

impl<P: PublicKey, V: Variant> Scheme<P, V>

pub fn new( participants: OrderedAssociated<P, V::Public>, private_key: Private, ) -> Self

Creates a new scheme instance with the provided key material.

Participants have both an identity key and a consensus key. The identity key is used for committee ordering and indexing, while the consensus key is used for signing and verification.

If the provided private key does not match any consensus key in the committee, the instance will act as a verifier (unable to generate signatures).

pub fn verifier(participants: OrderedAssociated<P, V::Public>) -> Self

Builds a verifier that can authenticate votes and certificates.

Participants have both an identity key and a consensus key. The identity key is used for committee ordering and indexing, while the consensus key is used for verification.

Trait Implementations

impl<P: Clone + PublicKey, V: Clone + Variant> Clone for Scheme<P, V>

where V::Public: Clone,

fn clone(&self) -> Scheme<P, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug + PublicKey, V: Debug + Variant> Debug for Scheme<P, V>

where V::Public: Debug,

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

Formats the value using the given formatter.

impl<P: PublicKey, V: Variant + Send + Sync> Scheme for Scheme<P, V>

type PublicKey = P

Public key type for participant identity used to order and index the committee.

type Signature = <V as Variant>::Signature

Vote signature emitted by individual validators.

type Certificate = Certificate<V>

Quorum certificate recovered from a set of votes.

type Seed = ()

Randomness seed derived from a certificate, if the scheme supports it.

fn me(&self) -> Option<u32>

Returns the index of “self” in the participant set, if available. Returns None if the scheme is a verifier-only instance.

fn participants(&self) -> &Ordered<Self::PublicKey>

Returns the ordered set of participant public identity keys managed by the scheme.

fn sign_vote<D: Digest>( &self, namespace: &[u8], context: VoteContext<'_, D>, ) -> Option<Vote<Self>>

Signs a vote for the given context using the supplied namespace for domain separation. Returns None if the scheme cannot sign (e.g. it’s a verifier-only instance).

fn verify_vote<D: Digest>( &self, namespace: &[u8], context: VoteContext<'_, D>, vote: &Vote<Self>, ) -> bool

Verifies a single vote against the participant material managed by the scheme.

fn verify_votes<R, D, I>( &self, _rng: &mut R, namespace: &[u8], context: VoteContext<'_, D>, votes: I, ) -> VoteVerification<Self>

where R: Rng + CryptoRng, D: Digest, I: IntoIterator<Item = Vote<Self>>,

Batch-verifies votes and separates valid messages from the voter indices that failed verification.

fn assemble_certificate<I>(&self, votes: I) -> Option<Self::Certificate>

where I: IntoIterator<Item = Vote<Self>>,

Aggregates a quorum of votes into a certificate, returning None if the quorum is not met.

fn verify_certificate<R: Rng + CryptoRng, D: Digest>( &self, _rng: &mut R, namespace: &[u8], context: VoteContext<'_, D>, certificate: &Self::Certificate, ) -> bool

Verifies a certificate that was recovered or received from the network.

fn seed(&self, _: Round, _: &Self::Certificate) -> Option<Self::Seed>

Extracts randomness seed, if provided by the scheme, derived from the certificate for the given round.

fn is_attributable(&self) -> bool

Returns whether per-validator fault evidence can be safely exposed.

fn certificate_codec_config(&self) -> <Self::Certificate as Read>::Cfg

Encoding configuration for bounded-size certificate decoding used in network payloads.

fn certificate_codec_config_unbounded() -> <Self::Certificate as Read>::Cfg

Encoding configuration that allows unbounded certificate decoding.

fn verify_certificates<'a, R, D, I>( &self, rng: &mut R, namespace: &[u8], certificates: I, ) -> bool

where R: Rng + CryptoRng, D: Digest, I: Iterator<Item = (VoteContext<'a, D>, &'a Self::Certificate)>,

Verifies a stream of certificates, returning false at the first failure.