Struct MinPk 

pub struct MinPk {}

A Variant with a public key of type G1 and a signature of type G2.

Trait Implementations

impl AsRef<<MinPk as Variant>::Public> for PublicKey

fn as_ref(&self) -> &<MinPk as Variant>::Public

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<<MinPk as Variant>::Signature> for Signature

fn as_ref(&self) -> &<MinPk as Variant>::Signature

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for MinPk

fn clone(&self) -> MinPk

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MinPk

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

Formats the value using the given formatter.

impl From<<MinPk as Variant>::Public> for PublicKey

fn from(key: <MinPk as Variant>::Public) -> Self

Converts to this type from the input type.

impl From<<MinPk as Variant>::Signature> for Signature

fn from(signature: <MinPk as Variant>::Signature) -> Self

Converts to this type from the input type.

impl Hash for MinPk

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MinPk

fn eq(&self, other: &MinPk) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Variant for MinPk

fn verify( public: &Self::Public, hm: &Self::Signature, signature: &Self::Signature, ) -> Result<(), Error>

Verifies that e(hm,pk) is equal to e(sig,G1::one()) using a single product check with a negated G1 generator (e(hm,pk) * e(sig,-G1::one()) == 1).

fn batch_verify<R: CryptoRngCore>( rng: &mut R, publics: &[Self::Public], hms: &[Self::Signature], signatures: &[Self::Signature], ) -> Result<(), Error>

Verifies a set of signatures against their respective public keys and pre-hashed messages.

This method is outperforms individual signature verification (2 pairings per signature) by verifying a random linear combination of the public keys and signatures (n+1 pairings and 2n multiplications for n signatures).

The verification equation for each signature i is: e(hm_i,pk_i) == e(sig_i,G1::one()), which is equivalent to checking if e(hm_i,pk_i) * e(sig_i,-G1::one()) == 1.

To batch verify n such equations, we introduce random non-zero scalars r_i (for i=1..n). The batch verification checks if the product of these individual equations, each raised to the power of its respective r_i, equals one: prod_i((e(hm_i,pk_i) * e(sig_i,-G1::one()))^{r_i}) == 1

Using the bilinearity of pairings, this can be rewritten (by moving r_i inside the pairings): prod_i(e(hm_i,r_i * pk_i) * e(r_i * sig_i,-G1::one())) == 1

The second term e(r_i * sig_i,-G1::one()) can be computed efficiently with Multi-Scalar Multiplication: e(sum_i(r_i * sig_i),-G1::one())

Finally, we aggregate all pairings e(hm_i,r_i * pk_i) (n) and e(sum_i(r_i * sig_i),-G1::one()) (1) into a single product in the target group G_T. If the result is the identity element in G_T, the batch verification succeeds.

Source: https://ethresear.ch/t/security-of-bls-batch-verification/10748

fn pairing(public: &Self::Public, signature: &Self::Signature) -> GT

Compute the pairing e(public, signature) -> GT.

const PROOF_OF_POSSESSION: DST = G2_PROOF_OF_POSSESSION

The domain separator tag (DST) for a proof of possession.

const MESSAGE: DST = G2_MESSAGE

The domain separator tag (DST) for a message.

type Public = G1

The public key type.

type Signature = G2

The signature type.

impl Eq for MinPk

impl StructuralPartialEq for MinPk