Struct UsualBLS 

pub struct UsualBLS<E: Pairing, P: Bls12Config + CurveExtraConfig>(pub E, _)
where
    <P as Bls12Config>::G2Config: WBConfig,
    WBMap<<P as Bls12Config>::G2Config>: MapToCurve<<E as Pairing>::G2>;

Usual aggregate BLS signature scheme on ZCash’s BLS12-381 curve. Usual BLS variant with tiny 48 byte public keys and 96 byte signatures.

We favor this variant because verifiers always perform O(signers) additions on the PublicKeyGroup, or worse 128 bit scalar multiplications with delinearization. We also orient this variant to match zcash’s traits.

Tuple Fields

0: E

Trait Implementations

impl<E: Default + Pairing, P: Default + Bls12Config + CurveExtraConfig> Default for UsualBLS<E, P>

where <P as Bls12Config>::G2Config: WBConfig, WBMap<<P as Bls12Config>::G2Config>: MapToCurve<<E as Pairing>::G2>,

fn default() -> UsualBLS<E, P>

Returns the “default value” for a type.

impl<E: Pairing, P: Bls12Config + CurveExtraConfig> EngineBLS for UsualBLS<E, P>

where <P as Bls12Config>::G2Config: WBConfig, WBMap<<P as Bls12Config>::G2Config>: MapToCurve<<E as Pairing>::G2>,

fn minus_generator_of_public_key_group_prepared() -> Self::PublicKeyPrepared

Prepared negative of the generator of the public key curve.

const PUBLICKEY_SERIALIZED_SIZE: usize = 48usize

const SECRET_KEY_SIZE: usize = 32usize

const CURVE_NAME: &'static [u8] = P::CURVE_NAME

const SIG_GROUP_NAME: &'static [u8] = b"G2"

const CIPHER_SUIT_DOMAIN_SEPARATION: &'static [u8] = b"_XMD:SHA-256_SSWU_RO_"

const SIGNATURE_SERIALIZED_SIZE: usize = 96usize

type Engine = E

type Scalar = <<UsualBLS<E, P> as EngineBLS>::Engine as Pairing>::ScalarField

type PublicKeyGroup = <E as Pairing>::G1

type PublicKeyGroupAffine = <E as Pairing>::G1Affine

type PublicKeyPrepared = <E as Pairing>::G1Prepared

type PublicKeyGroupBaseField = <<E as Pairing>::G1 as CurveGroup>::BaseField

Group where BLS public keys live

type SignatureGroup = <E as Pairing>::G2

type SignatureGroupAffine = <E as Pairing>::G2Affine

type SignaturePrepared = <E as Pairing>::G2Prepared

type SignatureGroupBaseField = <<E as Pairing>::G2 as CurveGroup>::BaseField

Group where BLS signatures live

type HashToSignatureField = DefaultFieldHasher<CoreWrapper<CtVariableCoreWrapper<Sha256VarCore, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, OidSha256>>>

type MapToSignatureCurve = WBMap<<P as Bls12Config>::G2Config>

fn miller_loop<'a, I>(i: I) -> MillerLoopOutput<E>

where I: IntoIterator<Item = &'a (Self::PublicKeyPrepared, Self::SignaturePrepared)>,

Run the Miller loop from Engine but orients its arguments to be a SignatureGroup and PublicKeyGroup.

fn pairing<G1, G2>(p: G1, q: G2) -> E::TargetField

where G1: Into<E::G1Affine>, G2: Into<E::G2Affine>,

Performs a pairing operation e(p, q) by calling Engine::pairing but orients its arguments to be a PublicKeyGroup and SignatureGroup.

fn hash_to_curve_map() -> MapToCurveBasedHasher<Self::SignatureGroup, Self::HashToSignatureField, Self::MapToSignatureCurve>

getter function for the hash to curve map

fn generate<R: Rng + RngCore>(rng: &mut R) -> Self::Scalar

Generate a random scalar for use as a secret key.

fn hash_to_signature_curve<M: Borrow<[u8]>>(message: M) -> Self::SignatureGroup

Hash one message to the signature curve.

fn final_exponentiation( e: MillerLoopOutput<Self::Engine>, ) -> Option<PairingOutput<Self::Engine>>

Perform final exponentiation on the result of a Miller loop.

fn verify_prepared<'a, I>(signature: Self::SignaturePrepared, inputs: I) -> bool

where Self::PublicKeyPrepared: 'a, Self::SignaturePrepared: 'a, I: IntoIterator<Item = &'a (Self::PublicKeyPrepared, Self::SignaturePrepared)>,

Implement verification equation for aggregate BLS signatures provided as prepared points

fn generator_of_signature_group() -> Self::SignatureGroup

return the generator of signature group

fn prepare_public_key( g: impl Into<Self::PublicKeyGroupAffine>, ) -> Self::PublicKeyPrepared

Process the public key to be use in pairing. This has to be implemented by the type of BLS system implementing the engine by calling either prepare_g1 or prepare_g2 based on which group is used by the signature system to host the public key

fn prepare_signature( g: impl Into<Self::SignatureGroupAffine>, ) -> Self::SignaturePrepared

Process the signature to be use in pairing. This has to be implemented by the type of BLS system implementing the engine by calling either prepare_g1 or prepare_g2 based on which group is used by the signature system to host the public key

fn signature_point_to_byte(point: &Self::SignatureGroup) -> Vec<u8>

Serialization helper for various sigma protocols

fn public_key_point_to_byte(point: &Self::PublicKeyGroup) -> Vec<u8>