Struct Generic 

pub struct Generic<P: PublicKey, V: Variant, N: Namespace> {
    pub participants: BiMap<P, V::Public>,
    pub signer: Option<(Participant, Private)>,
    pub namespace: N,
}

Generic BLS12-381 multi-signature implementation.

This struct contains the core cryptographic operations without protocol-specific context types. It can be reused across different protocols (simplex, aggregation, etc.) by wrapping it with protocol-specific trait implementations via the macro.

Fields

participants: BiMap<P, V::Public>

Participants in the committee.

signer: Option<(Participant, Private)>

Key used for generating signatures.

namespace: N

Pre-computed namespace(s) for this subject type.

Implementations

impl<P: PublicKey, V: Variant, N: Namespace> Generic<P, V, N>

pub fn signer( namespace: &[u8], participants: BiMap<P, V::Public>, private_key: Private, ) -> Option<Self>

Creates a new scheme instance with the provided key material.

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

Returns None if the provided private key does not match any signing key in the participant set.

pub fn verifier(namespace: &[u8], participants: BiMap<P, V::Public>) -> Self

Builds a verifier that can authenticate signatures and certificates.

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

pub const fn participants(&self) -> &Set<P>

Returns the ordered set of identity keys.

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

Returns the index of “self” in the participant set, if available.

pub fn sign<'a, S, D>( &self, subject: S::Subject<'a, D>, ) -> Option<Attestation<S>>

where S: Scheme<Signature = V::Signature>, S::Subject<'a, D>: Subject<Namespace = N>, D: Digest,

Signs a subject and returns the attestation.

pub fn verify_attestation<'a, S, D>( &self, subject: S::Subject<'a, D>, attestation: &Attestation<S>, ) -> bool

where S: Scheme<Signature = V::Signature>, S::Subject<'a, D>: Subject<Namespace = N>, D: Digest,

Verifies a single attestation from a signer.

pub fn verify_attestations<'a, S, R, D, I, T>( &self, rng: &mut R, subject: S::Subject<'a, D>, attestations: I, strategy: &T, ) -> Verification<S>

where S: Scheme<Signature = V::Signature>, S::Subject<'a, D>: Subject<Namespace = N>, R: CryptoRngCore, D: Digest, I: IntoIterator<Item = Attestation<S>>, T: Strategy,

Batch-verifies attestations and returns verified attestations and invalid signers.

pub fn assemble<S, I, M>(&self, attestations: I) -> Option<Certificate<V>>

where S: Scheme<Signature = V::Signature>, I: IntoIterator<Item = Attestation<S>>, M: Faults,

Assembles a certificate from a collection of attestations.

pub fn verify_certificate<'a, S, R, D, M>( &self, _rng: &mut R, subject: S::Subject<'a, D>, certificate: &Certificate<V>, ) -> bool

where S: Scheme, S::Subject<'a, D>: Subject<Namespace = N>, R: CryptoRngCore, D: Digest, M: Faults,

Verifies a certificate.

pub fn verify_certificates<'a, S, R, D, I, M>( &self, rng: &mut R, certificates: I, ) -> bool

where S: Scheme, S::Subject<'a, D>: Subject<Namespace = N>, R: CryptoRngCore, D: Digest, I: Iterator<Item = (S::Subject<'a, D>, &'a Certificate<V>)>, M: Faults,

Verifies multiple certificates (no batch optimization for BLS multisig).

pub const fn is_attributable() -> bool

pub const fn is_batchable() -> bool

pub const fn certificate_codec_config(&self) -> <Certificate<V> as Read>::Cfg

pub const fn certificate_codec_config_unbounded() -> <Certificate<V> as Read>::Cfg

Trait Implementations

impl<P: Clone + PublicKey, V: Clone + Variant, N: Clone + Namespace> Clone for Generic<P, V, N>

where V::Public: Clone,

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

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, N: Debug + Namespace> Debug for Generic<P, V, N>

where V::Public: Debug,

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

Formats the value using the given formatter.