Struct bls_like::pop::BatchAssumingProofsOfPossession

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

Batch or aggregate BLS signatures with attached messages and signers, for whom we previously checked proofs-of-possession.

In this type, we provide a high-risk low-level batching and aggregation mechanism that merely adds up signatures under the assumption that all required proofs-of-possession were previously checked.

We say a signing key has provided a proof-of-possession if the verifier remembers having checked some self-signed certificate by that key. It's insecure to use this aggregation strategy without first cehcking proofs-of-possession. In particular it is insecure to use this aggregation strategy when checking proofs-of-possession, and could not improve performance anyways.
Distinct message aggregation is always optimal for checking proofs-of-possession. Please see the module level doumentation for additional discussion and notes on security.

We foresee this type primarily being used to batch several BitPoPSignedMessages into one verification. We do not track aggreggated public keys here, instead merging multiples signers public keys anytime they sign the same message, so this type essentially provides only fast batch verificartion.
In principle, our add_* methods suffice for building an actual aggregate signature type. Yet, normally direct approaches like BitPoPSignedMessage work better for aggregation because the ProofsOfPossession trait tooling permits both enforce the proofs-of-possession and provide a compact serialization. We see no reason to support serialization for this type as present.

Methods

impl<E: EngineBLS> BatchAssumingProofsOfPossession<E>

pub fn new() -> BatchAssumingProofsOfPossession<E>

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

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

Useful for constructing an aggregate signature, but we recommend instead using a custom types like BitPoPSignedMessage.

pub fn add_message_n_publickey(
    &mut self,
    message: &Message,
    publickey: &PublicKey<E>
)

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

Useful for constructing an aggregate signature, but we recommend instead using a custom types like BitPoPSignedMessage.

pub fn aggregate<'a, S>(&mut self, signed: &'a S) where
    &'a S: Signed<E = E>,
    <&'a S as Signed>::PKG: Borrow<PublicKey<E>>, 

Aggregage BLS signatures assuming they have proofs-of-possession

Trait Implementations

impl<'a, E: EngineBLS> Signed for &'a BatchAssumingProofsOfPossession<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 BatchAssumingProofsOfPossession<E>

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

Returns a copy of the value.

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

Performs copy-assignment from source.