Enum Scheme 

pub enum Scheme<P: PublicKey, V: Variant> {
    Signer {
        participants: OrderedAssociated<P, V::Public>,
        identity: V::Public,
        share: Share,
    },
    Verifier {
        participants: OrderedAssociated<P, V::Public>,
        identity: V::Public,
    },
    CertificateVerifier {
        identity: V::Public,
    },
}

BLS12-381 threshold implementation of the Scheme trait.

It is possible for a node to play one of the following roles: a signer (with its share), a verifier (with evaluated public polynomial), or an external verifier that only checks recovered certificates.

Variants

Signer

Fields

participants: OrderedAssociated<P, V::Public>

Participants in the committee.

identity: V::Public

Public identity of the committee (constant across reshares).

share: Share

Local share used to generate partial signatures.

Verifier

Fields

participants: OrderedAssociated<P, V::Public>

Participants in the committee.

identity: V::Public

Public identity of the committee (constant across reshares).

CertificateVerifier

Fields

identity: V::Public

Public identity of the committee (constant across reshares).

Implementations

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

pub fn new( participants: Ordered<P>, polynomial: &Public<V>, share: Share, ) -> Self

Constructs a signer instance with a private share and evaluated public polynomial.

The participant identity keys are used for committee ordering and indexing. The polynomial can be evaluated to obtain public verification keys for partial signatures produced by committee members.

If the provided share does not match the polynomial evaluation at its index, the instance will act as a verifier (unable to sign votes).

• participants - ordered set of participant identity keys
• polynomial - public polynomial for threshold verification
• share - local threshold share for signing

pub fn verifier(participants: Ordered<P>, polynomial: &Public<V>) -> Self

Produces a verifier that can authenticate votes but does not hold signing state.

The participant identity keys are used for committee ordering and indexing. The polynomial can be evaluated to obtain public verification keys for partial signatures produced by committee members.

• participants - ordered set of participant identity keys
• polynomial - public polynomial for threshold verification

pub fn certificate_verifier(identity: V::Public) -> Self

Creates a verifier that only checks recovered certificates.

This lightweight verifier can authenticate recovered threshold certificates but cannot verify individual votes or partial signatures.

• identity - public identity of the committee (constant across reshares)

pub fn participants(&self) -> &Ordered<P>

Returns the ordered set of participant public identity keys in the committee.

pub fn identity(&self) -> &V::Public

Returns the public identity of the committee (constant across reshares).

pub fn share(&self) -> Option<&Share>

Returns the local share if this instance can generate partial signatures.

pub fn polynomial(&self) -> &[V::Public]

Returns the evaluated public polynomial for validating partial signatures produced by committee members.

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 = Signature<V>

Vote signature emitted by individual validators.

type Certificate = Signature<V>

Quorum certificate recovered from a set of votes.

type Seed = Seed<V>

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 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_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 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 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.

fn seed( &self, round: Round, certificate: &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.