Trait Scheme 

pub trait Scheme: Verifier {
    type Signature: Clone + Debug + PartialEq + Eq + Hash + Send + Sync + CodecFixed<Cfg = ()>;

    // Required methods
    fn me(&self) -> Option<Participant>;
    fn participants(&self) -> &Set<Self::PublicKey>;
    fn sign<D: Digest>(
        &self,
        subject: Self::Subject<'_, D>,
    ) -> Option<Attestation<Self>>;
    fn verify_attestation<R, D>(
        &self,
        rng: &mut R,
        subject: Self::Subject<'_, D>,
        attestation: &Attestation<Self>,
        strategy: &impl Strategy,
    ) -> bool
       where R: CryptoRng,
             D: Digest;
    fn assemble<I, M>(
        &self,
        attestations: I,
        strategy: &impl Strategy,
    ) -> Option<Self::Certificate>
       where I: IntoIterator<Item = Attestation<Self>>,
             I::IntoIter: Send,
             M: Faults;
    fn is_attributable() -> bool;

    // Provided method
    fn verify_attestations<R, D, I>(
        &self,
        rng: &mut R,
        subject: Self::Subject<'_, D>,
        attestations: I,
        strategy: &impl Strategy,
    ) -> Verification<Self>
       where R: CryptoRng,
             D: Digest,
             I: IntoIterator<Item = Attestation<Self>>,
             I::IntoIter: Send { ... }
}

Cryptographic surface for multi-party certificate schemes.

A Scheme extends Verifier with the signing surface: it produces attestations, validates them (individually or in batches), and assembles certificates. Implementations may override the provided defaults to take advantage of scheme-specific batching strategies.

Required Associated Types

type Signature: Clone + Debug + PartialEq + Eq + Hash + Send + Sync + CodecFixed<Cfg = ()>

Signature emitted by individual participants.

Required Methods

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

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, subject: Self::Subject<'_, D>, ) -> Option<Attestation<Self>>

Signs a subject. Returns None if the scheme cannot sign (e.g. it’s a verifier-only instance).

fn verify_attestation<R, D>( &self, rng: &mut R, subject: Self::Subject<'_, D>, attestation: &Attestation<Self>, strategy: &impl Strategy, ) -> bool

where R: CryptoRng, D: Digest,

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

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

where I: IntoIterator<Item = Attestation<Self>>, I::IntoIter: Send, M: Faults,

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

Callers must not include duplicate attestations from the same signer. Passing duplicates is undefined behavior, implementations may panic or produce incorrect results.

fn is_attributable() -> bool

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

Schemes where individual signatures can be safely reported as fault evidence should return true.

Provided Methods

fn verify_attestations<R, D, I>( &self, rng: &mut R, subject: Self::Subject<'_, D>, attestations: I, strategy: &impl Strategy, ) -> Verification<Self>

where R: CryptoRng, D: Digest, I: IntoIterator<Item = Attestation<Self>>, I::IntoIter: Send,

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

Callers must not include duplicate attestations from the same signer. Passing duplicates is undefined behavior, implementations may panic or produce incorrect results.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors