Struct bellperson::groth16::aggregate::GenericSRS

pub struct GenericSRS<E: Engine> {
    pub g_alpha_powers: Vec<E::G1Affine>,
    pub h_alpha_powers: Vec<E::G2Affine>,
    pub g_beta_powers: Vec<E::G1Affine>,
    pub h_beta_powers: Vec<E::G2Affine>,
}

It contains the maximum number of raw elements of the SRS needed to aggregate and verify Groth16 proofs. One can derive specialized prover and verifier key for specific size of aggregations by calling srs.specialize(n). The specialized prover key also contains precomputed tables that drastically increase prover’s performance. This GenericSRS is usually formed from the transcript of two distinct power of taus ceremony ,in other words from two distinct Groth16 CRS. See there a way on how to generate this GenesisSRS.

Fields

g_alpha_powers: Vec<E::G1Affine>

${g^a^i}_{i=0}^{N}$ where N is the smallest size of the two Groth16 CRS.

h_alpha_powers: Vec<E::G2Affine>

${h^a^i}_{i=0}^{N}$ where N is the smallest size of the two Groth16 CRS.

g_beta_powers: Vec<E::G1Affine>

${g^b^i}_{i=n}^{N}$ where N is the smallest size of the two Groth16 CRS.

h_beta_powers: Vec<E::G2Affine>

${h^b^i}_{i=0}^{N}$ where N is the smallest size of the two Groth16 CRS.

Implementations

impl<E: Engine> GenericSRS<E>

pub fn specialize(&self, num_proofs: usize) -> (ProverSRS<E>, VerifierSRS<E>)

specializes returns the prover and verifier SRS for a specific number of proofs to aggregate. The number of proofs MUST BE a power of two, it panics otherwise. The number of proofs must be inferior to half of the size of the generic srs otherwise it panics.

pub fn write<W: Write>(&self, writer: &mut W) -> Result<()>

pub fn hash(&self) -> Vec<u8>

Returns the hash over all powers of this generic srs.

pub fn read<R: Read>(reader: &mut R) -> Result<Self>

pub fn read_mmap(reader: &Mmap, max_len: usize) -> Result<Self>

Trait Implementations

impl<E: Clone + Engine> Clone for GenericSRS<E> where
    E::G1Affine: Clone,
    E::G2Affine: Clone,
    E::G1Affine: Clone,
    E::G2Affine: Clone, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Engine> Debug for GenericSRS<E> where
    E::G1Affine: Debug,
    E::G2Affine: Debug,
    E::G1Affine: Debug,
    E::G2Affine: Debug, 

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

Formats the value using the given formatter.

impl<E: Engine> PartialEq<GenericSRS<E>> for GenericSRS<E>

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.