Struct bls_like::delinear::Delinearized

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

Delinearized batched and aggregated BLS signatures.

We caution that this type only represents one of several optimizations possible. We believe it fits well when messages are often repeated but signers are rarely repeated.

We should create another type for when repeated signers are expected, likely by keying the hash map on the pubkic key. In practice though, if signers are often repeated then you should should consider a proof-of-possession scheme, which requiees all signers register in advance.

Methods

impl<E: EngineBLS> Delinearized<E>

pub fn new(key: Shake128) -> Delinearized<E>

pub fn new_keyed(key: &[u8]) -> Delinearized<E>

pub fn new_batched_rng<R: Rng>(rng: R) -> Delinearized<E>

pub fn new_batched() -> Delinearized<E>

pub fn mask(&self, publickey: &PublicKey<E>) -> E::Scalar

Return the mask used for a particular public key.

TODO: We only want 128 bits here, not a full scalar. We thus need mul_bits exposed by the pairing crate, at which point our return type here changes.

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

Add only a Signature<E> to our internal signature, assumes the signature was previously delinearized elsewhere.

Useful for constructing an aggregate signature.

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

Add only a Message and PublicKey<E> to our internal data, doing delinearization ourselves.

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

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

Aggregage BLS signatures from singletons using delinearization

pub fn agreement(&self, other: &Delinearized<E>) -> bool

Test that two Delinearized use the same key.

You should call this before calling merge, although we do enforce this because several untestable related conditions suffice too.

pub fn merge(&mut self, other: &Delinearized<E>)

Merge another Delinearized for simultanious verification.

You should only call this if self.agreement(other) or some related condition holds, or if you have message disjointness.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.