Struct bls_like::distinct::DistinctMessages

pub struct DistinctMessages<E: EngineBLS> { /* fields omitted */ }

Distinct messages with attached BLS signature

We can aggregate BLS signatures on distinct messages without additional assuptions or delinearization. In this variant, there is obviously no aggregation on the signature curve, so verification still requires one pairing per message. We can however aggregate numerous messages with the same signer, so this works well when a small signer set signs numerous messages, even if the signer set remains unknown.

We also of course benifit from running one single Miller loop and final exponentiation when compiuting all these pairings. We note that proofs-of-possession require distinct messages because the message must uniquely single out the signing key, so they may be aggregated or batch verified with distinct message mode, and indeed using distinct messages aggregation is optimal.

We recommend using this for either batching or aggregation, but we do yet not provide any serialization scheme for the aggregate version. Instead, you should serialize the aggregated signature seperately, and reconstruct this type using its add_* methods.

Methods

impl<E: EngineBLS> DistinctMessages<E>

pub fn new() -> DistinctMessages<E>

pub fn add_signature(&mut self, signature: &Signature<E>)

Add only a Signature<E> to our internal signature.

Useful in constructing an aggregate signature from this type.

pub fn add_message_n_publickey(
    self,
    message: Message,
    publickey: PublicKey<E>
) -> DistinctMessagesResult<E>

Add only a Message and PublicKey<E> to our internal data.

Useful in constructing an aggregate signature from this type.

We require that duplicate message halt verification by consuming self by vaule and return it only if no duplicates occur.

pub fn add(self, signed: &SignedMessage<E>) -> DistinctMessagesResult<E>

Aggregage BLS signatures from singletons with distinct messages

We require that duplicate message halt verification by consuming self by vaule and return it only if no duplicates occur.

pub fn merge(self, signed: &DistinctMessages<E>) -> DistinctMessagesResult<E>

Aggregage BLS signatures from sources with distinct messages

We require that duplicate message halt verification by consuming self by vaule and return it only if no duplicates occur.

Trait Implementations

impl<'a, E: EngineBLS> Signed for &'a DistinctMessages<E>

type E = E

type M = &'a Message

type PKG = &'a PublicKey<Self::E>

type PKnM = Iter<'a, Message, PublicKey<E>>

Iterator over messages and public key reference pairs.

fn messages_and_publickeys(self) -> Self::PKnM

Returns an iterator over messages and public key reference for pairings, often only partially aggregated.

fn signature(&self) -> Signature<E>

Return the aggregated signature

fn verify(self) -> bool

Appropriate BLS signature verification for the Self type.

impl<E: Clone + EngineBLS> Clone for DistinctMessages<E>

fn clone(&self) -> DistinctMessages<E>

Returns a copy of the value.

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

Performs copy-assignment from source.