Merge pull request #61 from str4d/bench-final

Update benchmark to use final Sapling circuit implementation

examples/bench.rs

@@ -8,11 +8,15 @@ use sapling_crypto::jubjub::{
     JubjubBls12,
     edwards,
     fs,
-    Unknown
 };
-use sapling_crypto::circuit::{
+use sapling_crypto::circuit::sapling::{
     Spend
 };
+use sapling_crypto::primitives::{
+    Diversifier,
+    ProofGenerationKey,
+    ValueCommitment
+};
 use bellman::groth16::*;
 use rand::{XorShiftRng, SeedableRng, Rng};
 use pairing::bls12_381::Bls12;
@@ -27,24 +31,11 @@ fn main() {
     let groth_params = generate_random_parameters::<Bls12, _, _>(
         Spend {
             params: jubjub_params,
-            /// Value of the note being spent
+            value_commitment: None,
-            value: None,
+            proof_generation_key: None,
-            /// Randomness that will hide the value
+            payment_address: None,
-            value_randomness: None,
-            /// Key which allows the proof to be constructed
-            /// as defense-in-depth against a flaw in the
-            /// protocol that would otherwise be exploitable
-            /// by a holder of a viewing key.
-            rsk: None,
-            /// The public key that will be re-randomized for
-            /// use as a nullifier and signing key for the
-            /// transaction.
-            ak: None,
-            /// The diversified base used to compute pk_d.
-            g_d: None,
-            /// The randomness used to hide the note commitment data
             commitment_randomness: None,
-            /// The authentication path of the commitment in the tree
+            ar: None,
             auth_path: vec![None; TREE_DEPTH]
         },
         rng
@@ -54,23 +45,48 @@ fn main() {
 
     let mut total_time = Duration::new(0, 0);
     for _ in 0..SAMPLES {
-        let value: u64 = 1;
+        let value_commitment = ValueCommitment {
-        let value_randomness: fs::Fs = rng.gen();
+            value: 1,
-        let ak: edwards::Point<Bls12, Unknown> = edwards::Point::rand(rng, jubjub_params);
+            randomness: rng.gen()
-        let g_d: edwards::Point<Bls12, Unknown> = edwards::Point::rand(rng, jubjub_params);
+        };
+
+        let nsk: fs::Fs = rng.gen();
+        let ak = edwards::Point::rand(rng, jubjub_params).mul_by_cofactor(jubjub_params);
+
+        let proof_generation_key = ProofGenerationKey {
+            ak: ak.clone(),
+            nsk: nsk.clone()
+        };
+
+        let viewing_key = proof_generation_key.into_viewing_key(jubjub_params);
+
+        let payment_address;
+
+        loop {
+            let diversifier = Diversifier(rng.gen());
+
+            if let Some(p) = viewing_key.into_payment_address(
+                diversifier,
+                jubjub_params
+            )
+            {
+                payment_address = p;
+                break;
+            }
+        }
+
         let commitment_randomness: fs::Fs = rng.gen();
-        let rsk: fs::Fs = rng.gen();
+        let auth_path = vec![Some((rng.gen(), rng.gen())); TREE_DEPTH];
-        let auth_path = (0..TREE_DEPTH).map(|_| Some((rng.gen(), rng.gen()))).collect();
+        let ar: fs::Fs = rng.gen();
 
         let start = Instant::now();
         let _ = create_random_proof(Spend {
             params: jubjub_params,
-            value: Some(value),
+            value_commitment: Some(value_commitment),
-            value_randomness: Some(value_randomness),
+            proof_generation_key: Some(proof_generation_key),
-            ak: Some(ak),
+            payment_address: Some(payment_address),
-            g_d: Some(g_d),
             commitment_randomness: Some(commitment_randomness),
-            rsk: Some(rsk),
+            ar: Some(ar),
             auth_path: auth_path
         }, &groth_params, rng).unwrap();
         total_time += start.elapsed();