Struct BulletproofGens 

pub struct BulletproofGens<G: AffineRepr> {
    pub gens_capacity: usize,
    pub party_capacity: usize,
    /* private fields */
}

The BulletproofGens struct contains all the generators needed for aggregating up to m range proofs of up to n bits each.

Extensible Generator Generation

Instead of constructing a single vector of size m*n, as described in the Bulletproofs paper, we construct each party’s generators separately.

To construct an arbitrary-length chain of generators, we apply SHAKE256 to a domain separator label, and feed each 64 bytes of XOF output into the ristretto255 hash-to-group function. Each of the m parties’ generators are constructed using a different domain separation label, and proving and verification uses the first n elements of the arbitrary-length chain.

This means that the aggregation size (number of parties) is orthogonal to the rangeproof size (number of bits), and allows using the same BulletproofGens object for different proving parameters.

This construction is also forward-compatible with constraint system proofs, which use a much larger slice of the generator chain, and even forward-compatible to multiparty aggregation of constraint system proofs, since the generators are namespaced by their party index.

Fields

gens_capacity: usize

The maximum number of usable generators for each party.

party_capacity: usize

Number of values or parties

Implementations

impl<G: AffineRepr> BulletproofGens<G>

pub fn new(gens_capacity: usize, party_capacity: usize) -> Self

Create a new BulletproofGens object.

Inputs

• gens_capacity is the number of generators to precompute for each party. For rangeproofs, it is sufficient to pass 64, the maximum bitsize of the rangeproofs. For circuit proofs, the capacity must be greater than the number of multipliers, rounded up to the next power of two.

• party_capacity is the maximum number of parties that can produce an aggregated proof.

pub fn share(&self, j: usize) -> BulletproofGensShare<'_, G>

Returns j-th share of generators, with an appropriate slice of vectors G and H for the j-th range proof.

pub fn increase_capacity(&mut self, new_capacity: usize)

Increases the generators’ capacity to the amount specified. If less than or equal to the current capacity, does nothing.

pub fn G(&self, n: usize, m: usize) -> impl Iterator<Item = &G>

Return an iterator over the aggregation of the parties’ G generators with given size n.

pub fn H(&self, n: usize, m: usize) -> impl Iterator<Item = &G>

Return an iterator over the aggregation of the parties’ H generators with given size n.

Trait Implementations

impl<G: AffineRepr> CanonicalDeserialize for BulletproofGens<G>

fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl<G: AffineRepr> CanonicalSerialize for BulletproofGens<G>

fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl<G: Clone + AffineRepr> Clone for BulletproofGens<G>

fn clone(&self) -> BulletproofGens<G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G: AffineRepr> Valid for BulletproofGens<G>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,