Enum Scheme 

pub enum Scheme<P: PublicKey, V: Variant> {
    Signer {
        participants: Set<P>,
        polynomial: Sharing<V>,
        share: Share,
    },
    Verifier {
        participants: Set<P>,
        polynomial: Sharing<V>,
    },
    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: Set<P>

Participants in the committee.

polynomial: Sharing<V>

The public polynomial, used for the group identity, and partial signatures.

share: Share

Local share used to generate partial signatures.

Verifier

Fields

participants: Set<P>

Participants in the committee.

polynomial: Sharing<V>

The public polynomial, used for the group identity, and partial signatures.

CertificateVerifier

Fields

identity: V::Public

Public identity of the committee (constant across reshares).

Implementations

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

pub fn signer( participants: Set<P>, polynomial: Sharing<V>, share: Share, ) -> Option<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.

Returns None if the share’s public key does not match any participant.

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

pub fn verifier(participants: Set<P>, polynomial: Sharing<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 const 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) -> &Set<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 const fn share(&self) -> Option<&Share>

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

pub fn polynomial(&self) -> &Sharing<V>

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

pub fn encrypt<R: Rng + CryptoRng>( &self, rng: &mut R, namespace: &[u8], target: Round, message: impl Into<Block>, ) -> Ciphertext<V>

Encrypts a message for a target round using Timelock Encryption (TLE).

The encrypted message can only be decrypted using the seed signature from a certificate of the target round (i.e. notarization, finalization, or nullification).

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, V> Config<Scheme<P, V>> for Random

where P: PublicKey, V: Variant + Send + Sync + 'static,

type Elector = RandomElector<Scheme<P, V>>

The initialized elector type.

fn build(self, participants: &Set<P>) -> RandomElector<Scheme<P, V>>

Builds the elector with the given participants.

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, V> Elector<Scheme<P, V>> for RandomElector<Scheme<P, V>>

where P: PublicKey, V: Variant + Send + Sync + 'static,

fn elect(&self, round: Round, certificate: Option<&Signature<V>>) -> u32

Selects the leader for the given round.

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

type Subject<'a, D: Digest> = Subject<'a, D>

Subject type for signing and verification.

type PublicKey = P

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

type Signature = Signature<V>

Signature emitted by individual participants.

type Certificate = Signature<V>

Certificate assembled from a set of attestations.

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) -> &Set<Self::PublicKey>

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

fn sign<D: Digest>( &self, namespace: &[u8], subject: Subject<'_, D>, ) -> Option<Attestation<Self>>

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

fn verify_attestation<D: Digest>( &self, namespace: &[u8], subject: Subject<'_, D>, attestation: &Attestation<Self>, ) -> bool

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

fn verify_attestations<R, D, I>( &self, _rng: &mut R, namespace: &[u8], subject: Subject<'_, D>, attestations: I, ) -> Verification<Self>

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

Batch-verifies attestations and separates valid attestations from signer indices that failed verification.

fn assemble<I>(&self, attestations: I) -> Option<Self::Certificate>

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

Assembles attestations into a certificate, returning None if the threshold is not met.

fn verify_certificate<R: Rng + CryptoRng, D: Digest>( &self, _rng: &mut R, namespace: &[u8], subject: Subject<'_, 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 = (Subject<'a, D>, &'a Self::Certificate)>,

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

fn is_attributable(&self) -> bool

Returns whether per-participant 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.