refactor: remove build.rs and integrate zkey downloading into utils

- Deleted the `build.rs` file, which previously handled downloading semaphore artifacts.
- Introduced a new `download_zkey` function in `utils.rs` to manage zkey downloads.
- Updated `proof.rs` to utilize the new `download_zkey` function for fetching zkeys dynamically based on tree depth.
- Added a new `witness.rs` file to handle witness dispatching based on tree depth.
- Updated `Cargo.toml` to remove `rust-witness` dependency and adjust `circom-prover` to use the latest version from the main branch.
- Added multiple witness graph binary files for different depths.

Author: vivianjeng

Cargo.lock

@@ -11,6 +11,8 @@ thiserror = "2.0.12"
 num-traits = "0.2.19"
 ethers-core = "2.0.14"
 anyhow = "1.0.97"
+reqwest = { version = "0.12.15", features = ["blocking"] }
+openssl = { version = "0.10", features = ["vendored"] }
 
 # arkworks
 ark-ec = { version = "=0.5.0", default-features = false }
@@ -25,16 +27,10 @@ serde = { version = "1", features = ["derive"], optional = true }
 serde_json = "1"
 
 # circom-prover
-rust-witness = "0.1"
-circom-prover = "=0.1.1"
+circom-prover = { git = "https://github.com/zkmopro/mopro.git", branch = "main", features = [
+    "circom-witnesscalc",
+] }
 
 [features]
 default = []
-serde = [
-    "dep:serde",
-    "zk-kit-lean-imt/serde"  
-]
-
-[build-dependencies]
-rust-witness = "0.1"
-reqwest = { version = "0.12.15", features = ["blocking", "json"] } 
+serde = ["dep:serde", "zk-kit-lean-imt/serde"]

Cargo.toml

@@ -9,6 +9,7 @@ pub mod group;
 pub mod identity;
 pub mod proof;
 pub mod utils;
+pub mod witness;
 
 pub const MIN_TREE_DEPTH: u16 = 1;
 pub const MAX_TREE_DEPTH: u16 = 32;

build.rs

@@ -1,29 +1,25 @@
 use crate::{
-    MAX_TREE_DEPTH, MIN_TREE_DEPTH,
-    group::{EMPTY_ELEMENT, Element, Group, MerkleProof},
+    group::{Element, Group, MerkleProof, EMPTY_ELEMENT},
     identity::Identity,
-    utils::{hash, to_big_uint, to_element},
+    utils::{download_zkey, hash, to_big_uint, to_element},
+    witness::dispatch_witness,
+    MAX_TREE_DEPTH, MIN_TREE_DEPTH,
 };
-use anyhow::{Ok, Result, bail};
+use anyhow::{bail, Ok, Result};
 use circom_prover::{
-    CircomProver,
     prover::{
-        CircomProof, ProofLib, PublicInputs,
         circom::{self, CURVE_BN254, G1, G2, PROTOCOL_GROTH16},
+        CircomProof, ProofLib, PublicInputs,
     },
     witness::WitnessFn,
+    CircomProver,
 };
 use num_bigint::BigUint;
-use num_traits::{Zero, identities::One};
-use std::{collections::HashMap, str::FromStr};
-
-// Prepare witness generator
-rust_witness::witness!(semaphore);
+use num_traits::{identities::One, Zero};
+use std::{collections::HashMap, str::FromStr, time::Instant};
 
 pub type PackedGroth16Proof = [BigUint; 8];
 
-const ZKEY_PATH: &str = "./zkey/semaphore.zkey";
-
 pub enum GroupOrMerkleProof {
     Group(Group),
     MerkleProof(MerkleProof),
@@ -112,12 +108,25 @@ impl Proof {
             ("message".to_string(), vec![hash(message_uint.clone())]),
         ]);
 
+        let start = Instant::now();
+        let zkey_path = download_zkey(merkle_tree_depth).expect("Failed to download zkey");
+        let duration = start.elapsed();
+        println!("download zkey time: {:?}", duration.as_micros());
+
+        let start = Instant::now();
+        let witness_fn = dispatch_witness(merkle_tree_depth);
+        let duration = start.elapsed();
+        println!("dispatch witness time: {:?}", duration.as_micros());
+
+        let start = Instant::now();
         let circom_proof = CircomProver::prove(
             ProofLib::Arkworks,
-            WitnessFn::RustWitness(semaphore_witness),
+            WitnessFn::CircomWitnessCalc(witness_fn),
             serde_json::to_string(&inputs).unwrap(),
-            ZKEY_PATH.to_string(),
+            zkey_path,
         )?;
+        let duration = start.elapsed();
+        println!("semaphore proof time: {:?}", duration.as_micros());
 
         Ok(SemaphoreProof {
             merkle_tree_depth,
@@ -148,7 +157,8 @@ impl Proof {
             pub_inputs,
         };
 
-        CircomProver::verify(ProofLib::Arkworks, p, ZKEY_PATH.to_string()).unwrap()
+        let zkey_path = download_zkey(proof.merkle_tree_depth).expect("Failed to download zkey");
+        CircomProver::verify(ProofLib::Arkworks, p, zkey_path).unwrap()
     }
 
     pub fn pack_groth16_proof(p: circom::Proof) -> PackedGroth16Proof {
@@ -390,6 +400,27 @@ mod tests {
             assert!(Proof::verify_proof(proof))
         }
 
+        #[test]
+        fn test_verify_proof_with_different_depth() {
+            for depth in MIN_TREE_DEPTH..=MAX_TREE_DEPTH {
+                println!("Testing depth: {}", depth);
+                let identity = Identity::new("secret".as_bytes());
+                let group =
+                    Group::new(&[MEMBER1, MEMBER2, to_element(*identity.commitment())]).unwrap();
+
+                let proof = Proof::generate_proof(
+                    identity,
+                    GroupOrMerkleProof::Group(group),
+                    MESSAGE.to_string(),
+                    SCOPE.to_string(),
+                    depth as u16,
+                )
+                .unwrap();
+
+                assert!(Proof::verify_proof(proof));
+            }
+        }
+
         #[test]
         fn test_panic_verify_invalid_tree_depth() {
             let identity = Identity::new("secret".as_bytes());

src/lib.rs

@@ -2,8 +2,12 @@ use ark_ed_on_bn254::Fq;
 use ark_ff::{BigInteger, PrimeField};
 use ethers_core::utils::keccak256;
 use num_bigint::BigUint;
+use reqwest::blocking::Client;
+use std::error::Error;
+use std::fs::File;
+use std::io::copy;
 
-use crate::group::{EMPTY_ELEMENT, Element};
+use crate::group::{Element, EMPTY_ELEMENT};
 
 pub fn string_to_biguint(num_str: &str) -> BigUint {
     num_str
@@ -33,3 +37,21 @@ pub fn to_element(value: Fq) -> Element {
     element[..bytes.len()].copy_from_slice(&bytes);
     element
 }
+
+/// Download zkey from artifacts: https://snark-artifacts.pse.dev/
+pub fn download_zkey(depth: u16) -> Result<String, Box<dyn Error>> {
+    let base_url = "https://snark-artifacts.pse.dev/semaphore/latest/";
+    let filename = format!("semaphore-{}.zkey", depth);
+    let out_dir = std::env::temp_dir();
+    let dest_path = out_dir.join(filename.clone());
+    if dest_path.exists() {
+        return Ok(dest_path.to_string_lossy().into_owned());
+    }
+    let url = format!("{}{}", base_url, filename);
+    let client = Client::new();
+    let mut resp = client.get(&url).send()?.error_for_status()?;
+    let mut out = File::create(&dest_path)?;
+    copy(&mut resp, &mut out)?;
+    eprintln!("Saved as {}", dest_path.display());
+    Ok(dest_path.to_string_lossy().into_owned())
+}

src/proof.rs

@@ -0,0 +1,135 @@
+use circom_prover::graph;
+
+pub fn dispatch_witness(depth: u16) -> fn(&str) -> anyhow::Result<Vec<u8>> {
+    match depth {
+        1_u16 => {
+            graph!(semaphore1, "../witness_graph/semaphore-1.bin");
+            semaphore1_witness
+        }
+        2_u16 => {
+            graph!(semaphore2, "../witness_graph/semaphore-2.bin");
+            semaphore2_witness
+        }
+        3_u16 => {
+            graph!(semaphore3, "../witness_graph/semaphore-3.bin");
+            semaphore3_witness
+        }
+        4_u16 => {
+            graph!(semaphore4, "../witness_graph/semaphore-4.bin");
+            semaphore4_witness
+        }
+        5_u16 => {
+            graph!(semaphore5, "../witness_graph/semaphore-5.bin");
+            semaphore5_witness
+        }
+        6_u16 => {
+            graph!(semaphore6, "../witness_graph/semaphore-6.bin");
+            semaphore6_witness
+        }
+        7_u16 => {
+            graph!(semaphore7, "../witness_graph/semaphore-7.bin");
+            semaphore7_witness
+        }
+        8_u16 => {
+            graph!(semaphore8, "../witness_graph/semaphore-8.bin");
+            semaphore8_witness
+        }
+        9_u16 => {
+            graph!(semaphore9, "../witness_graph/semaphore-9.bin");
+            semaphore9_witness
+        }
+        10_u16 => {
+            graph!(semaphore10, "../witness_graph/semaphore-10.bin");
+            semaphore10_witness
+        }
+        11_u16 => {
+            graph!(semaphore11, "../witness_graph/semaphore-11.bin");
+            semaphore11_witness
+        }
+        12_u16 => {
+            graph!(semaphore12, "../witness_graph/semaphore-12.bin");
+            semaphore12_witness
+        }
+        13_u16 => {
+            graph!(semaphore13, "../witness_graph/semaphore-13.bin");
+            semaphore13_witness
+        }
+        14_u16 => {
+            graph!(semaphore14, "../witness_graph/semaphore-14.bin");
+            semaphore14_witness
+        }
+        15_u16 => {
+            graph!(semaphore15, "../witness_graph/semaphore-15.bin");
+            semaphore15_witness
+        }
+        16_u16 => {
+            graph!(semaphore16, "../witness_graph/semaphore-16.bin");
+            semaphore16_witness
+        }
+        17_u16 => {
+            graph!(semaphore17, "../witness_graph/semaphore-17.bin");
+            semaphore17_witness
+        }
+        18_u16 => {
+            graph!(semaphore18, "../witness_graph/semaphore-18.bin");
+            semaphore18_witness
+        }
+        19_u16 => {
+            graph!(semaphore19, "../witness_graph/semaphore-19.bin");
+            semaphore19_witness
+        }
+        20_u16 => {
+            graph!(semaphore20, "../witness_graph/semaphore-20.bin");
+            semaphore20_witness
+        }
+        21_u16 => {
+            graph!(semaphore21, "../witness_graph/semaphore-21.bin");
+            semaphore21_witness
+        }
+        22_u16 => {
+            graph!(semaphore22, "../witness_graph/semaphore-22.bin");
+            semaphore22_witness
+        }
+        23_u16 => {
+            graph!(semaphore23, "../witness_graph/semaphore-23.bin");
+            semaphore23_witness
+        }
+        24_u16 => {
+            graph!(semaphore24, "../witness_graph/semaphore-24.bin");
+            semaphore24_witness
+        }
+        25_u16 => {
+            graph!(semaphore25, "../witness_graph/semaphore-25.bin");
+            semaphore25_witness
+        }
+        26_u16 => {
+            graph!(semaphore26, "../witness_graph/semaphore-26.bin");
+            semaphore26_witness
+        }
+        27_u16 => {
+            graph!(semaphore27, "../witness_graph/semaphore-27.bin");
+            semaphore27_witness
+        }
+        28_u16 => {
+            graph!(semaphore28, "../witness_graph/semaphore-28.bin");
+            semaphore28_witness
+        }
+        29_u16 => {
+            graph!(semaphore29, "../witness_graph/semaphore-29.bin");
+            semaphore29_witness
+        }
+        30_u16 => {
+            graph!(semaphore30, "../witness_graph/semaphore-30.bin");
+            semaphore30_witness
+        }
+        31_u16 => {
+            graph!(semaphore31, "../witness_graph/semaphore-31.bin");
+            semaphore31_witness
+        }
+        32_u16 => {
+            graph!(semaphore32, "../witness_graph/semaphore-32.bin");
+            semaphore32_witness
+        }
+        _ => panic!("Unsupported depth"),
+    }
+}