Rename Generators to BulletproofGens

Author: hdevalence

benches/bulletproofs.rs

@@ -12,7 +12,7 @@ use curve25519_dalek::scalar::Scalar;
 extern crate bulletproofs;
 use bulletproofs::RangeProof;
 use bulletproofs::Transcript;
-use bulletproofs::{Generators, PedersenGenerators};
+use bulletproofs::{BulletproofGens, PedersenGens};
 
 static AGGREGATION_SIZES: [usize; 6] = [1, 2, 4, 8, 16, 32];
 
@@ -22,7 +22,7 @@ fn create_aggregated_rangeproof_helper(n: usize, c: &mut Criterion) {
     c.bench_function_over_inputs(
         &label,
         move |b, &&m| {
-            let generators = Generators::new(PedersenGenerators::default(), n, m);
+            let generators = BulletproofGens::new(PedersenGens::default(), n, m);
             let mut rng = OsRng::new().unwrap();
 
             let (min, max) = (0u64, ((1u128 << n) - 1) as u64);
@@ -69,7 +69,7 @@ fn verify_aggregated_rangeproof_helper(n: usize, c: &mut Criterion) {
     c.bench_function_over_inputs(
         &label,
         move |b, &&m| {
-            let generators = Generators::new(PedersenGenerators::default(), n, m);
+            let generators = BulletproofGens::new(PedersenGens::default(), n, m);
             let mut rng = OsRng::new().unwrap();
 
             let (min, max) = (0u64, ((1u128 << n) - 1) as u64);

src/generators.rs

@@ -81,10 +81,10 @@ impl Iterator for GeneratorsChain {
     }
 }
 
-/// The `Generators` struct contains all the generators needed for
+/// The `BulletproofGens` struct contains all the generators needed for
 /// aggregating `m` range proofs of `n` bits each.
 #[derive(Clone)]
-pub struct Generators {
+pub struct BulletproofGens {
     /// Bases for Pedersen commitments
     pub pedersen_gens: PedersenGens,
     /// The maximum number of usable generators for each party.
@@ -97,8 +97,8 @@ pub struct Generators {
     H_vec: Vec<Vec<RistrettoPoint>>,
 }
 
-impl Generators {
-    /// Create a new `Generators` object.
+impl BulletproofGens {
+    /// Create a new `BulletproofGens` object.
     ///
     /// # Inputs
     ///
@@ -140,7 +140,7 @@ impl Generators {
                     .collect::<Vec<_>>()
             }).collect();
 
-        Generators {
+        BulletproofGens {
             pedersen_gens,
             gens_capacity,
             party_capacity,
@@ -214,17 +214,17 @@ impl<'a> Iterator for AggregatedGensIter<'a> {
     }
 }
 
-/// The `BulletproofGensShare` is produced by `Generators::share()`.
+/// The `BulletproofGensShare` is produced by `BulletproofGens::share()`.
 ///
-/// The `Generators` struct represents generators for an aggregated
+/// The `BulletproofGens` struct represents generators for an aggregated
 /// range proof `m` proofs of `n` bits each; the `BulletproofGensShare`
 /// represents the generators for one of the `m` parties' shares.
 #[derive(Copy, Clone)]
 pub struct BulletproofGensShare<'a> {
     /// Bases for Pedersen commitments
     pub pedersen_gens: &'a PedersenGens,
     /// The parent object that this is a view into
-    gens: &'a Generators,
+    gens: &'a BulletproofGens,
     /// Which share we are
     share: usize,
 }
@@ -248,7 +248,7 @@ mod tests {
 
     #[test]
     fn aggregated_gens_iter_matches_flat_map() {
-        let gens = Generators::new(PedersenGens::default(), 64, 8);
+        let gens = BulletproofGens::new(PedersenGens::default(), 64, 8);
 
         let helper = |n: usize, m: usize| {
             let agg_G: Vec<RistrettoPoint> = gens.G(n, m).cloned().collect();

src/inner_product_proof.rs

@@ -336,8 +336,8 @@ mod tests {
     fn test_helper_create(n: usize) {
         let mut rng = OsRng::new().unwrap();
 
-        use generators::{Generators, PedersenGens};
-        let gens = Generators::new(PedersenGens::default(), n, 1);
+        use generators::{BulletproofGens, PedersenGens};
+        let gens = BulletproofGens::new(PedersenGens::default(), n, 1);
         let G: Vec<RistrettoPoint> = gens.share(0).G(n).cloned().collect();
         let H: Vec<RistrettoPoint> = gens.share(0).H(n).cloned().collect();
 

src/lib.rs

@@ -41,7 +41,7 @@ mod transcript;
 pub use merlin::Transcript;
 
 pub use errors::ProofError;
-pub use generators::{Generators, BulletproofGensShare, PedersenGens};
+pub use generators::{BulletproofGens, BulletproofGensShare, PedersenGens};
 pub use range_proof::RangeProof;
 
 #[doc(include = "../docs/aggregation-api.md")]

src/range_proof/dealer.rs

@@ -10,7 +10,7 @@ use merlin::Transcript;
 use rand::{CryptoRng, Rng};
 
 use errors::MPCError;
-use generators::Generators;
+use generators::BulletproofGens;
 use inner_product_proof;
 use range_proof::RangeProof;
 use transcript::TranscriptProtocol;
@@ -25,7 +25,7 @@ pub struct Dealer {}
 impl Dealer {
     /// Creates a new dealer coordinating `m` parties proving `n`-bit ranges.
     pub fn new<'a, 'b>(
-        gens: &'b Generators,
+        gens: &'b BulletproofGens,
         n: usize,
         m: usize,
         transcript: &'a mut Transcript,
@@ -78,7 +78,7 @@ pub struct DealerAwaitingValueCommitments<'a, 'b> {
     /// The dealer keeps a copy of the initial transcript state, so
     /// that it can attempt to verify the aggregated proof at the end.
     initial_transcript: Transcript,
-    gens: &'b Generators,
+    gens: &'b BulletproofGens,
 }
 
 impl<'a, 'b> DealerAwaitingValueCommitments<'a, 'b> {
@@ -130,7 +130,7 @@ pub struct DealerAwaitingPolyCommitments<'a, 'b> {
     m: usize,
     transcript: &'a mut Transcript,
     initial_transcript: Transcript,
-    gens: &'b Generators,
+    gens: &'b BulletproofGens,
     value_challenge: ValueChallenge,
     value_commitments: Vec<ValueCommitment>,
     /// Aggregated commitment to the parties' bits
@@ -184,7 +184,7 @@ pub struct DealerAwaitingProofShares<'a, 'b> {
     m: usize,
     transcript: &'a mut Transcript,
     initial_transcript: Transcript,
-    gens: &'b Generators,
+    gens: &'b BulletproofGens,
     value_challenge: ValueChallenge,
     value_commitments: Vec<ValueCommitment>,
     poly_challenge: PolyChallenge,

src/range_proof/messages.rs

@@ -7,7 +7,7 @@
 use curve25519_dalek::ristretto::RistrettoPoint;
 use curve25519_dalek::scalar::Scalar;
 
-use generators::Generators;
+use generators::BulletproofGens;
 
 /// XXX rename this to `BitCommitment`
 #[derive(Serialize, Deserialize, Copy, Clone, Debug)]
@@ -49,7 +49,7 @@ impl ProofShare {
     /// malformed.
     pub(crate) fn audit_share(
         &self,
-        gens: &Generators,
+        gens: &BulletproofGens,
         j: usize,
         value_commitment: &ValueCommitment,
         value_challenge: &ValueChallenge,

src/range_proof/mod.rs

@@ -11,7 +11,7 @@ use curve25519_dalek::traits::{IsIdentity, VartimeMultiscalarMul};
 use merlin::Transcript;
 
 use errors::ProofError;
-use generators::Generators;
+use generators::BulletproofGens;
 use inner_product_proof::InnerProductProof;
 use transcript::TranscriptProtocol;
 use util;
@@ -52,7 +52,7 @@ impl RangeProof {
     ///
     /// XXX add doctests
     pub fn prove_single<R: Rng + CryptoRng>(
-        generators: &Generators,
+        generators: &BulletproofGens,
         transcript: &mut Transcript,
         rng: &mut R,
         v: u64,
@@ -66,7 +66,7 @@ impl RangeProof {
     ///
     /// XXX add doctests
     pub fn prove_multiple<R: Rng + CryptoRng>(
-        generators: &Generators,
+        generators: &BulletproofGens,
         transcript: &mut Transcript,
         rng: &mut R,
         values: &[u64],
@@ -134,7 +134,7 @@ impl RangeProof {
     pub fn verify_single<R: Rng + CryptoRng>(
         &self,
         V: &RistrettoPoint,
-        gens: &Generators,
+        gens: &BulletproofGens,
         transcript: &mut Transcript,
         rng: &mut R,
         n: usize,
@@ -148,7 +148,7 @@ impl RangeProof {
     pub fn verify<R: Rng + CryptoRng>(
         &self,
         value_commitments: &[RistrettoPoint],
-        gens: &Generators,
+        gens: &BulletproofGens,
         transcript: &mut Transcript,
         rng: &mut R,
         n: usize,
@@ -413,7 +413,7 @@ mod tests {
         // Both prover and verifier have access to the generators and the proof
         let max_bitsize = 64;
         let max_parties = 8;
-        let generators = Generators::new(PedersenGens::default(), max_bitsize, max_parties);
+        let generators = BulletproofGens::new(PedersenGens::default(), max_bitsize, max_parties);
 
         // Serialized proof data
         let proof_bytes: Vec<u8>;
@@ -532,7 +532,7 @@ mod tests {
         let m = 4;
         let n = 32;
 
-        let generators = Generators::new(PedersenGens::default(), n, m);
+        let generators = BulletproofGens::new(PedersenGens::default(), n, m);
 
         let mut rng = OsRng::new().unwrap();
         let mut transcript = Transcript::new(b"AggregatedRangeProofTest");
@@ -602,7 +602,7 @@ mod tests {
         let m = 1;
         let n = 32;
 
-        let generators = Generators::new(PedersenGens::default(), n, m);
+        let generators = BulletproofGens::new(PedersenGens::default(), n, m);
 
         let mut rng = OsRng::new().unwrap();
         let mut transcript = Transcript::new(b"AggregatedRangeProofTest");

src/range_proof/party.rs

@@ -9,7 +9,7 @@ use curve25519_dalek::scalar::Scalar;
 use curve25519_dalek::traits::MultiscalarMul;
 
 use errors::MPCError;
-use generators::Generators;
+use generators::BulletproofGens;
 use rand::{CryptoRng, Rng};
 use std::iter;
 use util;
@@ -24,7 +24,7 @@ impl Party {
         v: u64,
         v_blinding: Scalar,
         n: usize,
-        generators: &Generators,
+        generators: &BulletproofGens,
     ) -> Result<PartyAwaitingPosition, MPCError> {
         if !(n == 8 || n == 16 || n == 32 || n == 64) {
             return Err(MPCError::InvalidBitsize);
@@ -44,7 +44,7 @@ impl Party {
 
 /// As party awaits its position, they only know their value and desired bit-size of the proof.
 pub struct PartyAwaitingPosition<'a> {
-    generators: &'a Generators,
+    generators: &'a BulletproofGens,
     n: usize,
     v: u64,
     v_blinding: Scalar,
@@ -119,7 +119,7 @@ pub struct PartyAwaitingValueChallenge<'a> {
     v_blinding: Scalar,
 
     j: usize,
-    generators: &'a Generators,
+    generators: &'a BulletproofGens,
     a_blinding: Scalar,
     s_blinding: Scalar,
     s_L: Vec<Scalar>,