Benchmarks for ZK proofs

synedrion/Cargo.toml

@@ -40,6 +40,7 @@ serde = { version = "1", default-features = false, features = ["derive"] }
 serde-encoded-bytes = { version = "0.1", default-features = false, features = ["hex", "base64"] }
 bincode = { version = "2.0.0-rc.3", default-features = false, features = ["serde", "alloc"] }
 displaydoc = { version = "0.2", default-features = false }
+criterion = { version = "0.5", optional = true }
 
 [dev-dependencies]
 manul = { git = "https://github.com/entropyxyz/manul.git", rev = "f4c9515eaeb97a17ab3eef908b73be6159f7d9d2", features = ["dev"] }
@@ -51,9 +52,19 @@ k256 = { version = "0.13", default-features = false, features = ["ecdsa", "arith
 impls = "1"
 hex = { version = "0.4", default-features = false, features = ["alloc"] }
 test-log = { version = "0.2.16", default-features = false, features = ["trace", "color"] }
+tracing-subscriber = "0.3.19"
+
+[features]
+private_benches = ["criterion"]
 
 [[bench]]
 bench = true
 name = "bench"
 harness = false
-path = "benches/bench.rs"
+
+
+[[bench]]
+bench = true
+name = "zk_proofs"
+harness = false
+required-features = ["private_benches"]

synedrion/benches/zk_proofs.rs

@@ -0,0 +1,158 @@
+#[cfg(feature = "private_benches")]
+mod bench {
+    use criterion::{criterion_group, Criterion};
+    use rand::SeedableRng;
+    use synedrion::private_benches::*;
+    use tracing_subscriber::EnvFilter;
+
+    fn bench_aff_g(c: &mut Criterion) {
+        use aff_g_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+        let mut group = c.benchmark_group("AffG proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", aff_g_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", aff_g_proof_verify(rng));
+    }
+
+    fn bench_aff_g_star(c: &mut Criterion) {
+        use aff_g_star_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+        let mut group = c.benchmark_group("AffG* proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", aff_g_star_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", aff_g_star_proof_verify(rng));
+    }
+
+    fn bench_dec(c: &mut Criterion) {
+        use dec_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+        let mut group = c.benchmark_group("Dec proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", dec_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", dec_proof_verify(rng));
+    }
+
+    fn bench_elog(c: &mut Criterion) {
+        use elog_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+        let mut group = c.benchmark_group("Elog proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", elog_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", elog_proof_verify(rng));
+    }
+
+    fn bench_enc_elg(c: &mut Criterion) {
+        use enc_elg_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+        let mut group = c.benchmark_group("EncElg proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", enc_elg_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", enc_elg_proof_verify(rng));
+    }
+
+    fn bench_fac(c: &mut Criterion) {
+        use fac_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+
+        let mut group = c.benchmark_group("Fac proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", fac_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", fac_proof_verify(rng));
+    }
+
+    fn bench_paillier_blum_modulus(c: &mut Criterion) {
+        use paillier_blum_modulus_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+        let mut group = c.benchmark_group("Paillier-Blum modulus proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", paillier_blum_modulus_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", paillier_blum_modulus_proof_verify(rng));
+    }
+
+    fn bench_prm(c: &mut Criterion) {
+        use prm_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+        let mut group = c.benchmark_group("Pedersen Ring params (prm) proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", prm_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", prm_proof_verify(rng));
+    }
+
+    fn bench_sch(c: &mut Criterion) {
+        use sch_proof::*;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
+        let mut group = c.benchmark_group("Schnorr (sch) proof");
+        group.sample_size(10);
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("prove", sch_proof_prove(rng));
+
+        let rng = rand_chacha::ChaCha8Rng::seed_from_u64(1234567890);
+        group.bench_function("verify", sch_proof_verify(rng));
+    }
+
+    criterion_group!(
+        benches,
+        bench_aff_g,
+        bench_aff_g_star,
+        bench_dec,
+        bench_elog,
+        bench_enc_elg,
+        bench_fac,
+        bench_paillier_blum_modulus,
+        bench_prm,
+        bench_sch
+    );
+}
+
+criterion::criterion_main!(bench::benches);

synedrion/src/cggmp21.rs

@@ -8,13 +8,13 @@
 //! refers to the version of the paper published at <https://eprint.iacr.org/2021/060.pdf>
 
 mod aux_gen;
-mod conversion;
+pub(crate) mod conversion;
 mod entities;
 mod interactive_signing;
 mod key_init;
 mod key_refresh;
 mod params;
-mod sigma;
+pub(crate) mod sigma;
 
 #[cfg(test)]
 mod aux_gen_tests;
@@ -30,9 +30,13 @@ mod key_refresh_tests;
 
 pub use aux_gen::{AuxGen, AuxGenAssociatedData, AuxGenProtocol};
 pub use entities::{AuxInfo, KeyShare, KeyShareChange};
+
 pub use interactive_signing::{
     InteractiveSigning, InteractiveSigningAssociatedData, InteractiveSigningProtocol, PrehashedMessage,
 };
 pub use key_init::{KeyInit, KeyInitAssociatedData, KeyInitProtocol};
 pub use key_refresh::{KeyRefresh, KeyRefreshAssociatedData, KeyRefreshProtocol};
 pub use params::{ProductionParams112, SchemeParams, TestParams};
+
+#[cfg(feature = "private_benches")]
+pub(crate) use params::PaillierProduction112;

synedrion/src/cggmp21/sigma/aff_g.rs

@@ -256,6 +256,7 @@ impl<P: SchemeParams> AffGProof<P> {
 
 #[cfg(test)]
 mod tests {
+    use manul::{dev::BinaryFormat, session::WireFormat};
     use rand_core::OsRng;
 
     use super::{AffGProof, AffGPublicInputs, AffGSecretInputs};
@@ -311,6 +312,15 @@ mod tests {
             &rp_params,
             &aux,
         );
+
+        // Roundtrip works
+        let res = BinaryFormat::serialize(proof);
+        assert!(res.is_ok());
+        let payload = res.unwrap();
+        let proof: AffGProof<Params> = BinaryFormat::deserialize(&payload).unwrap();
+
+        let rp_params = rp_params.to_wire().to_precomputed();
+
         assert!(proof.verify(
             AffGPublicInputs {
                 pk0,

synedrion/src/cggmp21/sigma/dec.rs

@@ -254,6 +254,7 @@ impl<P: SchemeParams> DecProof<P> {
 
 #[cfg(test)]
 mod tests {
+    use manul::{dev::BinaryFormat, session::WireFormat};
     use rand_core::OsRng;
 
     use super::{DecProof, DecPublicInputs, DecSecretInputs};
@@ -311,6 +312,14 @@ mod tests {
             &setup,
             &aux,
         );
+
+        // Roundtrip works
+        let res = BinaryFormat::serialize(proof);
+        assert!(res.is_ok());
+        let payload = res.unwrap();
+        let proof: DecProof<Params> = BinaryFormat::deserialize(&payload).unwrap();
+        let rp_params = setup.to_wire().to_precomputed();
+
         assert!(proof.verify(
             DecPublicInputs {
                 pk0: pk,
@@ -320,7 +329,7 @@ mod tests {
                 cap_s: &cap_s,
                 cap_g: &cap_g
             },
-            &setup,
+            &rp_params,
             &aux
         ));
     }

synedrion/src/cggmp21/sigma/fac.rs

@@ -200,6 +200,7 @@ impl<P: SchemeParams> FacProof<P> {
 
 #[cfg(test)]
 mod tests {
+    use manul::{dev::BinaryFormat, session::WireFormat};
     use rand_core::OsRng;
 
     use super::FacProof;
@@ -221,6 +222,15 @@ mod tests {
         let aux: &[u8] = b"abcde";
 
         let proof = FacProof::<Params>::new(&mut OsRng, &sk, &setup, &aux);
-        assert!(proof.verify(pk, &setup, &aux));
+
+        // Roundtrip works
+        let res = BinaryFormat::serialize(proof);
+        assert!(res.is_ok());
+        let payload = res.unwrap();
+        let proof: FacProof<Params> = BinaryFormat::deserialize(&payload).unwrap();
+
+        let rp_params = setup.to_wire().to_precomputed();
+        let pubkey = pk.clone().into_wire().into_precomputed();
+        assert!(proof.verify(&pubkey, &rp_params, &aux));
     }
 }

synedrion/src/cggmp21/sigma/mod_.rs

@@ -201,6 +201,7 @@ impl<P: SchemeParams> ModProof<P> {
 
 #[cfg(test)]
 mod tests {
+    use manul::{dev::BinaryFormat, session::WireFormat};
     use rand_core::OsRng;
 
     use super::ModProof;
@@ -220,6 +221,13 @@ mod tests {
         let aux: &[u8] = b"abcde";
 
         let proof = ModProof::<Params>::new(&mut OsRng, &sk, &aux);
+
+        // Roundtrip works
+        let res = BinaryFormat::serialize(proof);
+        assert!(res.is_ok());
+        let payload = res.unwrap();
+        let proof: ModProof<Params> = BinaryFormat::deserialize(&payload).unwrap();
+
         assert!(proof.verify(pk, &aux));
     }
 }