1extern crate libspartan;
  2extern crate merlin;
  3
  4use libspartan::{
  5    parameters::poseidon_params, poseidon_transcript::PoseidonTranscript, Instance, SNARKGens,
  6    SNARK,
  7};
  8
  9use criterion::*;
 10
 11fn snark_encode_benchmark(c: &mut Criterion) {
 12    for &s in [10, 12, 16].iter() {
 13        let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 14        let mut group = c.benchmark_group("SNARK_encode_benchmark");
 15        group.plot_config(plot_config);
 16
 17        let num_vars = (2_usize).pow(s as u32);
 18        let num_cons = num_vars;
 19        let num_inputs = 10;
 20        let (inst, _vars, _inputs) =
 21            Instance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
 22
 23        // produce public parameters
 24        let gens = SNARKGens::new(num_cons, num_vars, num_inputs, num_cons);
 25
 26        // produce a commitment to R1CS instance
 27        let name = format!("SNARK_encode_{}", num_cons);
 28        group.bench_function(&name, move |b| {
 29            b.iter(|| {
 30                SNARK::encode(black_box(&inst), black_box(&gens));
 31            });
 32        });
 33        group.finish();
 34    }
 35}
 36
 37fn snark_prove_benchmark(c: &mut Criterion) {
 38    for &s in [10, 12, 16].iter() {
 39        let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 40        let mut group = c.benchmark_group("SNARK_prove_benchmark");
 41        group.plot_config(plot_config);
 42
 43        let num_vars = (2_usize).pow(s as u32);
 44        let num_cons = num_vars;
 45        let num_inputs = 10;
 46
 47        let params = poseidon_params();
 48
 49        let (inst, vars, inputs) = Instance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
 50
 51        // produce public parameters
 52        let gens = SNARKGens::new(num_cons, num_vars, num_inputs, num_cons);
 53
 54        // produce a commitment to R1CS instance
 55        let (comm, decomm) = SNARK::encode(&inst, &gens);
 56
 57        // produce a proof
 58        let name = format!("SNARK_prove_{}", num_cons);
 59        group.bench_function(&name, move |b| {
 60            b.iter(|| {
 61                let mut prover_transcript = PoseidonTranscript::new(&params);
 62                SNARK::prove(
 63                    black_box(&inst),
 64                    black_box(&comm),
 65                    black_box(&decomm),
 66                    black_box(vars.clone()),
 67                    black_box(&inputs),
 68                    black_box(&gens),
 69                    black_box(&mut prover_transcript),
 70                );
 71            });
 72        });
 73        group.finish();
 74    }
 75}
 76
 77fn snark_verify_benchmark(c: &mut Criterion) {
 78    for &s in [10, 12, 16].iter() {
 79        let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 80        let mut group = c.benchmark_group("SNARK_verify_benchmark");
 81        group.plot_config(plot_config);
 82
 83        let params = poseidon_params();
 84
 85        let num_vars = (2_usize).pow(s as u32);
 86        let num_cons = num_vars;
 87        let num_inputs = 10;
 88        let (inst, vars, inputs) = Instance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
 89
 90        // produce public parameters
 91        let gens = SNARKGens::new(num_cons, num_vars, num_inputs, num_cons);
 92
 93        // produce a commitment to R1CS instance
 94        let (comm, decomm) = SNARK::encode(&inst, &gens);
 95
 96        // produce a proof of satisfiability
 97        let mut prover_transcript = PoseidonTranscript::new(&params);
 98        let proof = SNARK::prove(
 99            &inst,
100            &comm,
101            &decomm,
102            vars,
103            &inputs,
104            &gens,
105            &mut prover_transcript,
106        );
107
108        // verify the proof
109        let name = format!("SNARK_verify_{}", num_cons);
110        group.bench_function(&name, move |b| {
111            b.iter(|| {
112                let mut verifier_transcript = PoseidonTranscript::new(&params);
113                assert!(proof
114                    .verify(
115                        black_box(&comm),
116                        black_box(&inputs),
117                        black_box(&mut verifier_transcript),
118                        black_box(&gens)
119                    )
120                    .is_ok());
121            });
122        });
123        group.finish();
124    }
125}
126
127fn set_duration() -> Criterion {
128    Criterion::default().sample_size(10)
129}
130
131criterion_group! {
132name = benches_snark;
133config = set_duration();
134targets =  snark_verify_benchmark
135}
136
137criterion_main!(benches_snark);