Struct TinyBLS

pub struct TinyBLS<E: Pairing, P: Bls12Config + CurveExtraConfig>(pub E, _)
where
    <P as Bls12Config>::G1Config: WBConfig,
    WBMap<<P as Bls12Config>::G1Config>: MapToCurve<<E as Pairing>::G1>;

Infrequently used BLS variant with tiny 48 byte signatures and 96 byte public keys,

We recommend gainst this variant by default because verifiers always perform O(signers) additions on the PublicKeyGroup, or worse 128 bit scalar multiplications with delinearization. Yet, there are specific use cases where this variant performs better. We swapy two group roles relative to zcash here.

Tuple Fields

0: E

Trait Implementations

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

where <P as Bls12Config>::G1Config: WBConfig, WBMap<<P as Bls12Config>::G1Config>: MapToCurve<<E as Pairing>::G1>,

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

Returns the “default value” for a type.

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

where <P as Bls12Config>::G1Config: WBConfig, WBMap<<P as Bls12Config>::G1Config>: MapToCurve<<E as Pairing>::G1>,

fn minus_generator_of_public_key_group_prepared() -> Self::PublicKeyPrepared

Prepared negative of the generator of the public key curve.

const SIGNATURE_SERIALIZED_SIZE: usize = 48usize

const PUBLICKEY_SERIALIZED_SIZE: usize = 96usize

const SECRET_KEY_SIZE: usize = 32usize

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

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

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

type Engine = E

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

type SignatureGroup = <E as Pairing>::G1

type SignatureGroupAffine = <E as Pairing>::G1Affine

type SignaturePrepared = <E as Pairing>::G1Prepared

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

Group where BLS signatures live

type PublicKeyGroup = <E as Pairing>::G2

type PublicKeyGroupAffine = <E as Pairing>::G2Affine

type PublicKeyPrepared = <E as Pairing>::G2Prepared

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

Group where BLS public keys 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>::G1Config>

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<G2, G1>(p: G2, q: G1) -> 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>