1#![allow(non_snake_case)]
  2
  3extern crate flate2;
  4
  5//use flate2::{write::ZlibEncoder, Compression};
  6use nova_snark::{
  7  traits::{Group, StepCircuit},
  8  CompressedSNARK, PublicParams, RecursiveSNARK,
  9};
 10
 11type G1 = pasta_curves::pallas::Point;
 12type G2 = pasta_curves::vesta::Point;
 13
 14use bellperson::{gadgets::num::AllocatedNum, ConstraintSystem, SynthesisError};
 15use core::marker::PhantomData;
 16use criterion::*;
 17use ff::PrimeField;
 18use std::time::Duration;
 19
 20fn compressed_snark_benchmark(c: &mut Criterion) {
 21  let num_samples = 10;
 22  let num_steps = 3;
 23  bench_compressed_snark(c, num_samples, num_steps);
 24}
 25
 26fn set_duration() -> Criterion {
 27  Criterion::default().warm_up_time(Duration::from_millis(3000))
 28}
 29
 30criterion_group! {
 31name = compressed_snark;
 32config = set_duration();
 33targets = compressed_snark_benchmark
 34}
 35
 36criterion_main!(compressed_snark);
 37
 38fn bench_compressed_snark(c: &mut Criterion, num_samples: usize, num_steps: usize) {
 39  let mut group = c.benchmark_group("CompressedSNARK");
 40  group.sample_size(num_samples);
 41  // Produce public parameters
 42  let pp = PublicParams::<
 43    G1,
 44    G2,
 45    TrivialTestCircuit<<G1 as Group>::Scalar>,
 46    TrivialTestCircuit<<G2 as Group>::Scalar>,
 47  >::setup(
 48    TrivialTestCircuit {
 49      _p: Default::default(),
 50    },
 51    TrivialTestCircuit {
 52      _p: Default::default(),
 53    },
 54  );
 55
 56  // produce a recursive SNARK
 57  let res = RecursiveSNARK::prove(
 58    &pp,
 59    num_steps,
 60    <G1 as Group>::Scalar::zero(),
 61    <G2 as Group>::Scalar::zero(),
 62  );
 63  assert!(res.is_ok());
 64  let recursive_snark = res.unwrap();
 65  // Bench time to produce a compressed SNARK
 66  group.bench_function("Prove", |b| {
 67    b.iter(|| {
 68      assert!(CompressedSNARK::prove(black_box(&pp), black_box(&recursive_snark)).is_ok());
 69    })
 70  });
 71  let res = CompressedSNARK::prove(&pp, &recursive_snark);
 72  assert!(res.is_ok());
 73  let compressed_snark = res.unwrap();
 74
 75  // Output the proof size
 76  //let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
 77  //bincode::serialize_into(&mut encoder, &compressed_snark).unwrap();
 78  //let proof_encoded = encoder.finish().unwrap();
 79  //println!(
 80  //  "ProofSize: {} B",
 81  //  proof_encoded.len(),
 82  //);
 83
 84  // Benchmark the verification time
 85  let name = "Verify";
 86  group.bench_function(name, |b| {
 87    b.iter(|| {
 88      assert!(black_box(&compressed_snark)
 89        .verify(
 90          black_box(&pp),
 91          black_box(num_steps),
 92          black_box(<G1 as Group>::Scalar::zero()),
 93          black_box(<G2 as Group>::Scalar::zero()),
 94        )
 95        .is_ok());
 96    })
 97  });
 98
 99  group.finish();
100}
101
102#[derive(Clone, Debug)]
103struct TrivialTestCircuit<F: PrimeField> {
104  _p: PhantomData<F>,
105}
106
107impl<F> StepCircuit<F> for TrivialTestCircuit<F>
108where
109  F: PrimeField,
110{
111  fn synthesize<CS: ConstraintSystem<F>>(
112    &self,
113    _cs: &mut CS,
114    z: AllocatedNum<F>,
115  ) -> Result<AllocatedNum<F>, SynthesisError> {
116    Ok(z)
117  }
118
119  fn compute(&self, z: &F) -> F {
120    *z
121  }
122}