chore(rln): onchain tree poc

.github/workflows/ci.yml

@@ -3,20 +3,27 @@ on:
     branches:
       - master
     paths-ignore:
-      - "**.md"
-      - "!.github/workflows/*.yml"
-      - "!rln-wasm/**"
-      - "!rln/src/**"
-      - "!rln/resources/**"
-      - "!utils/src/**"
+      - '**.md'
+      - '!.github/workflows/*.yml'
+      - '!multiplier/src/**'
+      - '!private-settlement/src/**'
+      - '!rln-wasm/**'
+      - '!rln/src/**'
+      - '!rln/resources/**'
+      - '!semaphore/src/**'
+      - '!utils/src/**'
   pull_request:
     paths-ignore:
-      - "**.md"
-      - "!.github/workflows/*.yml"
-      - "!rln-wasm/**"
-      - "!rln/src/**"
-      - "!rln/resources/**"
-      - "!utils/src/**"
+      - '**.md'
+      - '!.github/workflows/*.yml'
+      - '!multiplier/src/**'
+      - '!private-settlement/src/**'
+      - '!rln-wasm/**'
+      - '!rln/src/**'
+      - '!rln/resources/**'
+      - '!semaphore/src/**'
+      - '!utils/src/**'
+
 
 name: Tests
 
@@ -25,10 +32,10 @@ jobs:
     strategy:
       matrix:
         platform: [ubuntu-latest, macos-latest]
-        crate: [rln, utils]
+        crate: [multiplier, semaphore, rln, utils]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
-
+  
     name: test - ${{ matrix.crate }} - ${{ matrix.platform }}
     steps:
       - name: Checkout sources
@@ -44,16 +51,16 @@ jobs:
         run: make installdeps
       - name: cargo-make test
         run: |
-          cargo make test --release
+            cargo make test --release
         working-directory: ${{ matrix.crate }}
-
+  
   rln-wasm:
     strategy:
       matrix:
         platform: [ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
-
+  
     name: test - rln-wasm - ${{ matrix.platform }}
     steps:
       - uses: actions/checkout@v3
@@ -78,11 +85,11 @@ jobs:
       matrix:
         # we run lint tests only on ubuntu
         platform: [ubuntu-latest]
-        crate: [rln, utils]
+        crate: [multiplier, semaphore, rln, utils]
     runs-on: ${{ matrix.platform }}
     timeout-minutes: 60
 
-    name: lint - ${{ matrix.crate }} - ${{ matrix.platform }}
+    name: lint - ${{ matrix.crate }} - ${{ matrix.platform }}  
     steps:
       - name: Checkout sources
         uses: actions/checkout@v3
@@ -103,7 +110,7 @@ jobs:
       - name: cargo clippy
         if: success() || failure()
         run: |
-          cargo clippy --release -- -D warnings
+            cargo clippy --release -- -D warnings
         working-directory: ${{ matrix.crate }}
         # We skip clippy on rln-wasm, since wasm target is managed by cargo make
         # Currently not treating warnings as error, too noisy
@@ -127,4 +134,4 @@ jobs:
       - uses: boa-dev/criterion-compare-action@v3
         with:
           branchName: ${{ github.base_ref }}
-          cwd: ${{ matrix.crate }}
+          cwd: ${{ matrix.crate }}

.github/workflows/nightly-release.yml

@@ -8,8 +8,7 @@ jobs:
   linux:
     strategy:
       matrix:
-        feature: ["default", "arkzkey"]
-        target:
+        target: 
           - x86_64-unknown-linux-gnu
           - aarch64-unknown-linux-gnu
           - i686-unknown-linux-gnu
@@ -30,16 +29,16 @@ jobs:
         run: make installdeps
       - name: cross build
         run: |
-          cross build --release --target ${{ matrix.target }} --features ${{ matrix.feature }} --workspace --exclude rln-wasm
+          cross build --release --target ${{ matrix.target }} --workspace --exclude rln-wasm
           mkdir release
           cp target/${{ matrix.target }}/release/librln* release/
-          tar -czvf ${{ matrix.target }}-${{ matrix.feature }}-rln.tar.gz release/
+          tar -czvf ${{ matrix.target }}-rln.tar.gz release/
 
       - name: Upload archive artifact
         uses: actions/upload-artifact@v2
         with:
-          name: ${{ matrix.target }}-${{ matrix.feature }}-archive
-          path: ${{ matrix.target }}-${{ matrix.feature }}-rln.tar.gz
+          name: ${{ matrix.target }}-archive
+          path: ${{ matrix.target }}-rln.tar.gz
           retention-days: 2
 
   macos:
@@ -47,8 +46,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        feature: ["default", "arkzkey"]
-        target:
+        target: 
           - x86_64-apple-darwin
           - aarch64-apple-darwin
     steps:
@@ -66,18 +64,18 @@ jobs:
         run: make installdeps
       - name: cross build
         run: |
-          cross build --release --target ${{ matrix.target }} --features ${{ matrix.feature }} --workspace --exclude rln-wasm
+          cross build --release --target ${{ matrix.target }} --workspace --exclude rln-wasm
           mkdir release
           cp target/${{ matrix.target }}/release/librln* release/
-          tar -czvf ${{ matrix.target }}-${{ matrix.feature }}-rln.tar.gz release/
+          tar -czvf ${{ matrix.target }}-rln.tar.gz release/
 
       - name: Upload archive artifact
         uses: actions/upload-artifact@v2
         with:
-          name: ${{ matrix.target }}-${{ matrix.feature }}-archive
-          path: ${{ matrix.target }}-${{ matrix.feature }}-rln.tar.gz
+          name: ${{ matrix.target }}-archive
+          path: ${{ matrix.target }}-rln.tar.gz
           retention-days: 2
-
+  
   browser-rln-wasm:
     name: Browser build (RLN WASM)
     runs-on: ubuntu-latest
@@ -110,6 +108,7 @@ jobs:
           path: rln-wasm/browser-rln-wasm.tar.gz
           retention-days: 2
 
+
   prepare-prerelease:
     name: Prepare pre-release
     needs: [linux, macos, browser-rln-wasm]
@@ -121,7 +120,7 @@ jobs:
           ref: master
       - name: Download artifacts
         uses: actions/download-artifact@v2
-
+          
       - name: Delete tag
         uses: dev-drprasad/delete-tag-and-release@v0.2.1
         with:

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "semaphore/vendor/semaphore"]
+	path = semaphore/vendor/semaphore
+	ignore = dirty
+	url = https://github.com/appliedzkp/semaphore.git

Cargo.toml

@@ -1,6 +1,13 @@
 [workspace]
-members = ["rln", "rln-cli", "rln-wasm", "utils"]
-default-members = ["rln", "rln-cli", "utils"]
+members = [
+  "multiplier",
+  "private-settlement",
+  "semaphore",
+  "rln",
+  "rln-cli",
+  "rln-wasm",
+  "utils",
+]
 resolver = "2"
 
 # Compilation profile for any non-workspace member.
@@ -12,3 +19,6 @@ opt-level = 3
 [profile.release.package."rln-wasm"]
 # Tell `rustc` to optimize for small code size.
 opt-level = "s"
+
+[profile.release.package."semaphore"]
+codegen-units = 1

Cross.toml

@@ -29,7 +29,4 @@ image = "ghcr.io/cross-rs/mips64-unknown-linux-gnuabi64:latest"
 image = "ghcr.io/cross-rs/mips64el-unknown-linux-gnuabi64:latest"
 
 [target.mipsel-unknown-linux-gnu]
-image = "ghcr.io/cross-rs/mipsel-unknown-linux-gnu:latest"
-
-[target.aarch64-linux-android]
-image = "ghcr.io/cross-rs/aarch64-linux-android:edge"
+image = "ghcr.io/cross-rs/mipsel-unknown-linux-gnu:latest"

Makefile

@@ -13,19 +13,15 @@ endif
 
 installdeps: .pre-build
 ifeq ($(shell uname),Darwin)
-# commented due to https://github.com/orgs/Homebrew/discussions/4612
-# @brew update
+# commented due to https://github.com/orgs/Homebrew/discussions/4612	
+# @brew update 
 	@brew install cmake ninja
 else ifeq ($(shell uname),Linux)
 	@sudo apt-get update
 	@sudo apt-get install -y cmake ninja-build
 endif
-	@git -C "wabt" pull || git clone --recursive https://github.com/WebAssembly/wabt.git "wabt"
-	@cd wabt && mkdir -p build && cd build && cmake .. -GNinja && ninja && sudo ninja install
-	@which wasm-pack || cargo install wasm-pack
-	# nvm already checks if it's installed, and no-ops if it is
-	@curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
-	@. ${HOME}/.nvm/nvm.sh && nvm install 18.20.2 && nvm use 18.20.2;
+	@git clone --recursive https://github.com/WebAssembly/wabt.git
+	@cd wabt && mkdir build && cd build && cmake .. -GNinja && ninja && sudo ninja install
 
 build: .pre-build
 	@cargo make build

README.md

@@ -18,23 +18,13 @@ in Rust.
 
 - [semaphore-rs](https://github.com/worldcoin/semaphore-rs) written in Rust based on ark-circom.
 
-## Users
-
-Zerokit is used by -
-
-- [nwaku](https://github.com/waku-org/nwaku)
-- [js-rln](https://github.com/waku-org/js-rln)
-
 ## Build and Test
 
 To install missing dependencies, run the following commands from the root folder
-
 ```bash
 make installdeps
 ```
-
 To build and test all crates, run the following commands from the root folder
-
 ```bash
 make build
 make test
@@ -42,4 +32,4 @@ make test
 
 ## Release assets
 
-We use [`cross-rs`](https://github.com/cross-rs/cross) to cross-compile and generate release assets for rln.
+We use [`cross-rs`](https://github.com/cross-rs/cross) to cross-compile and generate release assets for rln. 

multiplier/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "multiplier"
+version = "0.3.0"
+edition = "2018"
+license = "MIT OR Apache-2.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+# WASM operations
+# wasmer = { version = "2.0" }
+# fnv = { version = "1.0.3", default-features = false }
+# num = { version = "0.4.0" }
+# num-traits = { version = "0.2.0", default-features = false }
+
+# ZKP Generation
+# ark-ff = { version = "0.3.0", default-features = false, features = ["parallel", "asm"] }
+ark-std = { version = "0.3.0", default-features = false, features = ["parallel"] }
+ark-bn254 = { version = "0.3.0" }
+ark-groth16 = { git = "https://github.com/arkworks-rs/groth16", rev = "765817f", features = ["parallel"] }
+# ark-poly = { version = "^0.3.0", default-features = false, features = ["parallel"] }
+ark-serialize = { version = "0.3.0", default-features = false }
+
+ark-circom = { git = "https://github.com/gakonst/ark-circom", features = ["circom-2"], rev = "35ce5a9" }
+
+# error handling
+color-eyre = "0.6.1"
+
+# decoding of data
+# hex = "0.4.3"
+# byteorder = "1.4.3"

multiplier/Makefile.toml

@@ -0,0 +1,7 @@
+[tasks.build]
+command = "cargo"
+args = ["build", "--release"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--release"]

multiplier/README.md

@@ -0,0 +1,21 @@
+# Multiplier example
+
+Example wrapper around a basic Circom circuit to test Circom 2 integration
+through ark-circom and FFI.
+
+## Build and Test
+
+To build and test, run the following commands within the module folder
+```bash
+cargo make build
+cargo make test
+```
+
+## FFI
+
+To generate C or Nim bindings from Rust FFI, use `cbindgen` or `nbindgen`:
+
+```
+cbindgen . -o target/multiplier.h
+nbindgen . -o target/multiplier.nim
+```

multiplier/src/ffi.rs

@@ -0,0 +1,77 @@
+use crate::public::Multiplier;
+use std::slice;
+
+/// Buffer struct is taken from
+/// https://github.com/celo-org/celo-threshold-bls-rs/blob/master/crates/threshold-bls-ffi/src/ffi.rs
+///
+/// Also heavily inspired by https://github.com/kilic/rln/blob/master/src/ffi.rs
+
+#[repr(C)]
+#[derive(Clone, Debug, PartialEq)]
+pub struct Buffer {
+    pub ptr: *const u8,
+    pub len: usize,
+}
+
+impl From<&[u8]> for Buffer {
+    fn from(src: &[u8]) -> Self {
+        Self {
+            ptr: &src[0] as *const u8,
+            len: src.len(),
+        }
+    }
+}
+
+impl<'a> From<&Buffer> for &'a [u8] {
+    fn from(src: &Buffer) -> &'a [u8] {
+        unsafe { slice::from_raw_parts(src.ptr, src.len) }
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn new_circuit(ctx: *mut *mut Multiplier) -> bool {
+    if let Ok(mul) = Multiplier::new() {
+        unsafe { *ctx = Box::into_raw(Box::new(mul)) };
+        true
+    } else {
+        false
+    }
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn prove(ctx: *const Multiplier, output_buffer: *mut Buffer) -> bool {
+    println!("multiplier ffi: prove");
+    let mul = unsafe { &*ctx };
+    let mut output_data: Vec<u8> = Vec::new();
+
+    match mul.prove(&mut output_data) {
+        Ok(proof_data) => proof_data,
+        Err(_) => return false,
+    };
+    unsafe { *output_buffer = Buffer::from(&output_data[..]) };
+    std::mem::forget(output_data);
+    true
+}
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn verify(
+    ctx: *const Multiplier,
+    proof_buffer: *const Buffer,
+    result_ptr: *mut u32,
+) -> bool {
+    println!("multiplier ffi: verify");
+    let mul = unsafe { &*ctx };
+    let proof_data = <&[u8]>::from(unsafe { &*proof_buffer });
+    if match mul.verify(proof_data) {
+        Ok(verified) => verified,
+        Err(_) => return false,
+    } {
+        unsafe { *result_ptr = 0 };
+    } else {
+        unsafe { *result_ptr = 1 };
+    };
+    true
+}

multiplier/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod ffi;
+pub mod public;

multiplier/src/main.rs

@@ -0,0 +1,49 @@
+use ark_circom::{CircomBuilder, CircomConfig};
+use ark_std::rand::thread_rng;
+use color_eyre::{Report, Result};
+
+use ark_bn254::Bn254;
+use ark_groth16::{
+    create_random_proof as prove, generate_random_parameters, prepare_verifying_key, verify_proof,
+};
+
+fn groth16_proof_example() -> Result<()> {
+    let cfg = CircomConfig::<Bn254>::new(
+        "./resources/circom2_multiplier2.wasm",
+        "./resources/circom2_multiplier2.r1cs",
+    )?;
+
+    let mut builder = CircomBuilder::new(cfg);
+    builder.push_input("a", 3);
+    builder.push_input("b", 11);
+
+    // create an empty instance for setting it up
+    let circom = builder.setup();
+
+    let mut rng = thread_rng();
+    let params = generate_random_parameters::<Bn254, _, _>(circom, &mut rng)?;
+
+    let circom = builder.build()?;
+
+    let inputs = circom
+        .get_public_inputs()
+        .ok_or(Report::msg("no public inputs"))?;
+
+    let proof = prove(circom, &params, &mut rng)?;
+
+    let pvk = prepare_verifying_key(&params.vk);
+
+    match verify_proof(&pvk, &proof, &inputs) {
+        Ok(_) => Ok(()),
+        Err(_) => Err(Report::msg("not verified")),
+    }
+}
+
+fn main() {
+    println!("Hello, world!");
+
+    match groth16_proof_example() {
+        Ok(_) => println!("Success"),
+        Err(_) => println!("Error"),
+    }
+}

multiplier/src/public.rs

@@ -0,0 +1,79 @@
+use ark_circom::{CircomBuilder, CircomCircuit, CircomConfig};
+use ark_std::rand::thread_rng;
+
+use ark_bn254::Bn254;
+use ark_groth16::{
+    create_random_proof as prove, generate_random_parameters, prepare_verifying_key, verify_proof,
+    Proof, ProvingKey,
+};
+use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+use color_eyre::{Report, Result};
+use std::io::{Read, Write};
+
+pub struct Multiplier {
+    circom: CircomCircuit<Bn254>,
+    params: ProvingKey<Bn254>,
+}
+
+impl Multiplier {
+    // TODO Break this apart here
+    pub fn new() -> Result<Multiplier> {
+        let cfg = CircomConfig::<Bn254>::new(
+            "./resources/circom2_multiplier2.wasm",
+            "./resources/circom2_multiplier2.r1cs",
+        )?;
+
+        let mut builder = CircomBuilder::new(cfg);
+        builder.push_input("a", 3);
+        builder.push_input("b", 11);
+
+        // create an empty instance for setting it up
+        let circom = builder.setup();
+
+        let mut rng = thread_rng();
+
+        let params = generate_random_parameters::<Bn254, _, _>(circom, &mut rng)?;
+
+        let circom = builder.build()?;
+
+        Ok(Multiplier { circom, params })
+    }
+
+    // TODO Input Read
+    pub fn prove<W: Write>(&self, result_data: W) -> Result<()> {
+        let mut rng = thread_rng();
+
+        // XXX: There's probably a better way to do this
+        let circom = self.circom.clone();
+        let params = self.params.clone();
+
+        let proof = prove(circom, &params, &mut rng)?;
+
+        // XXX: Unclear if this is different from other serialization(s)
+        proof.serialize(result_data)?;
+
+        Ok(())
+    }
+
+    pub fn verify<R: Read>(&self, input_data: R) -> Result<bool> {
+        let proof = Proof::deserialize(input_data)?;
+
+        let pvk = prepare_verifying_key(&self.params.vk);
+
+        // XXX Part of input data?
+        let inputs = self
+            .circom
+            .get_public_inputs()
+            .ok_or(Report::msg("no public inputs"))?;
+
+        let verified = verify_proof(&pvk, &proof, &inputs)?;
+
+        Ok(verified)
+    }
+}
+
+impl Default for Multiplier {
+    fn default() -> Self {
+        Self::new().unwrap()
+    }
+}

multiplier/tests/public.rs

@@ -0,0 +1,21 @@
+#[cfg(test)]
+mod tests {
+    use multiplier::public::Multiplier;
+
+    #[test]
+    fn multiplier_proof() {
+        let mul = Multiplier::new().unwrap();
+
+        let mut output_data: Vec<u8> = Vec::new();
+        let _ = mul.prove(&mut output_data);
+
+        let proof_data = &output_data[..];
+
+        // XXX Pass as arg?
+        //let pvk = prepare_verifying_key(&mul.params.vk);
+
+        let verified = mul.verify(proof_data).unwrap();
+
+        assert!(verified);
+    }
+}

private-settlement/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "private-settlement"
+version = "0.3.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

private-settlement/Makefile.toml

@@ -0,0 +1,7 @@
+[tasks.build]
+command = "cargo"
+args = ["build", "--release"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--release"]

private-settlement/README.md

@@ -0,0 +1,11 @@
+# Private Settlement  Module
+
+This module is to provide APIs to manage, compute and verify [Private Settlement](https://rfc.vac.dev/spec/44/) zkSNARK proofs and primitives.
+
+## Build and Test
+
+To build and test, run the following commands within the module folder
+```bash
+cargo make build
+cargo make test
+```

private-settlement/src/lib.rs

@@ -0,0 +1 @@
+

private-settlement/tests/private-settlement.rs

@@ -0,0 +1,11 @@
+#[cfg(test)]
+mod tests {
+    #[cfg(test)]
+    mod tests {
+        #[test]
+        fn it_works() {
+            let result = 2 + 2;
+            assert_eq!(result, 4);
+        }
+    }
+}

rln-cli/src/main.rs

@@ -37,11 +37,7 @@ fn main() -> Result<()> {
             tree_config_input,
         }) => {
             let mut resources: Vec<Vec<u8>> = Vec::new();
-            #[cfg(feature = "arkzkey")]
-            let filenames = ["rln.wasm", "rln_final.arkzkey", "verification_key.json"];
-            #[cfg(not(feature = "arkzkey"))]
-            let filenames = ["rln.wasm", "rln_final.zkey", "verification_key.json"];
-            for filename in filenames {
+            for filename in ["rln.wasm", "rln_final.zkey", "verification_key.json"] {
                 let fullpath = config.join(Path::new(filename));
                 let mut file = File::open(&fullpath)?;
                 let metadata = std::fs::metadata(&fullpath)?;

rln-wasm/Cargo.toml

@@ -3,9 +3,6 @@ name = "rln-wasm"
 version = "0.0.13"
 edition = "2021"
 license = "MIT or Apache2"
-autobenches = false
-autotests = false
-autobins = false
 
 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -33,3 +30,4 @@ console_error_panic_hook = { version = "0.1.7", optional = true }
 [dev-dependencies]
 wasm-bindgen-test = "0.3.13"
 wasm-bindgen-futures = "0.4.33"
+

rln-wasm/Makefile.toml

@@ -29,7 +29,3 @@ args = ["login"]
 [tasks.publish]
 command = "wasm-pack"
 args = ["publish", "--access", "public", "--target", "web"]
-
-[tasks.bench]
-command = "echo"
-args = ["'No benchmarks available for this project'"]

rln/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rln"
-version = "0.5.0"
+version = "0.4.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "APIs to manage, compute and verify zkSNARK proofs and RLN primitives"
@@ -19,20 +19,13 @@ doctest = false
 [dependencies]
 # ZKP Generation
 ark-ec = { version = "=0.4.1", default-features = false }
-ark-ff = { version = "=0.4.1", default-features = false, features = ["asm"] }
+ark-ff = { version = "=0.4.1", default-features = false, features = [ "asm"] }
 ark-std = { version = "=0.4.0", default-features = false }
 ark-bn254 = { version = "=0.4.0" }
-ark-groth16 = { version = "=0.4.0", features = [
-    "parallel",
-], default-features = false }
-ark-relations = { version = "=0.4.0", default-features = false, features = [
-    "std",
-] }
+ark-groth16 = { version = "=0.4.0", features = ["parallel"], default-features = false }
+ark-relations = { version = "=0.4.0", default-features = false, features = [ "std" ] }
 ark-serialize = { version = "=0.4.1", default-features = false }
-ark-circom = { version = "=0.1.0", default-features = false, features = [
-    "circom-2",
-] }
-ark-zkey = { version = "0.1.0", optional = true, default-features = false }
+ark-circom = { version = "=0.1.0", default-features = false, features = ["circom-2"] }
 
 # WASM
 wasmer = { version = "=2.3.0", default-features = false }
@@ -43,15 +36,13 @@ thiserror = "=1.0.39"
 
 # utilities
 cfg-if = "=1.0"
-num-bigint = { version = "=0.4.3", default-features = false, features = [
-    "rand",
-] }
+num-bigint = { version = "=0.4.3", default-features = false, features = ["rand"] }
 num-traits = "=0.2.15"
 once_cell = "=1.17.1"
 rand = "=0.8.5"
 rand_chacha = "=0.3.1"
 tiny-keccak = { version = "=2.0.2", features = ["keccak"] }
-utils = { package = "zerokit_utils", version = "=0.5.0", path = "../utils/", default-features = false }
+utils = { package = "zerokit_utils", version = "=0.4.1", path = "../utils/", default-features = false }
 
 
 # serialization
@@ -65,17 +56,10 @@ sled = "=0.34.7"
 criterion = { version = "=0.4.0", features = ["html_reports"] }
 
 [features]
-default = ["parallel", "wasmer/sys-default", "pmtree-ft"]
-parallel = [
-    "ark-ec/parallel",
-    "ark-ff/parallel",
-    "ark-std/parallel",
-    "ark-groth16/parallel",
-    "utils/parallel",
-]
+default = ["parallel", "wasmer/sys-default"]
+parallel = ["ark-ec/parallel", "ark-ff/parallel", "ark-std/parallel", "ark-groth16/parallel", "utils/parallel"]
 wasm = ["wasmer/js", "wasmer/std"]
 fullmerkletree = ["default"]
-arkzkey = ["ark-zkey"]
 
 # Note: pmtree feature is still experimental
 pmtree-ft = ["utils/pmtree-ft"]
@@ -83,11 +67,3 @@ pmtree-ft = ["utils/pmtree-ft"]
 [[bench]]
 name = "pmtree_benchmark"
 harness = false
-
-[[bench]]
-name = "circuit_loading_benchmark"
-harness = false
-
-[[bench]]
-name = "poseidon_tree_benchmark"
-harness = false

rln/README.md

@@ -3,7 +3,6 @@
 This module provides APIs to manage, compute and verify [RLN](https://rfc.vac.dev/spec/32/) zkSNARK proofs and RLN primitives.
 
 ## Pre-requisites
-
 ### Install dependencies and clone repo
 
 ```sh
@@ -15,7 +14,6 @@ cd zerokit/rln
 ### Build and Test
 
 To build and test, run the following commands within the module folder
-
 ```bash
 cargo make build
 cargo make test
@@ -23,11 +21,11 @@ cargo make test
 
 ### Compile ZK circuits
 
-The `rln` (https://github.com/rate-limiting-nullifier/circom-rln) repository, which contains the RLN circuit implementation is a submodule of zerokit RLN.
+The `rln` (https://github.com/privacy-scaling-explorations/rln) repository, which contains the RLN circuit implementation is a submodule of zerokit RLN. 
 
 To compile the RLN circuit
 
-```sh
+``` sh
 # Update submodules
 git submodule update --init --recursive
 
@@ -54,9 +52,10 @@ include "./rln-base.circom";
 component main {public [x, epoch, rln_identifier ]} = RLN(N);
 ```
 
-However, if `N` is too big, this might require a bigger Powers of Tau ceremony than the one hardcoded in `./scripts/build-circuits.sh`, which is `2^14`.
+However, if `N` is too big, this might require a bigger Powers of Tau ceremony than the one hardcoded in `./scripts/build-circuits.sh`, which is `2^14`. 
 In such case we refer to the official [Circom documentation](https://docs.circom.io/getting-started/proving-circuits/#powers-of-tau) for instructions on how to run an appropriate Powers of Tau ceremony and Phase 2 in order to compile the desired circuit.
 
+
 Currently, the `rln` module comes with 2 [pre-compiled](https://github.com/vacp2p/zerokit/tree/master/rln/resources) RLN circuits having Merkle tree of height `20` and `32`, respectively.
 
 ## Getting started
@@ -74,7 +73,7 @@ rln = { git = "https://github.com/vacp2p/zerokit" }
 
 First, we need to create a RLN object for a chosen input Merkle tree size.
 
-Note that we need to pass to RLN object constructor the path where the circuit (`rln.wasm`, built for the input tree size), the corresponding proving key (`rln_final.zkey`) or (`rln_final.arkzkey`) and verification key (`verification_key.json`, optional) are found.
+Note that we need to pass to RLN object constructor the path where the circuit (`rln.wasm`, built for the input tree size), the corresponding proving key (`rln_final.zkey`) and verification key (`verification_key.json`, optional) are found.
 
 In the following we will use [cursors](https://doc.rust-lang.org/std/io/struct.Cursor.html) as readers/writers for interfacing with RLN public APIs.
 
@@ -83,14 +82,14 @@ use rln::protocol::*;
 use rln::public::*;
 use std::io::Cursor;
 
-// We set the RLN parameters:
+// We set the RLN parameters: 
 // - the tree height;
-// - the tree config, if it is not defined, the default value will be set
+// - the circuit resource folder (requires a trailing "/").
 let tree_height = 20;
-let input = Cursor::new(json!({}).to_string());
+let resources = Cursor::new("../zerokit/rln/resources/tree_height_20/");
 
 // We create a new RLN instance
-let mut rln = RLN::new(tree_height, input);
+let mut rln = RLN::new(tree_height, resources);
 ```
 
 ### Generate an identity keypair
@@ -122,43 +121,33 @@ rln.set_leaf(id_index, &mut buffer).unwrap();
 
 Note that when tree leaves are not explicitly set by the user (in this example, all those with index less and greater than `10`), their values is set to an hardcoded default (all-`0` bytes in current implementation).
 
-### Set external nullifier
+### Set epoch
 
-The `external nullifier` includes two parameters.
-
-The first one is `epoch` and it's used to identify messages received in a certain time frame. It usually corresponds to the current UNIX time but can also be set to a random value or generated by a seed, provided that it corresponds to a field element.
-
-The second one is `rln_identifier` and it's used to prevent a RLN ZK proof generated for one application to be re-used in another one.
+The epoch, sometimes referred to as _external nullifier_, is used to identify messages received in a certain time frame. It usually corresponds to the current UNIX time but can also be set to a random value or generated by a seed, provided that it corresponds to a field element.
 
 ```rust
 // We generate epoch from a date seed and we ensure is
 // mapped to a field element by hashing-to-field its content
 let epoch = hash_to_field(b"Today at noon, this year");
-// We generate rln_identifier from a date seed and we ensure is
-// mapped to a field element by hashing-to-field its content
-let rln_identifier = hash_to_field(b"test-rln-identifier");
-
-let external_nullifier = poseidon_hash(&[epoch, rln_identifier]);
 ```
-
 ### Set signal
 
 The signal is the message for which we are computing a RLN proof.
 
 ```rust
-// We set our signal
+// We set our signal 
 let signal = b"RLN is awesome";
 ```
 
 ### Generate a RLN proof
 
-We prepare the input to the proof generation routine.
+We prepare the input to the proof generation routine. 
 
-Input buffer is serialized as `[ identity_key | id_index | external_nullifier | user_message_limit | message_id | signal_len | signal ]`.
+Input buffer is serialized as `[ identity_key | id_index | epoch | rln_identifier | user_message_limit | message_id | signal_len | signal ]`.
 
 ```rust
 // We prepare input to the proof generation routine
-let proof_input = prepare_prove_input(identity_secret_hash, id_index, external_nullifier, signal);
+let proof_input = prepare_prove_input(identity_secret_hash, id_index, epoch, rln_identifier, user_message_limit, message_id, signal);
 ```
 
 We are now ready to generate a RLN ZK proof along with the _public outputs_ of the ZK circuit evaluation.
@@ -175,11 +164,12 @@ rln.generate_rln_proof(&mut in_buffer, &mut out_buffer)
 let proof_data = out_buffer.into_inner();
 ```
 
-The byte vector `proof_data` is serialized as `[ zk-proof | tree_root | external_nullifier | share_x | share_y | nullifier ]`.
+The byte vector `proof_data` is serialized as `[ zk-proof | tree_root | epoch | share_x | share_y | nullifier | rln_identifier ]`.
+
 
 ### Verify a RLN proof
 
-We prepare the input to the proof verification routine.
+We prepare the input to the proof verification routine. 
 
 Input buffer is serialized as `[proof_data | signal_len | signal ]`, where `proof_data` is (computed as) the output obtained by `generate_rln_proof`.
 
@@ -192,21 +182,17 @@ let mut in_buffer = Cursor::new(verify_data);
 let verified = rln.verify(&mut in_buffer).unwrap();
 ```
 
-We check if the proof verification was successful:
-
+We check if the proof verification was successful: 
 ```rust
 // We ensure the proof is valid
 assert!(verified);
 ```
 
 ## Get involved!
-
 Zerokit RLN public and FFI APIs allow interaction with many more features than what briefly showcased above.
 
 We invite you to check our API documentation by running
-
 ```rust
 cargo doc --no-deps
 ```
-
-and look at unit tests to have an hint on how to interface and use them.
+and look at unit tests to have an hint on how to interface and use them.

rln/benches/circuit_loading_benchmark.rs

@@ -1,14 +0,0 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-
-// Depending on the key type (enabled by the `--features arkzkey` flag)
-// the upload speed from the `rln_final.zkey` or `rln_final.arkzkey` file is calculated
-pub fn key_load_benchmark(c: &mut Criterion) {
-    c.bench_function("zkey::upload_from_folder", |b| {
-        b.iter(|| {
-            let _ = rln::circuit::zkey_from_folder();
-        })
-    });
-}
-
-criterion_group!(benches, key_load_benchmark);
-criterion_main!(benches);

rln/benches/pmtree_benchmark.rs

@@ -1,7 +1,8 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use rln::{circuit::Fr, pm_tree_adapter::PmTree};
 use utils::ZerokitMerkleTree;
 
+use rln::{circuit::Fr, pm_tree_adapter::PmTree};
+
 pub fn pmtree_benchmark(c: &mut Criterion) {
     let mut tree = PmTree::default(2).unwrap();
 
@@ -37,19 +38,6 @@ pub fn pmtree_benchmark(c: &mut Criterion) {
             tree.get(0).unwrap();
         })
     });
-
-    // check intermediate node getter which required additional computation of sub root index
-    c.bench_function("Pmtree::get_subtree_root", |b| {
-        b.iter(|| {
-            tree.get_subtree_root(1, 0).unwrap();
-        })
-    });
-
-    c.bench_function("Pmtree::get_empty_leaves_indices", |b| {
-        b.iter(|| {
-            tree.get_empty_leaves_indices();
-        })
-    });
 }
 
 criterion_group!(benches, pmtree_benchmark);

rln/benches/poseidon_tree_benchmark.rs

@@ -1,79 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use rln::{
-    circuit::{Fr, TEST_TREE_HEIGHT},
-    hashers::PoseidonHash,
-};
-use utils::{FullMerkleTree, OptimalMerkleTree, ZerokitMerkleTree};
-
-pub fn get_leaves(n: u32) -> Vec<Fr> {
-    (0..n).map(|s| Fr::from(s)).collect()
-}
-
-pub fn optimal_merkle_tree_poseidon_benchmark(c: &mut Criterion) {
-    c.bench_function("OptimalMerkleTree::<Poseidon>::full_height_gen", |b| {
-        b.iter(|| {
-            OptimalMerkleTree::<PoseidonHash>::default(TEST_TREE_HEIGHT).unwrap();
-        })
-    });
-
-    let mut group = c.benchmark_group("Set");
-    for &n in [1u32, 10, 100].iter() {
-        let leaves = get_leaves(n);
-
-        let mut tree = OptimalMerkleTree::<PoseidonHash>::default(TEST_TREE_HEIGHT).unwrap();
-        group.bench_function(
-            BenchmarkId::new("OptimalMerkleTree::<Poseidon>::set", n),
-            |b| {
-                b.iter(|| {
-                    for (i, l) in leaves.iter().enumerate() {
-                        let _ = tree.set(i, *l);
-                    }
-                })
-            },
-        );
-
-        group.bench_function(
-            BenchmarkId::new("OptimalMerkleTree::<Poseidon>::set_range", n),
-            |b| b.iter(|| tree.set_range(0, leaves.iter().cloned())),
-        );
-    }
-    group.finish();
-}
-
-pub fn full_merkle_tree_poseidon_benchmark(c: &mut Criterion) {
-    c.bench_function("FullMerkleTree::<Poseidon>::full_height_gen", |b| {
-        b.iter(|| {
-            FullMerkleTree::<PoseidonHash>::default(TEST_TREE_HEIGHT).unwrap();
-        })
-    });
-
-    let mut group = c.benchmark_group("Set");
-    for &n in [1u32, 10, 100].iter() {
-        let leaves = get_leaves(n);
-
-        let mut tree = FullMerkleTree::<PoseidonHash>::default(TEST_TREE_HEIGHT).unwrap();
-        group.bench_function(
-            BenchmarkId::new("FullMerkleTree::<Poseidon>::set", n),
-            |b| {
-                b.iter(|| {
-                    for (i, l) in leaves.iter().enumerate() {
-                        let _ = tree.set(i, *l);
-                    }
-                })
-            },
-        );
-
-        group.bench_function(
-            BenchmarkId::new("FullMerkleTree::<Poseidon>::set_range", n),
-            |b| b.iter(|| tree.set_range(0, leaves.iter().cloned())),
-        );
-    }
-    group.finish();
-}
-
-criterion_group!(
-    benches,
-    optimal_merkle_tree_poseidon_benchmark,
-    full_merkle_tree_poseidon_benchmark
-);
-criterion_main!(benches);

rln/resources/tree_height_32/verification_key.json

@@ -0,0 +1,114 @@
+{
+ "protocol": "groth16",
+ "curve": "bn128",
+ "nPublic": 5,
+ "vk_alpha_1": [
+  "20491192805390485299153009773594534940189261866228447918068658471970481763042",
+  "9383485363053290200918347156157836566562967994039712273449902621266178545958",
+  "1"
+ ],
+ "vk_beta_2": [
+  [
+   "6375614351688725206403948262868962793625744043794305715222011528459656738731",
+   "4252822878758300859123897981450591353533073413197771768651442665752259397132"
+  ],
+  [
+   "10505242626370262277552901082094356697409835680220590971873171140371331206856",
+   "21847035105528745403288232691147584728191162732299865338377159692350059136679"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_gamma_2": [
+  [
+   "10857046999023057135944570762232829481370756359578518086990519993285655852781",
+   "11559732032986387107991004021392285783925812861821192530917403151452391805634"
+  ],
+  [
+   "8495653923123431417604973247489272438418190587263600148770280649306958101930",
+   "4082367875863433681332203403145435568316851327593401208105741076214120093531"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_delta_2": [
+  [
+   "3689226096868373144622340732612563195789744807442014147637039988348252818659",
+   "18947459102520510468597269280688700807407684209892273827108603062925288762423"
+  ],
+  [
+   "5816405977664254142436796931495067997250259145480168934320978750042633353708",
+   "14555486789839131710516067578112557185806110684461247253491378577062852578892"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_alphabeta_12": [
+  [
+   [
+    "2029413683389138792403550203267699914886160938906632433982220835551125967885",
+    "21072700047562757817161031222997517981543347628379360635925549008442030252106"
+   ],
+   [
+    "5940354580057074848093997050200682056184807770593307860589430076672439820312",
+    "12156638873931618554171829126792193045421052652279363021382169897324752428276"
+   ],
+   [
+    "7898200236362823042373859371574133993780991612861777490112507062703164551277",
+    "7074218545237549455313236346927434013100842096812539264420499035217050630853"
+   ]
+  ],
+  [
+   [
+    "7077479683546002997211712695946002074877511277312570035766170199895071832130",
+    "10093483419865920389913245021038182291233451549023025229112148274109565435465"
+   ],
+   [
+    "4595479056700221319381530156280926371456704509942304414423590385166031118820",
+    "19831328484489333784475432780421641293929726139240675179672856274388269393268"
+   ],
+   [
+    "11934129596455521040620786944827826205713621633706285934057045369193958244500",
+    "8037395052364110730298837004334506829870972346962140206007064471173334027475"
+   ]
+  ]
+ ],
+ "IC": [
+  [
+   "5412646265162057015134786739992128493053406364679846617542694915593022919217",
+   "9665511386935901867415947590751330959748921059696950821222365265700369811120",
+   "1"
+  ],
+  [
+   "4294362651275803035824711662252687124584574009834787359330648404293309808795",
+   "1861758671717754835450145961645465880215655915164196594175485865489885224285",
+   "1"
+  ],
+  [
+   "1911114017568107170522785254288953144010421698038439931935418407428234018676",
+   "13761363892532562822351086117281964648116890138564516558345965908415019790129",
+   "1"
+  ],
+  [
+   "16312980235585837964428386585067529342038135099260965575497230302984635878053",
+   "20286500347141875536561618770383759234192052027362539966911091298688849002783",
+   "1"
+  ],
+  [
+   "21038649368092225315431823433752123495654049075935052064397443455654061176031",
+   "6976971039866104284556300526186000690370678593992968176463280189048347216392",
+   "1"
+  ],
+  [
+   "971745799362951123575710699973701411260115357326598060711339429906895409324",
+   "12959821343398475313407440786226277845673045139874184400082186049649123071798",
+   "1"
+  ]
+ ]
+}

rln/src/circuit.rs

@@ -4,12 +4,14 @@ use ark_bn254::{
     Bn254, Fq as ArkFq, Fq2 as ArkFq2, Fr as ArkFr, G1Affine as ArkG1Affine,
     G1Projective as ArkG1Projective, G2Affine as ArkG2Affine, G2Projective as ArkG2Projective,
 };
+use ark_circom::read_zkey;
 use ark_groth16::{ProvingKey, VerifyingKey};
 use ark_relations::r1cs::ConstraintMatrices;
 use cfg_if::cfg_if;
 use color_eyre::{Report, Result};
 use num_bigint::BigUint;
 use serde_json::Value;
+use std::io::Cursor;
 use std::str::FromStr;
 
 cfg_if! {
@@ -23,22 +25,16 @@ cfg_if! {
     }
 }
 
-cfg_if! {
-    if #[cfg(feature = "arkzkey")] {
-        use ark_zkey::read_arkzkey_from_bytes;
-        const ARKZKEY_FILENAME: &str = "tree_height_20/rln_final.arkzkey";
+const ZKEY_FILENAME: &str = "rln_final.zkey";
+const VK_FILENAME: &str = "verification_key.json";
+const WASM_FILENAME: &str = "rln.wasm";
 
-    } else {
-        use std::io::Cursor;
-        use ark_circom::read_zkey;
-    }
-}
-
-const ZKEY_FILENAME: &str = "tree_height_20/rln_final.zkey";
-const VK_FILENAME: &str = "tree_height_20/verification_key.json";
-const WASM_FILENAME: &str = "tree_height_20/rln.wasm";
-
-pub const TEST_TREE_HEIGHT: usize = 20;
+// These parameters are used for tests
+// Note that the circuit and keys in TEST_RESOURCES_FOLDER are compiled for Merkle trees of height 20 & 32
+// Changing these parameters to other values than these defaults will cause zkSNARK proof verification to fail
+pub const TEST_PARAMETERS_INDEX: usize = 0;
+pub const TEST_TREE_HEIGHT: usize = [20, 32][TEST_PARAMETERS_INDEX];
+pub const TEST_RESOURCES_FOLDER: &str = ["tree_height_20", "tree_height_32"][TEST_PARAMETERS_INDEX];
 
 #[cfg(not(target_arch = "wasm32"))]
 static RESOURCES_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/resources");
@@ -57,15 +53,8 @@ pub type G2Projective = ArkG2Projective;
 // Loads the proving key using a bytes vector
 pub fn zkey_from_raw(zkey_data: &Vec<u8>) -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
     if !zkey_data.is_empty() {
-        let proving_key_and_matrices = match () {
-            #[cfg(feature = "arkzkey")]
-            () => read_arkzkey_from_bytes(zkey_data.as_slice())?,
-            #[cfg(not(feature = "arkzkey"))]
-            () => {
-                let mut c = Cursor::new(zkey_data);
-                read_zkey(&mut c)?
-            }
-        };
+        let mut c = Cursor::new(zkey_data);
+        let proving_key_and_matrices = read_zkey(&mut c)?;
         Ok(proving_key_and_matrices)
     } else {
         Err(Report::msg("No proving key found!"))
@@ -74,22 +63,13 @@ pub fn zkey_from_raw(zkey_data: &Vec<u8>) -> Result<(ProvingKey<Curve>, Constrai
 
 // Loads the proving key
 #[cfg(not(target_arch = "wasm32"))]
-pub fn zkey_from_folder() -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
-    #[cfg(feature = "arkzkey")]
-    let zkey = RESOURCES_DIR.get_file(Path::new(ARKZKEY_FILENAME));
-    #[cfg(not(feature = "arkzkey"))]
-    let zkey = RESOURCES_DIR.get_file(Path::new(ZKEY_FILENAME));
-
+pub fn zkey_from_folder(
+    resources_folder: &str,
+) -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
+    let zkey = RESOURCES_DIR.get_file(Path::new(resources_folder).join(ZKEY_FILENAME));
     if let Some(zkey) = zkey {
-        let proving_key_and_matrices = match () {
-            #[cfg(feature = "arkzkey")]
-            () => read_arkzkey_from_bytes(zkey.contents())?,
-            #[cfg(not(feature = "arkzkey"))]
-            () => {
-                let mut c = Cursor::new(zkey.contents());
-                read_zkey(&mut c)?
-            }
-        };
+        let mut c = Cursor::new(zkey.contents());
+        let proving_key_and_matrices = read_zkey(&mut c)?;
         Ok(proving_key_and_matrices)
     } else {
         Err(Report::msg("No proving key found!"))
@@ -97,7 +77,7 @@ pub fn zkey_from_folder() -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)>
 }
 
 // Loads the verification key from a bytes vector
-pub fn vk_from_raw(vk_data: &[u8], zkey_data: &Vec<u8>) -> Result<VerifyingKey<Curve>> {
+pub fn vk_from_raw(vk_data: &Vec<u8>, zkey_data: &Vec<u8>) -> Result<VerifyingKey<Curve>> {
     let verifying_key: VerifyingKey<Curve>;
 
     if !vk_data.is_empty() {
@@ -114,9 +94,9 @@ pub fn vk_from_raw(vk_data: &[u8], zkey_data: &Vec<u8>) -> Result<VerifyingKey<C
 
 // Loads the verification key
 #[cfg(not(target_arch = "wasm32"))]
-pub fn vk_from_folder() -> Result<VerifyingKey<Curve>> {
-    let vk = RESOURCES_DIR.get_file(Path::new(VK_FILENAME));
-    let zkey = RESOURCES_DIR.get_file(Path::new(ZKEY_FILENAME));
+pub fn vk_from_folder(resources_folder: &str) -> Result<VerifyingKey<Curve>> {
+    let vk = RESOURCES_DIR.get_file(Path::new(resources_folder).join(VK_FILENAME));
+    let zkey = RESOURCES_DIR.get_file(Path::new(resources_folder).join(ZKEY_FILENAME));
 
     let verifying_key: VerifyingKey<Curve>;
     if let Some(vk) = vk {
@@ -125,7 +105,7 @@ pub fn vk_from_folder() -> Result<VerifyingKey<Curve>> {
         ))?)?;
         Ok(verifying_key)
     } else if let Some(_zkey) = zkey {
-        let (proving_key, _matrices) = zkey_from_folder()?;
+        let (proving_key, _matrices) = zkey_from_folder(resources_folder)?;
         verifying_key = proving_key.vk;
         Ok(verifying_key)
     } else {
@@ -149,9 +129,9 @@ pub fn circom_from_raw(wasm_buffer: Vec<u8>) -> Result<&'static Mutex<WitnessCal
 
 // Initializes the witness calculator
 #[cfg(not(target_arch = "wasm32"))]
-pub fn circom_from_folder() -> Result<&'static Mutex<WitnessCalculator>> {
+pub fn circom_from_folder(resources_folder: &str) -> Result<&'static Mutex<WitnessCalculator>> {
     // We read the wasm file
-    let wasm = RESOURCES_DIR.get_file(Path::new(WASM_FILENAME));
+    let wasm = RESOURCES_DIR.get_file(Path::new(resources_folder).join(WASM_FILENAME));
 
     if let Some(wasm) = wasm {
         let wasm_buffer = wasm.contents();
@@ -165,7 +145,7 @@ pub fn circom_from_folder() -> Result<&'static Mutex<WitnessCalculator>> {
 
 // Utilities to convert a json verification key in a groth16::VerificationKey
 fn fq_from_str(s: &str) -> Result<Fq> {
-    Ok(Fq::from(BigUint::from_str(s)?))
+    Ok(Fq::try_from(BigUint::from_str(s)?)?)
 }
 
 // Extracts the element in G1 corresponding to its JSON serialization
@@ -274,8 +254,11 @@ fn vk_from_vector(vk: &[u8]) -> Result<VerifyingKey<Curve>> {
 
 // Checks verification key to be correct with respect to proving key
 #[cfg(not(target_arch = "wasm32"))]
-pub fn check_vk_from_zkey(verifying_key: VerifyingKey<Curve>) -> Result<()> {
-    let (proving_key, _matrices) = zkey_from_folder()?;
+pub fn check_vk_from_zkey(
+    resources_folder: &str,
+    verifying_key: VerifyingKey<Curve>,
+) -> Result<()> {
+    let (proving_key, _matrices) = zkey_from_folder(resources_folder)?;
     if proving_key.vk == verifying_key {
         Ok(())
     } else {

rln/src/ffi.rs

@@ -361,21 +361,6 @@ pub extern "C" fn generate_rln_proof(
     call_with_output_arg!(ctx, generate_rln_proof, output_buffer, input_buffer)
 }
 
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[no_mangle]
-pub extern "C" fn generate_rln_proof_with_witness(
-    ctx: *mut RLN,
-    input_buffer: *const Buffer,
-    output_buffer: *mut Buffer,
-) -> bool {
-    call_with_output_arg!(
-        ctx,
-        generate_rln_proof_with_witness,
-        output_buffer,
-        input_buffer
-    )
-}
-
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn verify_rln_proof(

rln/src/pm_tree_adapter.rs

@@ -5,7 +5,6 @@ use std::str::FromStr;
 use color_eyre::{Report, Result};
 use serde_json::Value;
 
-use utils::pmtree::tree::Key;
 use utils::pmtree::{Database, Hasher};
 use utils::*;
 
@@ -17,9 +16,6 @@ const METADATA_KEY: [u8; 8] = *b"metadata";
 
 pub struct PmTree {
     tree: pmtree::MerkleTree<SledDB, PoseidonHash>,
-    /// The indices of leaves which are set into zero upto next_index.
-    /// Set to 0 if the leaf is empty and set to 1 in otherwise.
-    cached_leaves_indices: Vec<u8>,
     // metadata that an application may use to store additional information
     metadata: Vec<u8>,
 }
@@ -147,7 +143,6 @@ impl ZerokitMerkleTree for PmTree {
 
         Ok(PmTree {
             tree,
-            cached_leaves_indices: vec![0; 1 << depth],
             metadata: Vec::new(),
         })
     }
@@ -160,7 +155,7 @@ impl ZerokitMerkleTree for PmTree {
         self.tree.capacity()
     }
 
-    fn leaves_set(&self) -> usize {
+    fn leaves_set(&mut self) -> usize {
         self.tree.leaves_set()
     }
 
@@ -175,9 +170,7 @@ impl ZerokitMerkleTree for PmTree {
     fn set(&mut self, index: usize, leaf: FrOf<Self::Hasher>) -> Result<()> {
         self.tree
             .set(index, leaf)
-            .map_err(|e| Report::msg(e.to_string()))?;
-        self.cached_leaves_indices[index] = 1;
-        Ok(())
+            .map_err(|e| Report::msg(e.to_string()))
     }
 
     fn set_range<I: IntoIterator<Item = FrOf<Self::Hasher>>>(
@@ -185,51 +178,15 @@ impl ZerokitMerkleTree for PmTree {
         start: usize,
         values: I,
     ) -> Result<()> {
-        let v = values.into_iter().collect::<Vec<_>>();
         self.tree
-            .set_range(start, v.clone().into_iter())
-            .map_err(|e| Report::msg(e.to_string()))?;
-        for i in start..v.len() {
-            self.cached_leaves_indices[i] = 1
-        }
-        Ok(())
+            .set_range(start, values)
+            .map_err(|e| Report::msg(e.to_string()))
     }
 
     fn get(&self, index: usize) -> Result<FrOf<Self::Hasher>> {
         self.tree.get(index).map_err(|e| Report::msg(e.to_string()))
     }
 
-    fn get_subtree_root(&self, n: usize, index: usize) -> Result<FrOf<Self::Hasher>> {
-        if n > self.depth() {
-            return Err(Report::msg("level exceeds depth size"));
-        }
-        if index >= self.capacity() {
-            return Err(Report::msg("index exceeds set size"));
-        }
-        if n == 0 {
-            Ok(self.root())
-        } else if n == self.depth() {
-            self.get(index)
-        } else {
-            let node = self
-                .tree
-                .get_elem(Key::new(n, index >> (self.depth() - n)))
-                .unwrap();
-            Ok(node)
-        }
-    }
-
-    fn get_empty_leaves_indices(&self) -> Vec<usize> {
-        let next_idx = self.leaves_set();
-        self.cached_leaves_indices
-            .iter()
-            .take(next_idx)
-            .enumerate()
-            .filter(|&(_, &v)| v == 0u8)
-            .map(|(idx, _)| idx)
-            .collect()
-    }
-
     fn override_range<I: IntoIterator<Item = FrOf<Self::Hasher>>, J: IntoIterator<Item = usize>>(
         &mut self,
         start: usize,
@@ -244,7 +201,7 @@ impl ZerokitMerkleTree for PmTree {
             (0, 0) => Err(Report::msg("no leaves or indices to be removed")),
             (1, 0) => self.set(start, leaves[0]),
             (0, 1) => self.delete(indices[0]),
-            (_, 0) => self.set_range(start, leaves),
+            (_, 0) => self.set_range_with_leaves(start, leaves),
             (0, _) => self.remove_indices(&indices),
             (_, _) => self.remove_indices_and_set_leaves(start, leaves, &indices),
         }
@@ -259,9 +216,7 @@ impl ZerokitMerkleTree for PmTree {
     fn delete(&mut self, index: usize) -> Result<()> {
         self.tree
             .delete(index)
-            .map_err(|e| Report::msg(e.to_string()))?;
-        self.cached_leaves_indices[index] = 0;
-        Ok(())
+            .map_err(|e| Report::msg(e.to_string()))
     }
 
     fn proof(&self, index: usize) -> Result<Self::Proof> {
@@ -291,8 +246,7 @@ impl ZerokitMerkleTree for PmTree {
         let data = self.tree.db.get(METADATA_KEY)?;
 
         if data.is_none() {
-            // send empty Metadata
-            return Ok(Vec::new());
+            return Err(Report::msg("metadata does not exist"));
         }
         Ok(data.unwrap())
     }
@@ -306,6 +260,12 @@ type PmTreeHasher = <PmTree as ZerokitMerkleTree>::Hasher;
 type FrOfPmTreeHasher = FrOf<PmTreeHasher>;
 
 impl PmTree {
+    fn set_range_with_leaves(&mut self, start: usize, leaves: Vec<FrOfPmTreeHasher>) -> Result<()> {
+        self.tree
+            .set_range(start, leaves)
+            .map_err(|e| Report::msg(e.to_string()))
+    }
+
     fn remove_indices(&mut self, indices: &[usize]) -> Result<()> {
         let start = indices[0];
         let end = indices.last().unwrap() + 1;
@@ -314,12 +274,7 @@ impl PmTree {
 
         self.tree
             .set_range(start, new_leaves)
-            .map_err(|e| Report::msg(e.to_string()))?;
-
-        for i in start..end {
-            self.cached_leaves_indices[i] = 0
-        }
-        Ok(())
+            .map_err(|e| Report::msg(e.to_string()))
     }
 
     fn remove_indices_and_set_leaves(
@@ -345,17 +300,8 @@ impl PmTree {
         }
 
         self.tree
-            .set_range(start, set_values)
-            .map_err(|e| Report::msg(e.to_string()))?;
-
-        for i in indices {
-            self.cached_leaves_indices[*i] = 0;
-        }
-
-        for i in start..(max_index - min_index) {
-            self.cached_leaves_indices[i] = 1
-        }
-        Ok(())
+            .set_range(min_index, set_values)
+            .map_err(|e| Report::msg(e.to_string()))
     }
 }
 

rln/src/protocol.rs

@@ -4,13 +4,11 @@ use ark_circom::{CircomReduction, WitnessCalculator};
 use ark_groth16::{prepare_verifying_key, Groth16, Proof as ArkProof, ProvingKey, VerifyingKey};
 use ark_relations::r1cs::ConstraintMatrices;
 use ark_relations::r1cs::SynthesisError;
-use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_std::{rand::thread_rng, UniformRand};
 use color_eyre::{Report, Result};
 use num_bigint::BigInt;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
-use serde::{Deserialize, Serialize};
 #[cfg(not(target_arch = "wasm32"))]
 use std::sync::Mutex;
 #[cfg(debug_assertions)]
@@ -31,20 +29,14 @@ use utils::{ZerokitMerkleProof, ZerokitMerkleTree};
 // RLN Witness data structure and utility functions
 ///////////////////////////////////////////////////////
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq)]
 pub struct RLNWitnessInput {
-    #[serde(serialize_with = "ark_se", deserialize_with = "ark_de")]
     identity_secret: Fr,
-    #[serde(serialize_with = "ark_se", deserialize_with = "ark_de")]
     user_message_limit: Fr,
-    #[serde(serialize_with = "ark_se", deserialize_with = "ark_de")]
     message_id: Fr,
-    #[serde(serialize_with = "ark_se", deserialize_with = "ark_de")]
     path_elements: Vec<Fr>,
     identity_path_index: Vec<u8>,
-    #[serde(serialize_with = "ark_se", deserialize_with = "ark_de")]
     x: Fr,
-    #[serde(serialize_with = "ark_se", deserialize_with = "ark_de")]
     external_nullifier: Fr,
 }
 
@@ -170,7 +162,7 @@ pub fn deserialize_witness(serialized: &[u8]) -> Result<(RLNWitnessInput, usize)
 
 // This function deserializes input for kilic's rln generate_proof public API
 // https://github.com/kilic/rln/blob/7ac74183f8b69b399e3bc96c1ae8ab61c026dc43/src/public.rs#L148
-// input_data is [ identity_secret<32> | id_index<8> | user_message_limit<32> | message_id<32> | external_nullifier<32> | signal_len<8> | signal<var> ]
+// input_data is [ identity_secret<32> | id_index<8> | user_message_limit<32> | message_id<32> | signal_len<8> | signal<var> ]
 // return value is a rln witness populated according to this information
 pub fn proof_inputs_to_rln_witness(
     tree: &mut PoseidonTree,
@@ -222,6 +214,55 @@ pub fn proof_inputs_to_rln_witness(
     ))
 }
 
+/// Returns `RLNWitnessInput` given a file with JSON serialized values.
+///
+/// # Errors
+///
+/// Returns an error if `message_id` is not within `user_message_limit`.
+pub fn rln_witness_from_json(input_json_str: &str) -> Result<RLNWitnessInput> {
+    let input_json: serde_json::Value =
+        serde_json::from_str(input_json_str).expect("JSON was not well-formatted");
+
+    let user_message_limit = str_to_fr(&input_json["userMessageLimit"].to_string(), 10)?;
+
+    let message_id = str_to_fr(&input_json["messageId"].to_string(), 10)?;
+
+    message_id_range_check(&message_id, &user_message_limit)?;
+
+    let identity_secret = str_to_fr(&input_json["identitySecret"].to_string(), 10)?;
+
+    let path_elements = input_json["pathElements"]
+        .as_array()
+        .ok_or(Report::msg("not an array"))?
+        .iter()
+        .map(|v| str_to_fr(&v.to_string(), 10))
+        .collect::<Result<_>>()?;
+
+    let identity_path_index_array = input_json["identityPathIndex"]
+        .as_array()
+        .ok_or(Report::msg("not an array"))?;
+
+    let mut identity_path_index: Vec<u8> = vec![];
+
+    for v in identity_path_index_array {
+        identity_path_index.push(v.as_u64().ok_or(Report::msg("not a u64 value"))? as u8);
+    }
+
+    let x = str_to_fr(&input_json["x"].to_string(), 10)?;
+
+    let external_nullifier = str_to_fr(&input_json["externalNullifier"].to_string(), 10)?;
+
+    Ok(RLNWitnessInput {
+        identity_secret,
+        path_elements,
+        identity_path_index,
+        x,
+        external_nullifier,
+        user_message_limit,
+        message_id,
+    })
+}
+
 /// Creates `RLNWitnessInput` from it's fields.
 ///
 /// # Errors
@@ -718,49 +759,40 @@ pub fn verify_proof(
     Ok(verified)
 }
 
-// auxiliary function for serialisation Fr to json using ark serilize
-fn ark_se<S, A: CanonicalSerialize>(a: &A, s: S) -> Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-{
-    let mut bytes = vec![];
-    a.serialize_compressed(&mut bytes)
-        .map_err(serde::ser::Error::custom)?;
-    s.serialize_bytes(&bytes)
-}
-
-// auxiliary function for deserialisation Fr to json using ark serilize
-fn ark_de<'de, D, A: CanonicalDeserialize>(data: D) -> Result<A, D::Error>
-where
-    D: serde::de::Deserializer<'de>,
-{
-    let s: Vec<u8> = serde::de::Deserialize::deserialize(data)?;
-    let a = A::deserialize_compressed_unchecked(s.as_slice());
-    a.map_err(serde::de::Error::custom)
-}
-
-/// Converts a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
+/// Get CIRCOM JSON inputs
 ///
-/// # Errors
-///
-/// Returns an error if `message_id` is not within `user_message_limit`.
-pub fn rln_witness_from_json(input_json: serde_json::Value) -> Result<RLNWitnessInput> {
-    let rln_witness: RLNWitnessInput = serde_json::from_value(input_json).unwrap();
-    message_id_range_check(&rln_witness.message_id, &rln_witness.user_message_limit)?;
-
-    Ok(rln_witness)
-}
-
-/// Converts a JSON value into [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object.
+/// Returns a JSON object containing the inputs necessary to calculate
+/// the witness with CIRCOM on javascript
 ///
 /// # Errors
 ///
 /// Returns an error if `rln_witness.message_id` is not within `rln_witness.user_message_limit`.
-pub fn rln_witness_to_json(rln_witness: &RLNWitnessInput) -> Result<serde_json::Value> {
+pub fn get_json_inputs(rln_witness: &RLNWitnessInput) -> Result<serde_json::Value> {
     message_id_range_check(&rln_witness.message_id, &rln_witness.user_message_limit)?;
 
-    let rln_witness_json = serde_json::to_value(rln_witness)?;
-    Ok(rln_witness_json)
+    let mut path_elements = Vec::new();
+
+    for v in rln_witness.path_elements.iter() {
+        path_elements.push(to_bigint(v)?.to_str_radix(10));
+    }
+
+    let mut identity_path_index = Vec::new();
+    rln_witness
+        .identity_path_index
+        .iter()
+        .for_each(|v| identity_path_index.push(BigInt::from(*v).to_str_radix(10)));
+
+    let inputs = serde_json::json!({
+        "identitySecret": to_bigint(&rln_witness.identity_secret)?.to_str_radix(10),
+        "userMessageLimit": to_bigint(&rln_witness.user_message_limit)?.to_str_radix(10),
+        "messageId": to_bigint(&rln_witness.message_id)?.to_str_radix(10),
+        "pathElements": path_elements,
+        "identityPathIndex": identity_path_index,
+        "x": to_bigint(&rln_witness.x)?.to_str_radix(10),
+        "externalNullifier":  to_bigint(&rln_witness.external_nullifier)?.to_str_radix(10),
+    });
+
+    Ok(inputs)
 }
 
 pub fn message_id_range_check(message_id: &Fr, user_message_limit: &Fr) -> Result<()> {

rln/src/public.rs

@@ -11,6 +11,7 @@ use ark_relations::r1cs::ConstraintMatrices;
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Read, Write};
 use cfg_if::cfg_if;
 use color_eyre::{Report, Result};
+use num_bigint::BigInt;
 use std::io::Cursor;
 use utils::{ZerokitMerkleProof, ZerokitMerkleTree};
 
@@ -18,14 +19,13 @@ cfg_if! {
     if #[cfg(not(target_arch = "wasm32"))] {
         use std::default::Default;
         use std::sync::Mutex;
-        use crate::circuit::{circom_from_folder, vk_from_folder, circom_from_raw, zkey_from_folder, TEST_TREE_HEIGHT};
+        use crate::circuit::{circom_from_folder, vk_from_folder, circom_from_raw, zkey_from_folder, TEST_RESOURCES_FOLDER, TEST_TREE_HEIGHT};
         use ark_circom::WitnessCalculator;
         use serde_json::{json, Value};
         use utils::{Hasher};
         use std::str::FromStr;
     } else {
         use std::marker::*;
-        use num_bigint::BigInt;
     }
 }
 
@@ -58,16 +58,17 @@ impl RLN<'_> {
     ///
     /// Input parameters are
     /// - `tree_height`: the height of the internal Merkle tree
-    /// - `input_data`: include `tree_config` a reader for a string containing a json with the merkle tree configuration
+    /// - `input_data`: a reader for the string path of the resource folder containing the ZK circuit (`rln.wasm`), the proving key (`rln_final.zkey`) and the verification key (`verification_key.json`).
+    ///
     /// Example:
     /// ```
     /// use std::io::Cursor;
     ///
     /// let tree_height = 20;
-    /// let input = Cursor::new(json!({}).to_string());;
+    /// let resources = Cursor::new(json!({"resources_folder": "tree_height_20"});
     ///
     /// // We create a new RLN instance
-    /// let mut rln = RLN::new(tree_height, input);
+    /// let mut rln = RLN::new(tree_height, resources);
     /// ```
     #[cfg(not(target_arch = "wasm32"))]
     pub fn new<R: Read>(tree_height: usize, mut input_data: R) -> Result<RLN<'static>> {
@@ -76,12 +77,15 @@ impl RLN<'_> {
         input_data.read_to_end(&mut input)?;
 
         let rln_config: Value = serde_json::from_str(&String::from_utf8(input)?)?;
+        let resources_folder = rln_config["resources_folder"]
+            .as_str()
+            .unwrap_or(TEST_RESOURCES_FOLDER);
         let tree_config = rln_config["tree_config"].to_string();
 
-        let witness_calculator = circom_from_folder()?;
-        let proving_key = zkey_from_folder()?;
+        let witness_calculator = circom_from_folder(resources_folder)?;
 
-        let verification_key = vk_from_folder()?;
+        let proving_key = zkey_from_folder(resources_folder)?;
+        let verification_key = vk_from_folder(resources_folder)?;
 
         let tree_config: <PoseidonTree as ZerokitMerkleTree>::Config = if tree_config.is_empty() {
             <PoseidonTree as ZerokitMerkleTree>::Config::default()
@@ -111,9 +115,9 @@ impl RLN<'_> {
     /// Input parameters are
     /// - `tree_height`: the height of the internal Merkle tree
     /// - `circom_vec`: a byte vector containing the ZK circuit (`rln.wasm`) as binary file
-    /// - `zkey_vec`: a byte vector containing to the proving key (`rln_final.zkey`)  or (`rln_final.arkzkey`) as binary file
+    /// - `zkey_vec`: a byte vector containing to the proving key (`rln_final.zkey`) as binary file
     /// - `vk_vec`: a byte vector containing to the verification key (`verification_key.json`) as binary file
-    /// - `tree_config_input`: a reader for a string containing a json with the merkle tree configuration
+    /// - `tree_config`: a reader for a string containing a json with the merkle tree configuration
     ///
     /// Example:
     /// ```
@@ -132,7 +136,7 @@ impl RLN<'_> {
     ///     file.read_exact(&mut buffer).expect("buffer overflow");
     ///     resources.push(buffer);
     ///     let tree_config = "{}".to_string();
-    ///     let tree_config_input = &Buffer::from(tree_config.as_bytes());
+    ///     let tree_config_buffer = &Buffer::from(tree_config.as_bytes());
     /// }
     ///
     /// let mut rln = RLN::new_with_params(
@@ -140,7 +144,7 @@ impl RLN<'_> {
     ///     resources[0].clone(),
     ///     resources[1].clone(),
     ///     resources[2].clone(),
-    ///     tree_config_input,
+    ///     tree_config_buffer,
     /// );
     /// ```
     #[cfg(not(target_arch = "wasm32"))]
@@ -261,9 +265,6 @@ impl RLN<'_> {
     /// Input values are:
     /// - `index`: the index of the leaf
     ///
-    /// Output values are:
-    /// - `output_data`: a writer receiving the serialization of the metadata
-    ///
     /// Example:
     /// ```
     /// use crate::protocol::*;
@@ -383,7 +384,7 @@ impl RLN<'_> {
     /// // We atomically add leaves and remove indices from the tree
     /// let mut leaves_buffer = Cursor::new(vec_fr_to_bytes_le(&leaves));
     /// let mut indices_buffer = Cursor::new(vec_u8_to_bytes_le(&indices));
-    /// rln.atomic_operation(index, &mut leaves_buffer, indices_buffer).unwrap();
+    /// rln.set_leaves_from(index, &mut leaves_buffer, indices_buffer).unwrap();
     /// ```
     pub fn atomic_operation<R: Read>(
         &mut self,
@@ -544,33 +545,6 @@ impl RLN<'_> {
         Ok(())
     }
 
-    /// Returns the root of subtree in the Merkle tree
-    ///
-    /// Output values are:
-    /// - `output_data`: a writer receiving the serialization of the node value (serialization done with [`rln::utils::fr_to_bytes_le`](crate::utils::fr_to_bytes_le))
-    ///
-    /// Example
-    /// ```
-    /// use rln::utils::*;
-    ///
-    /// let mut buffer = Cursor::new(Vec::<u8>::new());
-    /// let level = 1;
-    /// let index = 2;
-    /// rln.get_subtree_root(level, index, &mut buffer).unwrap();
-    /// let (subroot, _) = bytes_le_to_fr(&buffer.into_inner());
-    /// ```
-    pub fn get_subtree_root<W: Write>(
-        &self,
-        level: usize,
-        index: usize,
-        mut output_data: W,
-    ) -> Result<()> {
-        let subroot = self.tree.get_subtree_root(level, index)?;
-        output_data.write_all(&fr_to_bytes_le(&subroot))?;
-
-        Ok(())
-    }
-
     /// Returns the Merkle proof of the leaf at position index
     ///
     /// Input values are:
@@ -603,44 +577,6 @@ impl RLN<'_> {
         Ok(())
     }
 
-    /// Returns indices of leaves in the tree are set to zero (upto the final leaf that was set).
-    ///
-    /// Output values are:
-    /// - `output_data`: a writer receiving the serialization of the indices of leaves.
-    ///
-    /// Example
-    /// ```
-    /// use rln::circuit::Fr;
-    /// use rln::utils::*;
-    ///
-    /// let start_index = 5;
-    /// let no_of_leaves = 256;
-    ///
-    /// // We generate a vector of random leaves
-    /// let mut leaves: Vec<Fr> = Vec::new();
-    /// let mut rng = thread_rng();
-    /// for _ in 0..no_of_leaves {
-    ///     let (_, id_commitment) = keygen();
-    ///     let rate_commitment = poseidon_hash(&[id_commitment, 1.into()]);
-    ///     leaves.push(rate_commitment);
-    /// }
-    ///
-    /// // We add leaves in a batch into the tree
-    /// let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves));
-    /// rln.set_leaves_from(index, &mut buffer).unwrap();
-    ///
-    /// // Get indices of first empty leaves upto start_index
-    /// let mut buffer = Cursor::new(Vec::<u8>::new());
-    /// rln.get_empty_leaves_indices(&mut buffer).unwrap();
-    /// let idxs = bytes_le_to_vec_usize(&buffer.into_inner()).unwrap();
-    /// assert_eq!(idxs, [0, 1, 2, 3, 4]);
-    /// ```
-    pub fn get_empty_leaves_indices<W: Write>(&self, mut output_data: W) -> Result<()> {
-        let idxs = self.tree.get_empty_leaves_indices();
-        idxs.serialize_compressed(&mut output_data)?;
-        Ok(())
-    }
-
     ////////////////////////////////////////////////////////
     // zkSNARK APIs
     ////////////////////////////////////////////////////////
@@ -693,8 +629,7 @@ impl RLN<'_> {
     /// Verifies a zkSNARK RLN proof.
     ///
     /// Input values are:
-    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values,
-    ///  i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`, where <_> indicates the byte length.
+    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values, i.e. `[ proof<128> | root<32> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> | rln_identifier<32> ]`, where <_> indicates the byte length.
     ///
     /// The function returns true if the zkSNARK proof is valid with respect to the provided circuit output values, false otherwise.
     ///
@@ -729,7 +664,7 @@ impl RLN<'_> {
     pub fn verify<R: Read>(&self, mut input_data: R) -> Result<bool> {
         // Input data is serialized for Curve as:
         // serialized_proof (compressed, 4*32 bytes) || serialized_proof_values (6*32 bytes), i.e.
-        // [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> ]
+        // [ proof<128> | root<32> | external_nullifier<32> | share_x<32> | share_y<32> | nullifier<32> ]
         let mut input_byte: Vec<u8> = Vec::new();
         input_data.read_to_end(&mut input_byte)?;
         let proof = ArkProof::deserialize_compressed(&mut Cursor::new(&input_byte[..128]))?;
@@ -741,19 +676,18 @@ impl RLN<'_> {
         Ok(verified)
     }
 
-    /// Computes a zkSNARK RLN proof from the identity secret, the Merkle tree index, the user message limit, the message id, the external nullifier (which include epoch and rln identifier) and signal.
+    /// Computes a zkSNARK RLN proof from the identity secret, the Merkle tree index, the epoch and signal.
     ///
     /// Input values are:
-    /// - `input_data`: a reader for the serialization of `[ identity_secret<32> | id_index<8> | user_message_limit<32> | message_id<32> | external_nullifier<32> | signal_len<8> | signal<var> ]`
+    /// - `input_data`: a reader for the serialization of `[ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]`
     ///
     /// Output values are:
-    /// - `output_data`: a writer receiving the serialization of the zkSNARK proof and the circuit evaluations outputs, i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`
+    /// - `output_data`: a writer receiving the serialization of the zkSNARK proof and the circuit evaluations outputs, i.e. `[ proof<128> | root<32> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> | rln_identifier<32> ]`
     ///
-    /// Example
+    /// Example    
     /// ```
     /// use rln::protocol::*:
     /// use rln::utils::*;
-    /// use rln::hashers::*;
     ///
     /// // Generate identity pair
     /// let (identity_secret_hash, id_commitment) = keygen();
@@ -767,21 +701,15 @@ impl RLN<'_> {
     /// // We generate a random signal
     /// let mut rng = rand::thread_rng();
     /// let signal: [u8; 32] = rng.gen();
-    ///
     /// // We generate a random epoch
     /// let epoch = hash_to_field(b"test-epoch");
-    /// // We generate a random rln_identifier
-    /// let rln_identifier = hash_to_field(b"test-rln-identifier");
-    /// let external_nullifier = poseidon_hash(&[epoch, rln_identifier]);
     ///
     /// // We prepare input for generate_rln_proof API
-    /// // input_data is [ identity_secret<32> | id_index<8> | user_message_limit<32> | message_id<32> | external_nullifier<32> | signal_len<8> | signal<var> ]
+    /// // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
     /// let mut serialized: Vec<u8> = Vec::new();
     /// serialized.append(&mut fr_to_bytes_le(&identity_secret_hash));
     /// serialized.append(&mut normalize_usize(identity_index));
-    /// serialized.append(&mut fr_to_bytes_le(&user_message_limit));
-    /// serialized.append(&mut fr_to_bytes_le(&Fr::from(1))); // message_id
-    /// serialized.append(&mut fr_to_bytes_le(&external_nullifier));
+    /// serialized.append(&mut fr_to_bytes_le(&epoch));
     /// serialized.append(&mut normalize_usize(signal_len).resize(8,0));
     /// serialized.append(&mut signal.to_vec());
     ///
@@ -790,7 +718,7 @@ impl RLN<'_> {
     /// rln.generate_rln_proof(&mut input_buffer, &mut output_buffer)
     ///     .unwrap();
     ///
-    /// // proof_data is [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]
+    /// // proof_data is [ proof<128> | root<32> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> |  rln_identifier<32> ]
     /// let mut proof_data = output_buffer.into_inner();
     /// ```
     #[cfg(not(target_arch = "wasm32"))]
@@ -818,8 +746,9 @@ impl RLN<'_> {
     // TODO: this function seems to use redundant witness (as bigint and serialized) and should be refactored
     // Generate RLN Proof using a witness calculated from outside zerokit
     //
-    // output_data is [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]
-    #[cfg(target_arch = "wasm32")]
+    // output_data is  [ proof<128> | root<32> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> | rln_identifier<32> ]
+    // we skip it from documentation for now
+    #[doc(hidden)]
     pub fn generate_rln_proof_with_witness<W: Write>(
         &mut self,
         calculated_witness: Vec<BigInt>,
@@ -838,35 +767,10 @@ impl RLN<'_> {
         Ok(())
     }
 
-    // Generate RLN Proof using a witness calculated from outside zerokit
-    //
-    // output_data is  [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]
-    // we skip it from documentation for now
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn generate_rln_proof_with_witness<R: Read, W: Write>(
-        &mut self,
-        mut input_data: R,
-        mut output_data: W,
-    ) -> Result<()> {
-        let mut witness_byte: Vec<u8> = Vec::new();
-        input_data.read_to_end(&mut witness_byte)?;
-        let (rln_witness, _) = deserialize_witness(&witness_byte)?;
-        let proof_values = proof_values_from_witness(&rln_witness)?;
-
-        let proof = generate_proof(self.witness_calculator, &self.proving_key, &rln_witness)?;
-
-        // Note: we export a serialization of ark-groth16::Proof not semaphore::Proof
-        // This proof is compressed, i.e. 128 bytes long
-        proof.serialize_compressed(&mut output_data)?;
-        output_data.write_all(&serialize_proof_values(&proof_values))?;
-        Ok(())
-    }
-
     /// Verifies a zkSNARK RLN proof against the provided proof values and the state of the internal Merkle tree.
     ///
     /// Input values are:
-    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values and the signal information,
-    ///  i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var>]`, where <_> indicates the byte length.
+    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values and the signal information, i.e. `[ proof<128> | root<32> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> | rln_identifier<32> | signal_len<8> | signal<var> ]`
     ///
     /// The function returns true if the zkSNARK proof is valid with respect to the provided circuit output values and signal. Returns false otherwise.
     ///
@@ -880,7 +784,7 @@ impl RLN<'_> {
     /// // proof_data is computed as in the example code snippet provided for rln::public::RLN::generate_rln_proof
     ///
     /// // We prepare input for verify_rln_proof API
-    /// // input_data is  `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var>]`
+    /// // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
     /// // that is [ proof_data || signal_len<8> | signal<var> ]
     /// proof_data.append(&mut normalize_usize(signal_len));
     /// proof_data.append(&mut signal.to_vec());
@@ -917,7 +821,7 @@ impl RLN<'_> {
     /// Verifies a zkSNARK RLN proof against the provided proof values and a set of allowed Merkle tree roots.
     ///
     /// Input values are:
-    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values and the signal information, i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var>]`
+    /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values and the signal information, i.e. `[ proof<128> | root<32> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> | rln_identifier<32> | signal_len<8> | signal<var> ]`
     /// - `roots_data`: a reader for the serialization of a vector of roots, i.e. `[ number_of_roots<8> | root_1<32> | ... | root_n<32> ]` (number_of_roots is a uint64 in little-endian, roots are serialized using `rln::utils::fr_to_bytes_le`))
     ///
     /// The function returns true if the zkSNARK proof is valid with respect to the provided circuit output values, signal and roots. Returns false otherwise.
@@ -925,7 +829,7 @@ impl RLN<'_> {
     /// Note that contrary to [`verify_rln_proof`](crate::public::RLN::verify_rln_proof), this function does not check if the internal Merkle tree root corresponds to the root provided as input, but rather checks if the root provided as input in `input_data` corresponds to one of the roots serialized in `roots_data`.
     ///
     /// If `roots_data` contains no root (is empty), root validation is skipped and the proof will be correctly verified only if the other proof values results valid (i.e., zk-proof, signal, x-coordinate, RLN identifier)
-    ///
+    ///   
     /// Example
     /// ```
     /// // proof_data is computed as in the example code snippet provided for rln::public::RLN::generate_rln_proof
@@ -1172,12 +1076,10 @@ impl RLN<'_> {
         Ok(())
     }
 
-    /// Recovers the identity secret from two set of proof values computed for same secret in same epoch with same rln identifier.
+    /// Recovers the identity secret from two set of proof values computed for same secret in same epoch.
     ///
     /// Input values are:
-    /// - `input_proof_data_1`: a reader for the serialization of a RLN zkSNARK proof concatenated with a serialization of the circuit output values and -optionally- the signal information,
-    /// i.e. either `[proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`
-    /// or `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var> ]` (to maintain compatibility with both output of [`generate_rln_proof`](crate::public::RLN::generate_rln_proof) and input of [`verify_rln_proof`](crate::public::RLN::verify_rln_proof))
+    /// - `input_proof_data_1`: a reader for the serialization of a RLN zkSNARK proof concatenated with a serialization of the circuit output values and -optionally- the signal information, i.e. either `[ proof<128> | root<32> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> | rln_identifier<32> ]` or `[ proof<128> | root<32> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> | rln_identifier<32> | signal_len<8> | signal<var> ]` (to maintain compatibility with both output of [`generate_rln_proof`](crate::public::RLN::generate_rln_proof) and input of [`verify_rln_proof`](crate::public::RLN::verify_rln_proof))
     /// - `input_proof_data_2`: same as `input_proof_data_1`
     ///
     /// Output values are:
@@ -1185,7 +1087,7 @@ impl RLN<'_> {
     ///
     /// Example
     /// ```
-    /// // identity_secret_hash, proof_data_1 and proof_data_2 are computed as in the example code snippet provided for rln::public::RLN::generate_rln_proof using same identity secret, epoch and rln identifier (but not necessarily same signal)
+    /// // identity_secret_hash, proof_data_1 and proof_data_2 are computed as in the example code snippet provided for rln::public::RLN::generate_rln_proof using same identity secret and epoch (but not necessarily same signal)
     ///
     /// let mut input_proof_data_1 = Cursor::new(proof_data_1);
     /// let mut input_proof_data_2 = Cursor::new(proof_data_2);
@@ -1225,8 +1127,8 @@ impl RLN<'_> {
         let (proof_values_2, _) = deserialize_proof_values(&serialized[128..]);
         let external_nullifier_2 = proof_values_2.external_nullifier;
 
-        // We continue only if the proof values are for the same external nullifier (which includes epoch and rln identifier)
-        // The idea is that proof values that go as input to this function are verified first (with zk-proof verify), hence ensuring validity of external nullifier and other fields.
+        // We continue only if the proof values are for the same epoch
+        // The idea is that proof values that go as input to this function are verified first (with zk-proof verify), hence ensuring validity of epoch and other fields.
         // Only in case all fields are valid, an external_nullifier for the message will be stored (otherwise signal/proof will be simply discarded)
         // If the nullifier matches one already seen, we can recovery of identity secret.
         if external_nullifier_1 == external_nullifier_2 {
@@ -1248,10 +1150,10 @@ impl RLN<'_> {
         Ok(())
     }
 
-    /// Returns the serialization of a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) populated from the identity secret, the Merkle tree index, the user message limit, the message id, the external nullifier (which include epoch and rln identifier) and signal.
+    /// Returns the serialization of a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) populated from the identity secret, the Merkle tree index, the epoch and signal.
     ///
     /// Input values are:
-    /// - `input_data`: a reader for the serialization of `[ identity_secret<32> | id_index<8> | user_message_limit<32> | message_id<32> | external_nullifier<32> | signal_len<8> | signal<var> ]`
+    /// - `input_data`: a reader for the serialization of `[ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]`
     ///
     /// The function returns the corresponding [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object serialized using [`rln::protocol::serialize_witness`](crate::protocol::serialize_witness)).
     pub fn get_serialized_rln_witness<R: Read>(&mut self, mut input_data: R) -> Result<Vec<u8>> {
@@ -1271,7 +1173,7 @@ impl RLN<'_> {
     /// The function returns the corresponding JSON encoding of the input [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object.
     pub fn get_rln_witness_json(&mut self, serialized_witness: &[u8]) -> Result<serde_json::Value> {
         let (rln_witness, _) = deserialize_witness(serialized_witness)?;
-        rln_witness_to_json(&rln_witness)
+        get_json_inputs(&rln_witness)
     }
 
     /// Closes the connection to the Merkle tree database.
@@ -1287,7 +1189,7 @@ impl RLN<'_> {
 impl Default for RLN<'_> {
     fn default() -> Self {
         let tree_height = TEST_TREE_HEIGHT;
-        let buffer = Cursor::new(json!({}).to_string());
+        let buffer = Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
         Self::new(tree_height, buffer).unwrap()
     }
 }

rln/src/public_api_tests.rs

@@ -1,4 +1,4 @@
-use crate::circuit::{Curve, Fr, TEST_TREE_HEIGHT};
+use crate::circuit::{Curve, Fr, TEST_RESOURCES_FOLDER, TEST_TREE_HEIGHT};
 use crate::hashers::{hash_to_field, poseidon_hash as utils_poseidon_hash};
 use crate::protocol::*;
 use crate::public::RLN;
@@ -28,7 +28,9 @@ fn test_merkle_operations() {
     }
 
     // We create a new tree
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We first add leaves one by one specifying the index
     for (i, leaf) in leaves.iter().enumerate() {
@@ -122,7 +124,9 @@ fn test_leaf_setting_with_index() {
     let set_index = rng.gen_range(0..no_of_leaves) as usize;
 
     // We create a new tree
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We add leaves in a batch into the tree
     let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves).unwrap());
@@ -192,7 +196,9 @@ fn test_atomic_operation() {
     }
 
     // We create a new tree
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We add leaves in a batch into the tree
     let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves).unwrap());
@@ -241,7 +247,9 @@ fn test_atomic_operation_zero_indexed() {
     }
 
     // We create a new tree
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We add leaves in a batch into the tree
     let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves).unwrap());
@@ -285,7 +293,9 @@ fn test_atomic_operation_consistency() {
     }
 
     // We create a new tree
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We add leaves in a batch into the tree
     let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves).unwrap());
@@ -338,7 +348,9 @@ fn test_set_leaves_bad_index() {
     let bad_index = (1 << tree_height) - rng.gen_range(0..no_of_leaves) as usize;
 
     // We create a new tree
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // Get root of empty tree
     let mut buffer = Cursor::new(Vec::<u8>::new());
@@ -401,7 +413,9 @@ fn value_to_string_vec(value: &Value) -> Vec<String> {
 fn test_groth16_proof_hardcoded() {
     let tree_height = TEST_TREE_HEIGHT;
 
-    let rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let rln = RLN::new(tree_height, input_buffer).unwrap();
 
     let valid_snarkjs_proof = json!({
      "pi_a": [
@@ -481,7 +495,9 @@ fn test_groth16_proof_hardcoded() {
 fn test_groth16_proof() {
     let tree_height = TEST_TREE_HEIGHT;
 
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // Note: we only test Groth16 proof generation, so we ignore setting the tree in the RLN object
     let rln_witness = random_rln_witness(tree_height);
@@ -527,7 +543,9 @@ fn test_rln_proof() {
     }
 
     // We create a new RLN instance
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We add leaves in a batch into the tree
     let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves).unwrap());
@@ -570,11 +588,11 @@ fn test_rln_proof() {
     rln.generate_rln_proof(&mut input_buffer, &mut output_buffer)
         .unwrap();
 
-    // output_data is [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> ]
+    // output_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ]
     let mut proof_data = output_buffer.into_inner();
 
     // We prepare input for verify_rln_proof API
-    // input_data is  [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var> ]
+    // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
     // that is [ proof_data || signal_len<8> | signal<var> ]
     proof_data.append(&mut normalize_usize(signal.len()));
     proof_data.append(&mut signal.to_vec());
@@ -598,7 +616,9 @@ fn test_rln_with_witness() {
     }
 
     // We create a new RLN instance
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We add leaves in a batch into the tree
     let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves).unwrap());
@@ -665,16 +685,19 @@ fn test_rln_with_witness() {
         .collect();
 
     // Generating the proof
-    let mut input_buffer = Cursor::new(serialized_witness);
     let mut output_buffer = Cursor::new(Vec::<u8>::new());
-    rln.generate_rln_proof_with_witness(&mut input_buffer, &mut output_buffer)
-        .unwrap();
+    rln.generate_rln_proof_with_witness(
+        calculated_witness_vec,
+        serialized_witness,
+        &mut output_buffer,
+    )
+    .unwrap();
 
-    // output_data is  [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> ]
+    // output_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ]
     let mut proof_data = output_buffer.into_inner();
 
     // We prepare input for verify_rln_proof API
-    // input_data is  [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var> ]
+    // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
     // that is [ proof_data || signal_len<8> | signal<var> ]
     proof_data.append(&mut normalize_usize(signal.len()));
     proof_data.append(&mut signal.to_vec());
@@ -699,7 +722,9 @@ fn proof_verification_with_roots() {
     }
 
     // We create a new RLN instance
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We add leaves in a batch into the tree
     let mut buffer = Cursor::new(vec_fr_to_bytes_le(&leaves).unwrap());
@@ -726,7 +751,7 @@ fn proof_verification_with_roots() {
     let external_nullifier = utils_poseidon_hash(&[epoch, rln_identifier]);
 
     // We prepare input for generate_rln_proof API
-    // input_data is [ identity_secret<32> | id_index<8> | external_nullifier<32> | user_message_limit<32> | message_id<32> | signal_len<8> | signal<var> ]
+    // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | rln_identifier<32> | user_message_limit<32> | message_id<32> | signal_len<8> | signal<var> ]
     let mut serialized: Vec<u8> = Vec::new();
     serialized.append(&mut fr_to_bytes_le(&identity_secret_hash));
     serialized.append(&mut normalize_usize(identity_index));
@@ -741,11 +766,11 @@ fn proof_verification_with_roots() {
     rln.generate_rln_proof(&mut input_buffer, &mut output_buffer)
         .unwrap();
 
-    // output_data is  [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> ]
+    // output_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ]
     let mut proof_data = output_buffer.into_inner();
 
     // We prepare input for verify_rln_proof API
-    // input_data is [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var> ]
+    // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
     // that is [ proof_data || signal_len<8> | signal<var> ]
     proof_data.append(&mut normalize_usize(signal.len()));
     proof_data.append(&mut signal.to_vec());
@@ -791,7 +816,9 @@ fn test_recover_id_secret() {
     let tree_height = TEST_TREE_HEIGHT;
 
     // We create a new RLN instance
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // Generate identity pair
     let (identity_secret_hash, id_commitment) = keygen();
@@ -926,7 +953,9 @@ fn test_get_leaf() {
     // We generate a random tree
     let tree_height = 10;
     let mut rng = thread_rng();
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     // We generate a random leaf
     let leaf = Fr::rand(&mut rng);
@@ -948,10 +977,12 @@ fn test_get_leaf() {
 }
 
 #[test]
-fn test_valid_metadata() {
+fn test_metadata() {
     let tree_height = TEST_TREE_HEIGHT;
 
-    let mut rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
+    let input_buffer =
+        Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+    let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
     let arbitrary_metadata: &[u8] = b"block_number:200000";
     rln.set_metadata(arbitrary_metadata).unwrap();
@@ -962,16 +993,3 @@ fn test_valid_metadata() {
 
     assert_eq!(arbitrary_metadata, received_metadata);
 }
-
-#[test]
-fn test_empty_metadata() {
-    let tree_height = TEST_TREE_HEIGHT;
-
-    let rln = RLN::new(tree_height, generate_input_buffer()).unwrap();
-
-    let mut buffer = Cursor::new(Vec::<u8>::new());
-    rln.get_metadata(&mut buffer).unwrap();
-    let received_metadata = buffer.into_inner();
-
-    assert_eq!(received_metadata.len(), 0);
-}

rln/src/utils.rs

@@ -5,12 +5,10 @@ use ark_ff::PrimeField;
 use color_eyre::{Report, Result};
 use num_bigint::{BigInt, BigUint};
 use num_traits::Num;
-use serde_json::json;
-use std::io::Cursor;
 use std::iter::Extend;
 
 pub fn to_bigint(el: &Fr) -> Result<BigInt> {
-    let res: BigUint = (*el).into();
+    let res: BigUint = (*el).try_into()?;
     Ok(res.into())
 }
 
@@ -30,10 +28,10 @@ pub fn str_to_fr(input: &str, radix: u32) -> Result<Fr> {
     input_clean = input_clean.trim().to_string();
 
     if radix == 10 {
-        Ok(BigUint::from_str_radix(&input_clean, radix)?.into())
+        Ok(BigUint::from_str_radix(&input_clean, radix)?.try_into()?)
     } else {
         input_clean = input_clean.replace("0x", "");
-        Ok(BigUint::from_str_radix(&input_clean, radix)?.into())
+        Ok(BigUint::from_str_radix(&input_clean, radix)?.try_into()?)
     }
 }
 
@@ -181,24 +179,6 @@ pub fn normalize_usize(input: usize) -> Vec<u8> {
     normalized_usize
 }
 
-pub fn bytes_le_to_vec_usize(input: &[u8]) -> Result<Vec<usize>> {
-    let nof_elem = usize::try_from(u64::from_le_bytes(input[0..8].try_into()?))?;
-    if nof_elem == 0 {
-        Ok(vec![])
-    } else {
-        let elements: Vec<usize> = input[8..]
-            .chunks(8)
-            .map(|ch| usize::from_le_bytes(ch[0..8].try_into().unwrap()))
-            .collect();
-        Ok(elements)
-    }
-}
-
-// using for test
-pub fn generate_input_buffer() -> Cursor<String> {
-    Cursor::new(json!({}).to_string())
-}
-
 /* Old conversion utilities between different libraries data types
 
 // Conversion Utilities between poseidon-rs Field and arkworks Fr (in order to call directly poseidon-rs' poseidon_hash)

rln/tests/poseidon_tree.rs

@@ -4,25 +4,48 @@
 
 #[cfg(test)]
 mod test {
-    use rln::hashers::{poseidon_hash, PoseidonHash};
-    use rln::{circuit::*, poseidon_tree::PoseidonTree};
+    use rln::circuit::*;
+    use rln::hashers::PoseidonHash;
     use utils::{FullMerkleTree, OptimalMerkleTree, ZerokitMerkleProof, ZerokitMerkleTree};
 
     #[test]
-    // The test is checked correctness for `FullMerkleTree` and `OptimalMerkleTree` with Poseidon hash
-    fn test_zerokit_merkle_implementations() {
+    /// A basic performance comparison between the two supported Merkle Tree implementations
+    fn test_zerokit_merkle_implementations_performances() {
+        use std::time::{Duration, Instant};
+
+        let tree_height = 20;
         let sample_size = 100;
+
         let leaves: Vec<Fr> = (0..sample_size).map(|s| Fr::from(s)).collect();
 
-        let mut tree_full = FullMerkleTree::<PoseidonHash>::default(TEST_TREE_HEIGHT).unwrap();
-        let mut tree_opt = OptimalMerkleTree::<PoseidonHash>::default(TEST_TREE_HEIGHT).unwrap();
+        let mut gen_time_full: u128 = 0;
+        let mut upd_time_full: u128 = 0;
+        let mut gen_time_opt: u128 = 0;
+        let mut upd_time_opt: u128 = 0;
+
+        for _ in 0..sample_size.try_into().unwrap() {
+            let now = Instant::now();
+            FullMerkleTree::<PoseidonHash>::default(tree_height).unwrap();
+            gen_time_full += now.elapsed().as_nanos();
+
+            let now = Instant::now();
+            OptimalMerkleTree::<PoseidonHash>::default(tree_height).unwrap();
+            gen_time_opt += now.elapsed().as_nanos();
+        }
+
+        let mut tree_full = FullMerkleTree::<PoseidonHash>::default(tree_height).unwrap();
+        let mut tree_opt = OptimalMerkleTree::<PoseidonHash>::default(tree_height).unwrap();
 
         for i in 0..sample_size.try_into().unwrap() {
+            let now = Instant::now();
             tree_full.set(i, leaves[i]).unwrap();
+            upd_time_full += now.elapsed().as_nanos();
             let proof = tree_full.proof(i).expect("index should be set");
             assert_eq!(proof.leaf_index(), i);
 
+            let now = Instant::now();
             tree_opt.set(i, leaves[i]).unwrap();
+            upd_time_opt += now.elapsed().as_nanos();
             let proof = tree_opt.proof(i).expect("index should be set");
             assert_eq!(proof.leaf_index(), i);
         }
@@ -32,108 +55,26 @@ mod test {
         let tree_opt_root = tree_opt.root();
 
         assert_eq!(tree_full_root, tree_opt_root);
-    }
 
-    #[test]
-    fn test_subtree_root() {
-        const DEPTH: usize = 3;
-        const LEAVES_LEN: usize = 6;
-
-        let mut tree = PoseidonTree::default(DEPTH).unwrap();
-        let leaves: Vec<Fr> = (0..LEAVES_LEN).map(|s| Fr::from(s as i32)).collect();
-        let _ = tree.set_range(0, leaves);
-
-        for i in 0..LEAVES_LEN {
-            // check leaves
-            assert_eq!(
-                tree.get(i).unwrap(),
-                tree.get_subtree_root(DEPTH, i).unwrap()
-            );
-            // check root
-            assert_eq!(tree.root(), tree.get_subtree_root(0, i).unwrap());
-        }
-
-        // check intermediate nodes
-        for n in (1..=DEPTH).rev() {
-            for i in (0..(1 << n)).step_by(2) {
-                let idx_l = i * (1 << (DEPTH - n));
-                let idx_r = (i + 1) * (1 << (DEPTH - n));
-                let idx_sr = idx_l;
-
-                let prev_l = tree.get_subtree_root(n, idx_l).unwrap();
-                let prev_r = tree.get_subtree_root(n, idx_r).unwrap();
-                let subroot = tree.get_subtree_root(n - 1, idx_sr).unwrap();
-
-                assert_eq!(poseidon_hash(&[prev_l, prev_r]), subroot);
-            }
-        }
-    }
-
-    #[test]
-    fn test_get_empty_leaves_indices() {
-        let depth = 4;
-        let nof_leaves: usize = 1 << (depth - 1);
-
-        let mut tree = PoseidonTree::default(depth).unwrap();
-        let leaves: Vec<Fr> = (0..nof_leaves).map(|s| Fr::from(s as i32)).collect();
-
-        // check set_range
-        let _ = tree.set_range(0, leaves.clone());
-        assert!(tree.get_empty_leaves_indices().is_empty());
-
-        let mut vec_idxs = Vec::new();
-        // check delete function
-        for i in 0..nof_leaves {
-            vec_idxs.push(i);
-            let _ = tree.delete(i);
-            assert_eq!(tree.get_empty_leaves_indices(), vec_idxs);
-        }
-        // check set function
-        for i in (0..nof_leaves).rev() {
-            vec_idxs.pop();
-            let _ = tree.set(i, leaves[i]);
-            assert_eq!(tree.get_empty_leaves_indices(), vec_idxs);
-        }
-
-        // check remove_indices_and_set_leaves inside override_range function
-        assert!(tree.get_empty_leaves_indices().is_empty());
-        let leaves_2: Vec<Fr> = (0..2).map(|s| Fr::from(s as i32)).collect();
-        tree.override_range(0, leaves_2.clone(), [0, 1, 2, 3])
-            .unwrap();
-        assert_eq!(tree.get_empty_leaves_indices(), vec![2, 3]);
-
-        // check remove_indices inside override_range function
-        tree.override_range(0, [], [0, 1]).unwrap();
-        assert_eq!(tree.get_empty_leaves_indices(), vec![0, 1, 2, 3]);
-
-        // check set_range inside override_range function
-        tree.override_range(0, leaves_2.clone(), []).unwrap();
-        assert_eq!(tree.get_empty_leaves_indices(), vec![2, 3]);
-
-        let leaves_4: Vec<Fr> = (0..4).map(|s| Fr::from(s as i32)).collect();
-        // check if the indexes for write and delete are the same
-        tree.override_range(0, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        assert!(tree.get_empty_leaves_indices().is_empty());
-
-        // check if indexes for deletion are before indexes for overwriting
-        tree.override_range(4, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        // The result will be like this, because in the set_range function in pmtree
-        // the next_index value is increased not by the number of elements to insert,
-        // but by the union of indices for deleting and inserting.
-        assert_eq!(
-            tree.get_empty_leaves_indices(),
-            vec![0, 1, 2, 3, 8, 9, 10, 11]
+        println!(" Average tree generation time:");
+        println!(
+            "   - Full Merkle Tree:  {:?}",
+            Duration::from_nanos((gen_time_full / sample_size).try_into().unwrap())
+        );
+        println!(
+            "   - Optimal Merkle Tree: {:?}",
+            Duration::from_nanos((gen_time_opt / sample_size).try_into().unwrap())
         );
 
-        // check if the indices for write and delete do not overlap completely
-        tree.override_range(2, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        // The result will be like this, because in the set_range function in pmtree
-        // the next_index value is increased not by the number of elements to insert,
-        // but by the union of indices for deleting and inserting.
-        // + we've already set to 6 and 7 in previous test
-        assert_eq!(tree.get_empty_leaves_indices(), vec![0, 1, 8, 9, 10, 11]);
+        println!(" Average update_next execution time:");
+        println!(
+            "   - Full Merkle Tree: {:?}",
+            Duration::from_nanos((upd_time_full / sample_size).try_into().unwrap())
+        );
+
+        println!(
+            "   - Optimal Merkle Tree: {:?}",
+            Duration::from_nanos((upd_time_opt / sample_size).try_into().unwrap())
+        );
     }
 }

rln/tests/protocol.rs

@@ -1,8 +1,10 @@
 #[cfg(test)]
 mod test {
     use ark_ff::BigInt;
-    use rln::circuit::zkey_from_folder;
-    use rln::circuit::{circom_from_folder, vk_from_folder, Fr, TEST_TREE_HEIGHT};
+    use rln::circuit::{
+        circom_from_folder, vk_from_folder, zkey_from_folder, Fr, TEST_RESOURCES_FOLDER,
+        TEST_TREE_HEIGHT,
+    };
     use rln::hashers::{hash_to_field, poseidon_hash};
     use rln::poseidon_tree::PoseidonTree;
     use rln::protocol::*;
@@ -11,9 +13,65 @@ mod test {
 
     type ConfigOf<T> = <T as ZerokitMerkleTree>::Config;
 
+    // Input generated with https://github.com/oskarth/zk-kit/commit/b6a872f7160c7c14e10a0ea40acab99cbb23c9a8
+    const WITNESS_JSON_20: &str = r#"
+            {
+                "externalNullifier": "21074405743803627666274838159589343934394162804826017440941339048886754734203",
+                "identityPathIndex": [
+                    1,
+                    1,
+                    1,
+                    0,
+                    1,
+                    0,
+                    1,
+                    0,
+                    1,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    1,
+                    1,
+                    0
+                ],
+                "identitySecret": "2301650865650889795878889082892690584512243988708213561328369865554257051708",
+                "messageId": "1",
+                "pathElements": [
+                    "14082964758224722211945379872337797638951236517417253447686770846170014042825",
+                    "6628418579821163687428454604867534487917867918886059133241840211975892987309",
+                    "12745863228198753394445659605634840709296716381893463421165313830643281758511",
+                    "56118267389743063830320351452083247040583061493621478539311100137113963555",
+                    "3648731943306935051357703221473866306053186513730785325303257057776816073765",
+                    "10548621390442503192989374711060717107954536293658152583621924810330521179016",
+                    "11741160669079729961275351458682156164905457324981803454515784688429276743441",
+                    "17165464309215350864730477596846156251863702878546777829650812432906796008534",
+                    "18947162586829418653666557598416458949428989734998924978331450666032720066913",
+                    "8809427088917589399897132358419395928548406347152047718919154153577297139202",
+                    "6261460226929242970747566981077801929281729646713842579109271945192964422300",
+                    "13871468675790284383809887052382100311103716176061564908030808887079542722597",
+                    "10413964486611723004584705484327518190402370933255450052832412709168190985805",
+                    "3978387560092078849178760154060822400741873818692524912249877867958842934383",
+                    "14014915591348694328771517896715085647041518432952027841088176673715002508448",
+                    "17680675606519345547327984724173632294904524423937145835611954334756161077843",
+                    "17107175244885276119916848057745382329169223109661217238296871427531065458152",
+                    "18326186549441826262593357123467931475982067066825042001499291800252145875109",
+                    "7043961192177345916232559778383741091053414803377017307095275172896944935996",
+                    "2807630271073553218355393059254209097448243975722083008310815929736065268921"
+                ],
+                "userMessageLimit": "100",
+                "x": "20645213238265527935869146898028115621427162613172918400241870500502509785943"
+            }
+        "#;
+
     #[test]
     // We test Merkle tree generation, proofs and verification
     fn test_merkle_proof() {
+        let tree_height = TEST_TREE_HEIGHT;
         let leaf_index = 3;
 
         // generate identity
@@ -24,7 +82,7 @@ mod test {
         // generate merkle tree
         let default_leaf = Fr::from(0);
         let mut tree = PoseidonTree::new(
-            TEST_TREE_HEIGHT,
+            tree_height,
             default_leaf,
             ConfigOf::<PoseidonTree>::default(),
         )
@@ -34,49 +92,143 @@ mod test {
         // We check correct computation of the root
         let root = tree.root();
 
-        assert_eq!(
-            root,
-            BigInt([
-                4939322235247991215,
-                5110804094006647505,
-                4427606543677101242,
-                910933464535675827
-            ])
-            .into()
-        );
+        if TEST_TREE_HEIGHT == 20 || TEST_TREE_HEIGHT == 32 {
+            assert_eq!(
+                root,
+                BigInt([
+                    4939322235247991215,
+                    5110804094006647505,
+                    4427606543677101242,
+                    910933464535675827
+                ])
+                .into()
+            );
+        }
 
         let merkle_proof = tree.proof(leaf_index).expect("proof should exist");
         let path_elements = merkle_proof.get_path_elements();
+        dbg!(&path_elements);
+        dbg!(poseidon_hash(&[rate_commitment, Fr::from(0)]));
         let identity_path_index = merkle_proof.get_path_index();
 
         // We check correct computation of the path and indexes
-        let expected_path_elements: Vec<Fr> = [
-            "0x0000000000000000000000000000000000000000000000000000000000000000",
-            "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
-            "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
-            "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
-            "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
-            "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
-            "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
-            "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
-            "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
-            "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
-            "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
-            "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
-            "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
-            "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
-            "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
-            "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
-            "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
-            "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
-            "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
-            "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
-        ]
-        .map(|e| str_to_fr(e, 16).unwrap())
-        .to_vec();
+        // These values refers to TEST_TREE_HEIGHT == 16
+        let mut expected_path_elements = vec![
+            str_to_fr(
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
+                16,
+            )
+            .unwrap(),
+        ];
 
-        let expected_identity_path_index: Vec<u8> =
-            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        let mut expected_identity_path_index: Vec<u8> =
+            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        // We add the remaining elements for the case TEST_TREE_HEIGHT = 20
+        if TEST_TREE_HEIGHT == 20 {
+            expected_path_elements.append(&mut vec![
+                str_to_fr(
+                    "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
+                    16,
+                )
+                .unwrap(),
+            ]);
+            expected_identity_path_index.append(&mut vec![0, 0, 0, 0]);
+        }
+
+        if TEST_TREE_HEIGHT == 20 {
+            expected_path_elements.append(&mut vec![str_to_fr(
+                "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
+                16,
+            )
+            .unwrap()]);
+            expected_identity_path_index.append(&mut vec![0]);
+        }
 
         assert_eq!(path_elements, expected_path_elements);
         assert_eq!(identity_path_index, expected_identity_path_index);
@@ -85,8 +237,146 @@ mod test {
         assert!(tree.verify(&rate_commitment, &merkle_proof).unwrap());
     }
 
-    fn get_test_witness() -> RLNWitnessInput {
+    #[test]
+    // We test a RLN proof generation and verification
+    fn test_witness_from_json() {
+        // We generate all relevant keys
+        let proving_key = zkey_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+        let verification_key = vk_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+        let builder = circom_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+
+        // We compute witness from the json input example
+        let witness_json = WITNESS_JSON_20;
+        let rln_witness = rln_witness_from_json(witness_json).unwrap();
+
+        // Let's generate a zkSNARK proof
+        let proof = generate_proof(builder, &proving_key, &rln_witness).unwrap();
+        let proof_values = proof_values_from_witness(&rln_witness).unwrap();
+
+        // Let's verify the proof
+        let verified = verify_proof(&verification_key, &proof, &proof_values);
+
+        assert!(verified.unwrap());
+    }
+
+    #[test]
+    fn test_compute_root_single_insertion() {
+        let tree_height = TEST_TREE_HEIGHT;
+        let leaf_index = 0;
+
+        let rate_commitment = str_to_fr(
+            "0x2A09A9FD93C590C26B91EFFBB2499F07E8F7AA12E2B4940A3AED2411CB65E11C",
+            16,
+        )
+        .unwrap();
+
+        let default_leaf = Fr::from(0);
+        let mut tree = PoseidonTree::new(
+            tree_height,
+            default_leaf,
+            ConfigOf::<PoseidonTree>::default(),
+        )
+        .unwrap();
+        tree.set(leaf_index, rate_commitment.into()).unwrap();
+
+        assert_eq!(
+            tree.root().to_string(),
+            "7919895337495550471953660523154055129542864206434083474237224229170626792564"
+        );
+    }
+
+    #[test]
+    fn test_compute_root_multiple_insertions() {
+        let tree_height = TEST_TREE_HEIGHT;
+        let start_index = 0;
+
+        let rate_commitments: Vec<Fr> = [
+            BigInt([
+                6344960399222479404,
+                8873735028955887118,
+                7344916015079734877,
+                3049769223023031486,
+            ]),
+            BigInt([
+                5712098114927176582,
+                8940737845291386850,
+                13760702216785496874,
+                2705829225787818087,
+            ]),
+            BigInt([
+                11095489423361569757,
+                3600059334404558726,
+                2596276295120316067,
+                1747990648971046346,
+            ]),
+            BigInt([
+                6042348329893423557,
+                18258910608249868782,
+                15808282831752017379,
+                431669247253051424,
+            ]),
+            BigInt([
+                10095207707778447201,
+                5682738389371124904,
+                13211310082780638286,
+                1315201582035914269,
+            ]),
+            BigInt([
+                17025532269492512967,
+                1150892318682047614,
+                9382150527271933425,
+                3232654496558305327,
+            ]),
+            BigInt([
+                12575250814731208081,
+                3588033008530583836,
+                14988210865591309718,
+                1882695786084137797,
+            ]),
+            BigInt([
+                2907978739955320703,
+                8716018548752635030,
+                10462674785957232325,
+                2943370953425792650,
+            ]),
+            BigInt([
+                5234706529109067247,
+                11231622334196983240,
+                1886386083208828393,
+                1690607978854820878,
+            ]),
+            BigInt([
+                12359804935986041669,
+                10294673542421867784,
+                11783956311711833641,
+                2759017549080634703,
+            ]),
+        ]
+        .into_iter()
+        .map(|x| Fr::from(x))
+        .collect();
+
+        let default_leaf = Fr::from(0);
+        let mut tree = PoseidonTree::new(
+            tree_height,
+            default_leaf,
+            ConfigOf::<PoseidonTree>::default(),
+        )
+        .unwrap();
+        tree.set_range(start_index, rate_commitments).unwrap();
+
+        assert_eq!(
+            tree.root().to_string(),
+            "5210724218081541877101688952118136930297124697603087561558225712176057209122"
+        );
+    }
+
+    #[test]
+    // We test a RLN proof generation and verification
+    fn test_end_to_end() {
+        let tree_height = TEST_TREE_HEIGHT;
         let leaf_index = 3;
+
         // Generate identity pair
         let (identity_secret_hash, id_commitment) = keygen();
         let user_message_limit = Fr::from(100);
@@ -95,7 +385,7 @@ mod test {
         //// generate merkle tree
         let default_leaf = Fr::from(0);
         let mut tree = PoseidonTree::new(
-            TEST_TREE_HEIGHT,
+            tree_height,
             default_leaf,
             ConfigOf::<PoseidonTree>::default(),
         )
@@ -112,7 +402,7 @@ mod test {
         let rln_identifier = hash_to_field(b"test-rln-identifier");
         let external_nullifier = poseidon_hash(&[epoch, rln_identifier]);
 
-        rln_witness_from_values(
+        let rln_witness: RLNWitnessInput = rln_witness_from_values(
             identity_secret_hash,
             &merkle_proof,
             x,
@@ -120,50 +410,17 @@ mod test {
             user_message_limit,
             Fr::from(1),
         )
-        .unwrap()
-    }
-
-    #[test]
-    // We test a RLN proof generation and verification
-    fn test_witness_from_json() {
-        // We generate all relevant keys
-        let proving_key = zkey_from_folder().unwrap();
-        let verification_key = vk_from_folder().unwrap();
-        let builder = circom_from_folder().unwrap();
-
-        // We compute witness from the json input
-        let rln_witness = get_test_witness();
-        let rln_witness_json = rln_witness_to_json(&rln_witness).unwrap();
-        let rln_witness_deser = rln_witness_from_json(rln_witness_json).unwrap();
-        assert_eq!(rln_witness_deser, rln_witness);
-
-        // Let's generate a zkSNARK proof
-        let proof = generate_proof(builder, &proving_key, &rln_witness_deser).unwrap();
-        let proof_values = proof_values_from_witness(&rln_witness_deser).unwrap();
-
-        // Let's verify the proof
-        let verified = verify_proof(&verification_key, &proof, &proof_values);
-
-        assert!(verified.unwrap());
-    }
-
-    #[test]
-    // We test a RLN proof generation and verification
-    fn test_end_to_end() {
-        let rln_witness = get_test_witness();
-        let rln_witness_json = rln_witness_to_json(&rln_witness).unwrap();
-        let rln_witness_deser = rln_witness_from_json(rln_witness_json).unwrap();
-        assert_eq!(rln_witness_deser, rln_witness);
+        .unwrap();
 
         // We generate all relevant keys
-        let proving_key = zkey_from_folder().unwrap();
-        let verification_key = vk_from_folder().unwrap();
-        let builder = circom_from_folder().unwrap();
+        let proving_key = zkey_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+        let verification_key = vk_from_folder(TEST_RESOURCES_FOLDER).unwrap();
+        let builder = circom_from_folder(TEST_RESOURCES_FOLDER).unwrap();
 
         // Let's generate a zkSNARK proof
-        let proof = generate_proof(builder, &proving_key, &rln_witness_deser).unwrap();
+        let proof = generate_proof(builder, &proving_key, &rln_witness).unwrap();
 
-        let proof_values = proof_values_from_witness(&rln_witness_deser).unwrap();
+        let proof_values = proof_values_from_witness(&rln_witness).unwrap();
 
         // Let's verify the proof
         let success = verify_proof(&verification_key, &proof, &proof_values).unwrap();
@@ -173,13 +430,11 @@ mod test {
 
     #[test]
     fn test_witness_serialization() {
-        // We test witness JSON serialization
-        let rln_witness = get_test_witness();
-        let rln_witness_json = rln_witness_to_json(&rln_witness).unwrap();
-        let rln_witness_deser = rln_witness_from_json(rln_witness_json).unwrap();
-        assert_eq!(rln_witness_deser, rln_witness);
-
         // We test witness serialization
+        let witness_json: &str = WITNESS_JSON_20;
+
+        let rln_witness = rln_witness_from_json(witness_json).unwrap();
+
         let ser = serialize_witness(&rln_witness).unwrap();
         let (deser, _) = deserialize_witness(&ser).unwrap();
         assert_eq!(rln_witness, deser);
@@ -191,6 +446,24 @@ mod test {
         assert_eq!(proof_values, deser);
     }
 
+    #[test]
+    fn test_poseidon_hash() {
+        let inputs = &[
+            str_to_fr(
+                "0x2A09A9FD93C590C26B91EFFBB2499F07E8F7AA12E2B4940A3AED2411CB65E11C",
+                16,
+            )
+            .unwrap(),
+            Fr::from(0),
+        ];
+        let hash = poseidon_hash(inputs);
+
+        assert_eq!(
+            hash.to_string(),
+            "13164376930590487041313497514223288845711140604177161029957349518915056324115"
+        );
+    }
+
     #[test]
     // Tests seeded keygen
     // Note that hardcoded values are only valid for Bn254

rln/tests/public.rs

@@ -3,56 +3,59 @@ mod test {
     use ark_ff::BigInt;
     use ark_std::{rand::thread_rng, UniformRand};
     use rand::Rng;
-    use rln::circuit::{Fr, TEST_TREE_HEIGHT};
+    use rln::circuit::{Fr, TEST_RESOURCES_FOLDER, TEST_TREE_HEIGHT};
     use rln::hashers::{hash_to_field, poseidon_hash as utils_poseidon_hash, ROUND_PARAMS};
     use rln::protocol::{compute_tree_root, deserialize_identity_tuple};
     use rln::public::{hash as public_hash, poseidon_hash as public_poseidon_hash, RLN};
     use rln::utils::*;
+    use serde_json::json;
     use std::io::Cursor;
 
     #[test]
     // This test is similar to the one in lib, but uses only public API
     fn test_merkle_proof() {
+        let tree_height = TEST_TREE_HEIGHT;
         let leaf_index = 3;
         let user_message_limit = 1;
 
-        let mut rln = RLN::new(TEST_TREE_HEIGHT, generate_input_buffer()).unwrap();
+        let input_buffer =
+            Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
+        let mut rln = RLN::new(tree_height, input_buffer).unwrap();
 
         // generate identity
         let identity_secret_hash = hash_to_field(b"test-merkle-proof");
         let id_commitment = utils_poseidon_hash(&vec![identity_secret_hash]);
         let rate_commitment = utils_poseidon_hash(&[id_commitment, user_message_limit.into()]);
 
-        // check that leaves indices is empty
-        let mut buffer = Cursor::new(Vec::<u8>::new());
-        rln.get_empty_leaves_indices(&mut buffer).unwrap();
-        let idxs = bytes_le_to_vec_usize(&buffer.into_inner()).unwrap();
-        assert!(idxs.is_empty());
-
         // We pass rate_commitment as Read buffer to RLN's set_leaf
         let mut buffer = Cursor::new(fr_to_bytes_le(&rate_commitment));
         rln.set_leaf(leaf_index, &mut buffer).unwrap();
 
-        // check that leaves before leaf_index is set to zero
-        let mut buffer = Cursor::new(Vec::<u8>::new());
-        rln.get_empty_leaves_indices(&mut buffer).unwrap();
-        let idxs = bytes_le_to_vec_usize(&buffer.into_inner()).unwrap();
-        assert_eq!(idxs, [0, 1, 2]);
-
         // We check correct computation of the root
         let mut buffer = Cursor::new(Vec::<u8>::new());
         rln.get_root(&mut buffer).unwrap();
         let (root, _) = bytes_le_to_fr(&buffer.into_inner());
 
-        assert_eq!(
-            root,
-            Fr::from(BigInt([
-                17110646155607829651,
-                5040045984242729823,
-                6965416728592533086,
-                2328960363755461975
-            ]))
-        );
+        if TEST_TREE_HEIGHT == 20 {
+            assert_eq!(
+                root,
+                Fr::from(BigInt([
+                    17110646155607829651,
+                    5040045984242729823,
+                    6965416728592533086,
+                    2328960363755461975
+                ]))
+            );
+        } else if TEST_TREE_HEIGHT == 32 {
+            assert_eq!(
+                root,
+                str_to_fr(
+                    "0x21947ffd0bce0c385f876e7c97d6a42eec5b1fe935aab2f01c1f8a8cbcc356d2",
+                    16
+                )
+                .unwrap()
+            );
+        }
 
         // We check correct computation of merkle proof
         let mut buffer = Cursor::new(Vec::<u8>::new());
@@ -63,60 +66,126 @@ mod test {
         let (identity_path_index, _) = bytes_le_to_vec_u8(&buffer_inner[read..].to_vec()).unwrap();
 
         // We check correct computation of the path and indexes
-        let expected_path_elements: Vec<Fr> = [
-            "0x0000000000000000000000000000000000000000000000000000000000000000",
-            "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
-            "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
-            "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
-            "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
-            "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
-            "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
-            "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
-            "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
-            "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
-            "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
-            "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
-            "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
-            "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
-            "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
-            "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
-            "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
-            "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
-            "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
-            "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
-        ]
-        .map(|e| str_to_fr(e, 16).unwrap())
-        .to_vec();
+        let mut expected_path_elements = vec![
+            str_to_fr(
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0",
+                16,
+            )
+            .unwrap(),
+            str_to_fr(
+                "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c",
+                16,
+            )
+            .unwrap(),
+        ];
 
-        let expected_identity_path_index: Vec<u8> =
-            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        let mut expected_identity_path_index: Vec<u8> =
+            vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+        // We add the remaining elements for the case TEST_TREE_HEIGHT = 20
+        if TEST_TREE_HEIGHT == 20 || TEST_TREE_HEIGHT == 32 {
+            expected_path_elements.append(&mut vec![
+                str_to_fr(
+                    "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992",
+                    16,
+                )
+                .unwrap(),
+                str_to_fr(
+                    "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f",
+                    16,
+                )
+                .unwrap(),
+            ]);
+            expected_identity_path_index.append(&mut vec![0, 0, 0, 0]);
+        }
+
+        if TEST_TREE_HEIGHT == 20 {
+            expected_path_elements.append(&mut vec![str_to_fr(
+                "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca",
+                16,
+            )
+            .unwrap()]);
+            expected_identity_path_index.append(&mut vec![0]);
+        }
 
         assert_eq!(path_elements, expected_path_elements);
         assert_eq!(identity_path_index, expected_identity_path_index);
 
-        // check subtree root computation for leaf 0 for all corresponding node until the root
-        let l_idx = 0;
-        for n in (1..=TEST_TREE_HEIGHT).rev() {
-            let idx_l = l_idx * (1 << (TEST_TREE_HEIGHT - n));
-            let idx_r = (l_idx + 1) * (1 << (TEST_TREE_HEIGHT - n));
-            let idx_sr = idx_l;
-
-            let mut buffer = Cursor::new(Vec::<u8>::new());
-            rln.get_subtree_root(n, idx_l, &mut buffer).unwrap();
-            let (prev_l, _) = bytes_le_to_fr(&buffer.into_inner());
-
-            let mut buffer = Cursor::new(Vec::<u8>::new());
-            rln.get_subtree_root(n, idx_r, &mut buffer).unwrap();
-            let (prev_r, _) = bytes_le_to_fr(&buffer.into_inner());
-
-            let mut buffer = Cursor::new(Vec::<u8>::new());
-            rln.get_subtree_root(n - 1, idx_sr, &mut buffer).unwrap();
-            let (subroot, _) = bytes_le_to_fr(&buffer.into_inner());
-
-            let res = utils_poseidon_hash(&[prev_l, prev_r]);
-            assert_eq!(res, subroot);
-        }
-
         // We double check that the proof computed from public API is correct
         let root_from_proof = compute_tree_root(
             &identity_secret_hash,

semaphore/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "semaphore-wrapper"
+version = "0.3.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = []
+dylib = [ "wasmer/dylib", "wasmer-engine-dylib", "wasmer-compiler-cranelift" ]
+
+[dependencies]
+ark-bn254 = { version = "0.3.0" }
+ark-circom = { git = "https://github.com/gakonst/ark-circom", features=["circom-2"], rev = "35ce5a9" }
+ark-ec = { version = "0.3.0", default-features = false, features = ["parallel"] }
+ark-groth16 = { git = "https://github.com/arkworks-rs/groth16", rev = "765817f", features = ["parallel"] }
+ark-relations = { version = "0.3.0", default-features = false }
+ark-std = { version = "0.3.0", default-features = false, features = ["parallel"] }
+color-eyre = "0.6.2"
+once_cell = "1.17.1"
+rand = "0.8.5"
+semaphore = { git = "https://github.com/worldcoin/semaphore-rs", rev = "ee658c2"}
+ethers-core = { version = "2.0.10", default-features = false }
+ruint = { version = "1.10.0", features = [ "serde", "num-bigint", "ark-ff" ] }
+serde = "1.0"
+thiserror = "1.0.39"
+wasmer = { version = "2.3" }
+
+[dev-dependencies]
+rand_chacha = "0.3.1"
+serde_json = "1.0.96"
+
+[build-dependencies]
+color-eyre = "0.6.2"
+wasmer = { version = "2.3" }
+wasmer-engine-dylib = { version = "2.3.0", optional = true }
+wasmer-compiler-cranelift = { version = "3.3.0", optional = true }
+
+[profile.release]
+codegen-units = 1
+lto = true
+panic = "abort"
+opt-level = 3
+
+# Compilation profile for any non-workspace member.
+# Dependencies are optimized, even in a dev build. This improves dev performance
+# while having neglible impact on incremental build times.
+[profile.dev.package."*"]
+opt-level = 3

semaphore/Makefile.toml

@@ -0,0 +1,7 @@
+[tasks.build]
+command = "cargo"
+args = ["build", "--release"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--release"]

semaphore/README.md

@@ -0,0 +1,18 @@
+# Semaphore example package
+
+This is basically a wrapper around/copy of
+https://github.com/worldcoin/semaphore-rs to illustrate how e.g. RLN package
+can be structured like.
+
+Goal is also to provide a basic FFI around protocol.rs, which is currently not
+in scope for that project.
+
+See that project for more information.
+
+## Build and Test
+
+To build and test, run the following commands within the module folder
+```bash
+cargo make build
+cargo make test
+```

semaphore/build.rs

@@ -0,0 +1,111 @@
+// Adapted from semaphore-rs/build.rs
+use color_eyre::eyre::{eyre, Result};
+use std::{
+    path::{Component, Path, PathBuf},
+    process::Command,
+};
+
+const ZKEY_FILE: &str = "./vendor/semaphore/build/snark/semaphore_final.zkey";
+const WASM_FILE: &str = "./vendor/semaphore/build/snark/semaphore.wasm";
+
+// See <https://internals.rust-lang.org/t/path-to-lexical-absolute/14940>
+fn absolute(path: &str) -> Result<PathBuf> {
+    let path = Path::new(path);
+    let mut absolute = if path.is_absolute() {
+        PathBuf::new()
+    } else {
+        std::env::current_dir()?
+    };
+    for component in path.components() {
+        match component {
+            Component::CurDir => {}
+            Component::ParentDir => {
+                absolute.pop();
+            }
+            component => absolute.push(component.as_os_str()),
+        }
+    }
+    Ok(absolute)
+}
+
+fn build_circuit() -> Result<()> {
+    println!("cargo:rerun-if-changed=./vendor/semaphore");
+    let run = |cmd: &[&str]| -> Result<()> {
+        // TODO: Use ExitCode::exit_ok() when stable.
+        Command::new(cmd[0])
+            .args(cmd[1..].iter())
+            .current_dir("./vendor/semaphore")
+            .status()?
+            .success()
+            .then_some(())
+            .ok_or(eyre!("procees returned failure"))?;
+        Ok(())
+    };
+
+    // Compute absolute paths
+    let zkey_file = absolute(ZKEY_FILE)?;
+    let wasm_file = absolute(WASM_FILE)?;
+
+    // Build circuits if not exists
+    // TODO: This does not rebuild if the semaphore submodule is changed.
+    // NOTE: This requires npm / nodejs to be installed.
+    if !(zkey_file.exists() && wasm_file.exists()) {
+        run(&["npm", "install"])?;
+        run(&["npm", "exec", "ts-node", "./scripts/compile-circuits.ts"])?;
+    }
+    assert!(zkey_file.exists());
+    assert!(wasm_file.exists());
+
+    // Export generated paths
+    println!("cargo:rustc-env=BUILD_RS_ZKEY_FILE={}", zkey_file.display());
+    println!("cargo:rustc-env=BUILD_RS_WASM_FILE={}", wasm_file.display());
+
+    Ok(())
+}
+
+#[cfg(feature = "dylib")]
+fn build_dylib() -> Result<()> {
+    use enumset::enum_set;
+    use std::{env, str::FromStr};
+    use wasmer::{Module, Store, Target, Triple};
+    use wasmer_compiler_cranelift::Cranelift;
+    use wasmer_engine_dylib::Dylib;
+
+    let wasm_file = absolute(WASM_FILE)?;
+    assert!(wasm_file.exists());
+
+    let out_dir = env::var("OUT_DIR")?;
+    let out_dir = Path::new(&out_dir).to_path_buf();
+    let dylib_file = out_dir.join("semaphore.dylib");
+    println!(
+        "cargo:rustc-env=CIRCUIT_WASM_DYLIB={}",
+        dylib_file.display()
+    );
+
+    if dylib_file.exists() {
+        return Ok(());
+    }
+
+    // Create a WASM engine for the target that can compile
+    let triple = Triple::from_str(&env::var("TARGET")?).map_err(|e| eyre!(e))?;
+    let cpu_features = enum_set!();
+    let target = Target::new(triple, cpu_features);
+    let compiler_config = Cranelift::default();
+    let engine = Dylib::new(compiler_config).target(target).engine();
+
+    // Compile the WASM module
+    let store = Store::new(&engine);
+    let module = Module::from_file(&store, &wasm_file)?;
+    module.serialize_to_file(&dylib_file)?;
+    assert!(dylib_file.exists());
+    println!("cargo:warning=Circuit dylib is in {}", dylib_file.display());
+
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    build_circuit()?;
+    #[cfg(feature = "dylib")]
+    build_dylib()?;
+    Ok(())
+}

semaphore/src/circuit.rs

@@ -0,0 +1,79 @@
+// Adapted from semaphore-rs/src/circuit.rs
+use ark_bn254::{Bn254, Fr};
+use ark_circom::{read_zkey, WitnessCalculator};
+use ark_groth16::ProvingKey;
+use ark_relations::r1cs::ConstraintMatrices;
+use core::include_bytes;
+use once_cell::sync::{Lazy, OnceCell};
+use std::{io::Cursor, sync::Mutex};
+use wasmer::{Module, Store};
+
+#[cfg(feature = "dylib")]
+use std::{env, path::Path};
+#[cfg(feature = "dylib")]
+use wasmer::Dylib;
+
+const ZKEY_BYTES: &[u8] = include_bytes!(env!("BUILD_RS_ZKEY_FILE"));
+
+#[cfg(not(feature = "dylib"))]
+const WASM: &[u8] = include_bytes!(env!("BUILD_RS_WASM_FILE"));
+
+static ZKEY: Lazy<(ProvingKey<Bn254>, ConstraintMatrices<Fr>)> = Lazy::new(|| {
+    let mut reader = Cursor::new(ZKEY_BYTES);
+    read_zkey(&mut reader).expect("zkey should be valid")
+});
+
+static WITNESS_CALCULATOR: OnceCell<Mutex<WitnessCalculator>> = OnceCell::new();
+
+/// Initialize the library.
+#[cfg(feature = "dylib")]
+pub fn initialize(dylib_path: &Path) {
+    WITNESS_CALCULATOR
+        .set(from_dylib(dylib_path))
+        .expect("Failed to initialize witness calculator");
+
+    // Force init of ZKEY
+    Lazy::force(&ZKEY);
+}
+
+#[cfg(feature = "dylib")]
+fn from_dylib(path: &Path) -> Mutex<WitnessCalculator> {
+    let store = Store::new(&Dylib::headless().engine());
+    // The module must be exported using [`Module::serialize`].
+    let module = unsafe {
+        Module::deserialize_from_file(&store, path).expect("Failed to load wasm dylib module")
+    };
+    let result =
+        WitnessCalculator::from_module(module).expect("Failed to create witness calculator");
+    Mutex::new(result)
+}
+
+#[must_use]
+pub fn zkey() -> &'static (ProvingKey<Bn254>, ConstraintMatrices<Fr>) {
+    &ZKEY
+}
+
+#[cfg(feature = "dylib")]
+#[must_use]
+pub fn witness_calculator() -> &'static Mutex<WitnessCalculator> {
+    WITNESS_CALCULATOR.get_or_init(|| {
+        let path = env::var("CIRCUIT_WASM_DYLIB").expect(
+            "Semaphore-rs is not initialized. The library needs to be initialized before use when \
+             build with the `cdylib` feature. You can initialize by calling `initialize` or \
+             seting the `CIRCUIT_WASM_DYLIB` environment variable.",
+        );
+        from_dylib(Path::new(&path))
+    })
+}
+
+#[cfg(not(feature = "dylib"))]
+#[must_use]
+pub fn witness_calculator() -> &'static Mutex<WitnessCalculator> {
+    WITNESS_CALCULATOR.get_or_init(|| {
+        let store = Store::default();
+        let module = Module::from_binary(&store, WASM).expect("wasm should be valid");
+        let result =
+            WitnessCalculator::from_module(module).expect("Failed to create witness calculator");
+        Mutex::new(result)
+    })
+}

semaphore/src/lib.rs

@@ -0,0 +1,7 @@
+#![allow(clippy::multiple_crate_versions)]
+
+pub mod circuit;
+pub mod protocol;
+
+#[cfg(feature = "dylib")]
+pub use circuit::initialize;

semaphore/src/protocol.rs

@@ -0,0 +1,215 @@
+// Adapted from semaphore-rs/src/protocol.rs
+// For illustration purposes only as an example protocol
+
+// Private module
+use crate::circuit::{witness_calculator, zkey};
+
+use ark_bn254::{Bn254, Parameters};
+use ark_circom::CircomReduction;
+use ark_ec::bn::Bn;
+use ark_groth16::{
+    create_proof_with_reduction_and_matrices, prepare_verifying_key, Proof as ArkProof,
+};
+use ark_relations::r1cs::SynthesisError;
+use ark_std::UniformRand;
+use color_eyre::{Report, Result};
+use ethers_core::types::U256;
+use rand::{thread_rng, Rng};
+use semaphore::{
+    identity::Identity,
+    merkle_tree::{self, Branch},
+    poseidon,
+    poseidon_tree::PoseidonHash,
+    Field,
+};
+use serde::{Deserialize, Serialize};
+use std::time::Instant;
+use thiserror::Error;
+
+// Matches the private G1Tup type in ark-circom.
+pub type G1 = (U256, U256);
+
+// Matches the private G2Tup type in ark-circom.
+pub type G2 = ([U256; 2], [U256; 2]);
+
+/// Wrap a proof object so we have serde support
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Proof(G1, G2, G1);
+
+impl From<ArkProof<Bn<Parameters>>> for Proof {
+    fn from(proof: ArkProof<Bn<Parameters>>) -> Self {
+        let proof = ark_circom::ethereum::Proof::from(proof);
+        let (a, b, c) = proof.as_tuple();
+        Self(a, b, c)
+    }
+}
+
+impl From<Proof> for ArkProof<Bn<Parameters>> {
+    fn from(proof: Proof) -> Self {
+        let eth_proof = ark_circom::ethereum::Proof {
+            a: ark_circom::ethereum::G1 {
+                x: proof.0 .0,
+                y: proof.0 .1,
+            },
+            #[rustfmt::skip] // Rustfmt inserts some confusing spaces
+            b: ark_circom::ethereum::G2 {
+                // The order of coefficients is flipped.
+                x: [proof.1.0[1], proof.1.0[0]],
+                y: [proof.1.1[1], proof.1.1[0]],
+            },
+            c: ark_circom::ethereum::G1 {
+                x: proof.2 .0,
+                y: proof.2 .1,
+            },
+        };
+        eth_proof.into()
+    }
+}
+
+/// Helper to merkle proof into a bigint vector
+/// TODO: we should create a From trait for this
+fn merkle_proof_to_vec(proof: &merkle_tree::Proof<PoseidonHash>) -> Vec<Field> {
+    proof
+        .0
+        .iter()
+        .map(|x| match x {
+            Branch::Left(value) | Branch::Right(value) => *value,
+        })
+        .collect()
+}
+
+/// Generates the nullifier hash
+#[must_use]
+pub fn generate_nullifier_hash(identity: &Identity, external_nullifier: Field) -> Field {
+    poseidon::hash2(external_nullifier, identity.nullifier)
+}
+
+#[derive(Error, Debug)]
+pub enum ProofError {
+    #[error("Error reading circuit key: {0}")]
+    CircuitKeyError(#[from] std::io::Error),
+    #[error("Error producing witness: {0}")]
+    WitnessError(Report),
+    #[error("Error producing proof: {0}")]
+    SynthesisError(#[from] SynthesisError),
+    #[error("Error converting public input: {0}")]
+    ToFieldError(#[from] ruint::ToFieldError),
+}
+
+/// Generates a semaphore proof
+///
+/// # Errors
+///
+/// Returns a [`ProofError`] if proving fails.
+pub fn generate_proof(
+    identity: &Identity,
+    merkle_proof: &merkle_tree::Proof<PoseidonHash>,
+    external_nullifier_hash: Field,
+    signal_hash: Field,
+) -> Result<Proof, ProofError> {
+    generate_proof_rng(
+        identity,
+        merkle_proof,
+        external_nullifier_hash,
+        signal_hash,
+        &mut thread_rng(),
+    )
+}
+
+/// Generates a semaphore proof from entropy
+///
+/// # Errors
+///
+/// Returns a [`ProofError`] if proving fails.
+pub fn generate_proof_rng(
+    identity: &Identity,
+    merkle_proof: &merkle_tree::Proof<PoseidonHash>,
+    external_nullifier_hash: Field,
+    signal_hash: Field,
+    rng: &mut impl Rng,
+) -> Result<Proof, ProofError> {
+    generate_proof_rs(
+        identity,
+        merkle_proof,
+        external_nullifier_hash,
+        signal_hash,
+        ark_bn254::Fr::rand(rng),
+        ark_bn254::Fr::rand(rng),
+    )
+}
+
+fn generate_proof_rs(
+    identity: &Identity,
+    merkle_proof: &merkle_tree::Proof<PoseidonHash>,
+    external_nullifier_hash: Field,
+    signal_hash: Field,
+    r: ark_bn254::Fr,
+    s: ark_bn254::Fr,
+) -> Result<Proof, ProofError> {
+    let inputs = [
+        ("identityNullifier", vec![identity.nullifier]),
+        ("identityTrapdoor", vec![identity.trapdoor]),
+        ("treePathIndices", merkle_proof.path_index()),
+        ("treeSiblings", merkle_proof_to_vec(merkle_proof)),
+        ("externalNullifier", vec![external_nullifier_hash]),
+        ("signalHash", vec![signal_hash]),
+    ];
+    let inputs = inputs.into_iter().map(|(name, values)| {
+        (
+            name.to_string(),
+            values.iter().copied().map(Into::into).collect::<Vec<_>>(),
+        )
+    });
+
+    let now = Instant::now();
+
+    let full_assignment = witness_calculator()
+        .lock()
+        .expect("witness_calculator mutex should not get poisoned")
+        .calculate_witness_element::<Bn254, _>(inputs, false)
+        .map_err(ProofError::WitnessError)?;
+
+    println!("witness generation took: {:.2?}", now.elapsed());
+
+    let now = Instant::now();
+    let zkey = zkey();
+    let ark_proof = create_proof_with_reduction_and_matrices::<_, CircomReduction>(
+        &zkey.0,
+        r,
+        s,
+        &zkey.1,
+        zkey.1.num_instance_variables,
+        zkey.1.num_constraints,
+        full_assignment.as_slice(),
+    )?;
+    let proof = ark_proof.into();
+    println!("proof generation took: {:.2?}", now.elapsed());
+
+    Ok(proof)
+}
+
+/// Verifies a given semaphore proof
+///
+/// # Errors
+///
+/// Returns a [`ProofError`] if verifying fails. Verification failure does not
+/// necessarily mean the proof is incorrect.
+pub fn verify_proof(
+    root: Field,
+    nullifier_hash: Field,
+    signal_hash: Field,
+    external_nullifier_hash: Field,
+    proof: &Proof,
+) -> Result<bool, ProofError> {
+    let zkey = zkey();
+    let pvk = prepare_verifying_key(&zkey.0.vk);
+
+    let public_inputs = [root, nullifier_hash, signal_hash, external_nullifier_hash]
+        .iter()
+        .map(ark_bn254::Fr::try_from)
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let ark_proof = (*proof).into();
+    let result = ark_groth16::verify_proof(&pvk, &ark_proof, &public_inputs[..])?;
+    Ok(result)
+}

semaphore/tests/protocol.rs

@@ -0,0 +1,115 @@
+#[cfg(test)]
+mod tests {
+    use ark_bn254::Parameters;
+    use ark_ec::bn::Bn;
+    use ark_groth16::Proof as ArkProof;
+    use rand::{Rng, SeedableRng as _};
+    use rand_chacha::ChaChaRng;
+    use semaphore::{hash_to_field, identity::Identity, poseidon_tree::PoseidonTree, Field};
+    use semaphore_wrapper::protocol::{
+        generate_nullifier_hash, generate_proof, generate_proof_rng, verify_proof, Proof,
+    };
+    use serde_json::json;
+
+    #[test]
+    fn test_semaphore() {
+        // generate identity
+        let id = Identity::from_seed(b"secret");
+
+        // generate merkle tree
+        let leaf = Field::from(0);
+        let mut tree = PoseidonTree::new(21, leaf);
+        tree.set(0, id.commitment());
+
+        let merkle_proof = tree.proof(0).expect("proof should exist");
+        let root = tree.root().into();
+
+        // change signal and external_nullifier here
+        let signal_hash = hash_to_field(b"xxx");
+        let external_nullifier_hash = hash_to_field(b"appId");
+
+        let nullifier_hash = generate_nullifier_hash(&id, external_nullifier_hash);
+
+        let proof =
+            generate_proof(&id, &merkle_proof, external_nullifier_hash, signal_hash).unwrap();
+
+        let success = verify_proof(
+            root,
+            nullifier_hash,
+            signal_hash,
+            external_nullifier_hash,
+            &proof,
+        )
+        .unwrap();
+
+        assert!(success);
+    }
+
+    fn arb_proof(seed: u64) -> Proof {
+        // Deterministic randomness for testing
+        let mut rng = ChaChaRng::seed_from_u64(seed);
+
+        // generate identity
+        let seed: [u8; 16] = rng.gen();
+        let id = Identity::from_seed(&seed);
+
+        // generate merkle tree
+        let leaf = Field::from(0);
+        let mut tree = PoseidonTree::new(21, leaf);
+        tree.set(0, id.commitment());
+
+        let merkle_proof = tree.proof(0).expect("proof should exist");
+
+        let external_nullifier: [u8; 16] = rng.gen();
+        let external_nullifier_hash = hash_to_field(&external_nullifier);
+
+        let signal: [u8; 16] = rng.gen();
+        let signal_hash = hash_to_field(&signal);
+
+        generate_proof_rng(
+            &id,
+            &merkle_proof,
+            external_nullifier_hash,
+            signal_hash,
+            &mut rng,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn test_proof_cast_roundtrip() {
+        let proof = arb_proof(123);
+        let ark_proof: ArkProof<Bn<Parameters>> = proof.into();
+        let result: Proof = ark_proof.into();
+        assert_eq!(proof, result);
+    }
+
+    #[test]
+    fn test_proof_serialize() {
+        let proof = arb_proof(456);
+        let json = serde_json::to_value(&proof).unwrap();
+        assert_eq!(
+            json,
+            json!([
+                [
+                    "0x249ae469686987ee9368da60dd177a8c42891c02f5760e955e590c79d55cfab2",
+                    "0xf22e25870f49388459d388afb24dcf6ec11bb2d4def1e2ec26d6e42f373aad8"
+                ],
+                [
+                    [
+                        "0x17bd25dbd7436c30ea5b8a3a47aadf11ed646c4b25cc14a84ff8cbe0252ff1f8",
+                        "0x1c140668c56688367416534d57b4a14e5a825efdd5e121a6a2099f6dc4cd277b"
+                    ],
+                    [
+                        "0x26a8524759d969ea0682a092cf7a551697d81962d6c998f543f81e52d83e05e1",
+                        "0x273eb3f796fd1807b9df9c6d769d983e3dabdc61677b75d48bb7691303b2c8dd"
+                    ]
+                ],
+                [
+                    "0x62715c53a0eb4c46dbb5f73f1fd7449b9c63d37c1ece65debc39b472065a90f",
+                    "0x114f7becc66f1cd7a8b01c89db8233622372fc0b6fc037c4313bca41e2377fd9"
+                ]
+            ])
+        );
+    }
+}

utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zerokit_utils"
-version = "0.5.0"
+version = "0.4.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Various utilities for Zerokit"
@@ -15,11 +15,9 @@ bench = false
 ark-ff = { version = "=0.4.1", default-features = false, features = ["asm"] }
 num-bigint = { version = "=0.4.3", default-features = false, features = ["rand"] }
 color-eyre = "=0.6.2"
-pmtree = { package = "vacp2p_pmtree", version = "=2.0.2", optional = true}
+pmtree = { package = "pmtree", version = "=2.0.0", optional = true}
 sled = "=0.34.7"
 serde = "=1.0.163"
-lazy_static = "1.4.0"
-hex = "0.4"
 
 [dev-dependencies]
 ark-bn254 = "=0.4.0"

utils/benches/merkle_tree_benchmark.rs

@@ -1,7 +1,5 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use hex_literal::hex;
-use lazy_static::lazy_static;
-use std::{fmt::Display, str::FromStr};
 use tiny_keccak::{Hasher as _, Keccak};
 use zerokit_utils::{
     FullMerkleConfig, FullMerkleTree, Hasher, OptimalMerkleConfig, OptimalMerkleTree,
@@ -11,59 +9,38 @@ use zerokit_utils::{
 #[derive(Clone, Copy, Eq, PartialEq)]
 struct Keccak256;
 
-#[derive(Clone, Copy, Eq, PartialEq, Debug, Default)]
-struct TestFr([u8; 32]);
-
 impl Hasher for Keccak256 {
-    type Fr = TestFr;
+    type Fr = [u8; 32];
 
     fn default_leaf() -> Self::Fr {
-        TestFr([0; 32])
+        [0; 32]
     }
 
     fn hash(inputs: &[Self::Fr]) -> Self::Fr {
         let mut output = [0; 32];
         let mut hasher = Keccak::v256();
         for element in inputs {
-            hasher.update(element.0.as_slice());
+            hasher.update(element);
         }
         hasher.finalize(&mut output);
-        TestFr(output)
+        output
     }
 }
 
-impl Display for TestFr {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", String::from_utf8_lossy(self.0.as_slice()))
-    }
-}
-
-impl FromStr for TestFr {
-    type Err = std::string::FromUtf8Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(TestFr(s.as_bytes().try_into().unwrap()))
-    }
-}
-
-lazy_static! {
-    static ref LEAVES: [TestFr; 4] = [
-        hex!("0000000000000000000000000000000000000000000000000000000000000001"),
-        hex!("0000000000000000000000000000000000000000000000000000000000000002"),
-        hex!("0000000000000000000000000000000000000000000000000000000000000003"),
-        hex!("0000000000000000000000000000000000000000000000000000000000000004"),
-    ]
-    .map(TestFr);
-}
-
 pub fn optimal_merkle_tree_benchmark(c: &mut Criterion) {
     let mut tree =
-        OptimalMerkleTree::<Keccak256>::new(2, TestFr([0; 32]), OptimalMerkleConfig::default())
-            .unwrap();
+        OptimalMerkleTree::<Keccak256>::new(2, [0; 32], OptimalMerkleConfig::default()).unwrap();
+
+    let leaves = [
+        hex!("0000000000000000000000000000000000000000000000000000000000000001"),
+        hex!("0000000000000000000000000000000000000000000000000000000000000002"),
+        hex!("0000000000000000000000000000000000000000000000000000000000000003"),
+        hex!("0000000000000000000000000000000000000000000000000000000000000004"),
+    ];
 
     c.bench_function("OptimalMerkleTree::set", |b| {
         b.iter(|| {
-            tree.set(0, LEAVES[0]).unwrap();
+            tree.set(0, leaves[0]).unwrap();
         })
     });
 
@@ -75,7 +52,7 @@ pub fn optimal_merkle_tree_benchmark(c: &mut Criterion) {
 
     c.bench_function("OptimalMerkleTree::override_range", |b| {
         b.iter(|| {
-            tree.override_range(0, *LEAVES, [0, 1, 2, 3]).unwrap();
+            tree.override_range(0, leaves, [0, 1, 2, 3]).unwrap();
         })
     });
 
@@ -90,28 +67,22 @@ pub fn optimal_merkle_tree_benchmark(c: &mut Criterion) {
             tree.get(0).unwrap();
         })
     });
-
-    // check intermediate node getter which required additional computation of sub root index
-    c.bench_function("OptimalMerkleTree::get_subtree_root", |b| {
-        b.iter(|| {
-            tree.get_subtree_root(1, 0).unwrap();
-        })
-    });
-
-    c.bench_function("OptimalMerkleTree::get_empty_leaves_indices", |b| {
-        b.iter(|| {
-            tree.get_empty_leaves_indices();
-        })
-    });
 }
 
 pub fn full_merkle_tree_benchmark(c: &mut Criterion) {
     let mut tree =
-        FullMerkleTree::<Keccak256>::new(2, TestFr([0; 32]), FullMerkleConfig::default()).unwrap();
+        FullMerkleTree::<Keccak256>::new(2, [0; 32], FullMerkleConfig::default()).unwrap();
+
+    let leaves = [
+        hex!("0000000000000000000000000000000000000000000000000000000000000001"),
+        hex!("0000000000000000000000000000000000000000000000000000000000000002"),
+        hex!("0000000000000000000000000000000000000000000000000000000000000003"),
+        hex!("0000000000000000000000000000000000000000000000000000000000000004"),
+    ];
 
     c.bench_function("FullMerkleTree::set", |b| {
         b.iter(|| {
-            tree.set(0, LEAVES[0]).unwrap();
+            tree.set(0, leaves[0]).unwrap();
         })
     });
 
@@ -123,7 +94,7 @@ pub fn full_merkle_tree_benchmark(c: &mut Criterion) {
 
     c.bench_function("FullMerkleTree::override_range", |b| {
         b.iter(|| {
-            tree.override_range(0, *LEAVES, [0, 1, 2, 3]).unwrap();
+            tree.override_range(0, leaves, [0, 1, 2, 3]).unwrap();
         })
     });
 
@@ -138,19 +109,6 @@ pub fn full_merkle_tree_benchmark(c: &mut Criterion) {
             tree.get(0).unwrap();
         })
     });
-
-    // check intermediate node getter which required additional computation of sub root index
-    c.bench_function("FullMerkleTree::get_subtree_root", |b| {
-        b.iter(|| {
-            tree.get_subtree_root(1, 0).unwrap();
-        })
-    });
-
-    c.bench_function("FullMerkleTree::get_empty_leaves_indices", |b| {
-        b.iter(|| {
-            tree.get_empty_leaves_indices();
-        })
-    });
 }
 
 criterion_group!(

utils/src/merkle_tree/full_merkle_tree.rs

@@ -26,10 +26,6 @@ pub struct FullMerkleTree<H: Hasher> {
     /// The tree nodes
     nodes: Vec<H::Fr>,
 
-    /// The indices of leaves which are set into zero upto next_index.
-    /// Set to 0 if the leaf is empty and set to 1 in otherwise.
-    cached_leaves_indices: Vec<u8>,
-
     // The next available (i.e., never used) tree index. Equivalently, the number of leaves added to the tree
     // (deletions leave next_index unchanged)
     next_index: usize,
@@ -100,7 +96,6 @@ where
             depth,
             cached_nodes,
             nodes,
-            cached_leaves_indices: vec![0; 1 << depth],
             next_index,
             metadata: Vec::new(),
         })
@@ -121,7 +116,7 @@ where
     }
 
     // Returns the total number of leaves set
-    fn leaves_set(&self) -> usize {
+    fn leaves_set(&mut self) -> usize {
         self.next_index
     }
 
@@ -146,42 +141,6 @@ where
         Ok(self.nodes[self.capacity() + leaf - 1])
     }
 
-    fn get_subtree_root(&self, n: usize, index: usize) -> Result<H::Fr> {
-        if n > self.depth() {
-            return Err(Report::msg("level exceeds depth size"));
-        }
-        if index >= self.capacity() {
-            return Err(Report::msg("index exceeds set size"));
-        }
-        if n == 0 {
-            Ok(self.root())
-        } else if n == self.depth {
-            self.get(index)
-        } else {
-            let mut idx = self.capacity() + index - 1;
-            let mut nd = self.depth;
-            loop {
-                let parent = self.parent(idx).unwrap();
-                nd -= 1;
-                if nd == n {
-                    return Ok(self.nodes[parent]);
-                } else {
-                    idx = parent;
-                    continue;
-                }
-            }
-        }
-    }
-    fn get_empty_leaves_indices(&self) -> Vec<usize> {
-        self.cached_leaves_indices
-            .iter()
-            .take(self.next_index)
-            .enumerate()
-            .filter(|&(_, &v)| v == 0u8)
-            .map(|(idx, _)| idx)
-            .collect()
-    }
-
     // Sets tree nodes, starting from start index
     // Function proper of FullMerkleTree implementation
     fn set_range<I: IntoIterator<Item = FrOf<Self::Hasher>>>(
@@ -199,7 +158,6 @@ where
         }
         hashes.into_iter().for_each(|hash| {
             self.nodes[index + count] = hash;
-            self.cached_leaves_indices[start + count] = 1;
             count += 1;
         });
         if count != 0 {
@@ -209,36 +167,37 @@ where
         Ok(())
     }
 
-    fn override_range<I, J>(&mut self, start: usize, leaves: I, indices: J) -> Result<()>
+    fn override_range<I, J>(&mut self, start: usize, leaves: I, to_remove_indices: J) -> Result<()>
     where
         I: IntoIterator<Item = FrOf<Self::Hasher>>,
         J: IntoIterator<Item = usize>,
     {
-        let indices = indices.into_iter().collect::<Vec<_>>();
-        let min_index = *indices.first().unwrap();
-        let leaves_vec = leaves.into_iter().collect::<Vec<_>>();
-
-        let max_index = start + leaves_vec.len();
-
-        let mut set_values = vec![Self::Hasher::default_leaf(); max_index - min_index];
-
-        for i in min_index..start {
-            if !indices.contains(&i) {
-                let value = self.get(i)?;
-                set_values[i - min_index] = value;
-            }
+        let index = self.capacity() + start - 1;
+        let mut count = 0;
+        let leaves = leaves.into_iter().collect::<Vec<_>>();
+        let to_remove_indices = to_remove_indices.into_iter().collect::<Vec<_>>();
+        // first count number of hashes, and check that they fit in the tree
+        // then insert into the tree
+        if leaves.len() + start - to_remove_indices.len() > self.capacity() {
+            return Err(Report::msg("provided hashes do not fit in the tree"));
         }
 
-        for i in 0..leaves_vec.len() {
-            set_values[start - min_index + i] = leaves_vec[i];
+        // remove leaves
+        for i in &to_remove_indices {
+            self.delete(*i)?;
         }
 
-        for i in indices {
-            self.cached_leaves_indices[i] = 0;
+        // insert new leaves
+        for hash in leaves {
+            self.nodes[index + count] = hash;
+            count += 1;
         }
 
-        self.set_range(start, set_values)
-            .map_err(|e| Report::msg(e.to_string()))
+        if count != 0 {
+            self.update_nodes(index, index + (count - 1))?;
+            self.next_index = max(self.next_index, start + count - to_remove_indices.len());
+        }
+        Ok(())
     }
 
     // Sets a leaf at the next available index
@@ -252,7 +211,6 @@ where
         // We reset the leaf only if we previously set a leaf at that index
         if index < self.next_index {
             self.set(index, H::default_leaf())?;
-            self.cached_leaves_indices[index] = 0;
         }
         Ok(())
     }

utils/src/merkle_tree/merkle_tree.rs

@@ -13,6 +13,7 @@
 //! * Disk based storage backend (using mmaped files should be easy)
 //! * Implement serialization for tree and Merkle proof
 
+use std::fmt::Debug;
 use std::str::FromStr;
 
 use color_eyre::Result;
@@ -21,7 +22,7 @@ use color_eyre::Result;
 /// and the hash function used to initialize a Merkle Tree implementation
 pub trait Hasher {
     /// Type of the leaf and tree node
-    type Fr: Clone + Copy + Eq + Default + std::fmt::Debug + std::fmt::Display + FromStr;
+    type Fr: Clone + Copy + Eq + Debug + ToString;
 
     /// Returns the default tree leaf
     fn default_leaf() -> Self::Fr;
@@ -47,16 +48,14 @@ pub trait ZerokitMerkleTree {
         Self: Sized;
     fn depth(&self) -> usize;
     fn capacity(&self) -> usize;
-    fn leaves_set(&self) -> usize;
+    fn leaves_set(&mut self) -> usize;
     fn root(&self) -> FrOf<Self::Hasher>;
     fn compute_root(&mut self) -> Result<FrOf<Self::Hasher>>;
-    fn get_subtree_root(&self, n: usize, index: usize) -> Result<FrOf<Self::Hasher>>;
     fn set(&mut self, index: usize, leaf: FrOf<Self::Hasher>) -> Result<()>;
     fn set_range<I>(&mut self, start: usize, leaves: I) -> Result<()>
     where
         I: IntoIterator<Item = FrOf<Self::Hasher>>;
     fn get(&self, index: usize) -> Result<FrOf<Self::Hasher>>;
-    fn get_empty_leaves_indices(&self) -> Vec<usize>;
     fn override_range<I, J>(&mut self, start: usize, leaves: I, to_remove_indices: J) -> Result<()>
     where
         I: IntoIterator<Item = FrOf<Self::Hasher>>,

utils/src/merkle_tree/optimal_merkle_tree.rs

@@ -27,10 +27,6 @@ where
     /// The tree nodes
     nodes: HashMap<(usize, usize), H::Fr>,
 
-    /// The indices of leaves which are set into zero upto next_index.
-    /// Set to 0 if the leaf is empty and set to 1 in otherwise.
-    cached_leaves_indices: Vec<u8>,
-
     // The next available (i.e., never used) tree index. Equivalently, the number of leaves added to the tree
     // (deletions leave next_index unchanged)
     next_index: usize,
@@ -82,7 +78,6 @@ where
             cached_nodes: cached_nodes.clone(),
             depth,
             nodes: HashMap::new(),
-            cached_leaves_indices: vec![0; 1 << depth],
             next_index: 0,
             metadata: Vec::new(),
         })
@@ -103,7 +98,7 @@ where
     }
 
     // Returns the total number of leaves set
-    fn leaves_set(&self) -> usize {
+    fn leaves_set(&mut self) -> usize {
         self.next_index
     }
 
@@ -113,31 +108,16 @@ where
         self.get_node(0, 0)
     }
 
-    fn get_subtree_root(&self, n: usize, index: usize) -> Result<H::Fr> {
-        if n > self.depth() {
-            return Err(Report::msg("level exceeds depth size"));
-        }
-        if index >= self.capacity() {
-            return Err(Report::msg("index exceeds set size"));
-        }
-        if n == 0 {
-            Ok(self.root())
-        } else if n == self.depth {
-            self.get(index)
-        } else {
-            Ok(self.get_node(n, index >> (self.depth - n)))
-        }
-    }
-
     // Sets a leaf at the specified tree index
     fn set(&mut self, index: usize, leaf: H::Fr) -> Result<()> {
         if index >= self.capacity() {
             return Err(Report::msg("index exceeds set size"));
         }
+        let log = format!("inserting {} at {}[{index}]", leaf.to_string(), self.depth);
+        dbg!(log);
         self.nodes.insert((self.depth, index), leaf);
         self.recalculate_from(index)?;
         self.next_index = max(self.next_index, index + 1);
-        self.cached_leaves_indices[index] = 1;
         Ok(())
     }
 
@@ -149,16 +129,6 @@ where
         Ok(self.get_node(self.depth, index))
     }
 
-    fn get_empty_leaves_indices(&self) -> Vec<usize> {
-        self.cached_leaves_indices
-            .iter()
-            .take(self.next_index)
-            .enumerate()
-            .filter(|&(_, &v)| v == 0u8)
-            .map(|(idx, _)| idx)
-            .collect()
-    }
-
     // Sets multiple leaves from the specified tree index
     fn set_range<I: IntoIterator<Item = H::Fr>>(&mut self, start: usize, leaves: I) -> Result<()> {
         let leaves = leaves.into_iter().collect::<Vec<_>>();
@@ -168,43 +138,40 @@ where
         }
         for (i, leaf) in leaves.iter().enumerate() {
             self.nodes.insert((self.depth, start + i), *leaf);
-            self.cached_leaves_indices[start + i] = 1;
             self.recalculate_from(start + i)?;
         }
         self.next_index = max(self.next_index, start + leaves.len());
         Ok(())
     }
 
-    fn override_range<I, J>(&mut self, start: usize, leaves: I, indices: J) -> Result<()>
+    fn override_range<I, J>(&mut self, start: usize, leaves: I, to_remove_indices: J) -> Result<()>
     where
         I: IntoIterator<Item = FrOf<Self::Hasher>>,
         J: IntoIterator<Item = usize>,
     {
-        let indices = indices.into_iter().collect::<Vec<_>>();
-        let min_index = *indices.first().unwrap();
-        let leaves_vec = leaves.into_iter().collect::<Vec<_>>();
-
-        let max_index = start + leaves_vec.len();
-
-        let mut set_values = vec![Self::Hasher::default_leaf(); max_index - min_index];
-
-        for i in min_index..start {
-            if !indices.contains(&i) {
-                let value = self.get_leaf(i);
-                set_values[i - min_index] = value;
-            }
+        let leaves = leaves.into_iter().collect::<Vec<_>>();
+        let to_remove_indices = to_remove_indices.into_iter().collect::<Vec<_>>();
+        // check if the range is valid
+        if leaves.len() + start - to_remove_indices.len() > self.capacity() {
+            return Err(Report::msg("provided range exceeds set size"));
         }
 
-        for i in 0..leaves_vec.len() {
-            set_values[start - min_index + i] = leaves_vec[i];
+        // remove leaves
+        for i in &to_remove_indices {
+            self.delete(*i)?;
         }
 
-        for i in indices {
-            self.cached_leaves_indices[i] = 0;
+        // add leaves
+        for (i, leaf) in leaves.iter().enumerate() {
+            self.nodes.insert((self.depth, start + i), *leaf);
+            self.recalculate_from(start + i)?;
         }
 
-        self.set_range(start, set_values)
-            .map_err(|e| Report::msg(e.to_string()))
+        self.next_index = max(
+            self.next_index,
+            start + leaves.len() - to_remove_indices.len(),
+        );
+        Ok(())
     }
 
     // Sets a leaf at the next available index
@@ -218,7 +185,6 @@ where
         // We reset the leaf only if we previously set a leaf at that index
         if index < self.next_index {
             self.set(index, H::default_leaf())?;
-            self.cached_leaves_indices[index] = 0;
         }
         Ok(())
     }
@@ -228,6 +194,7 @@ where
         if index >= self.capacity() {
             return Err(Report::msg("index exceeds set size"));
         }
+        dbg!("yomama");
         let mut witness = Vec::<(H::Fr, u8)>::with_capacity(self.depth);
         let mut i = index;
         let mut depth = self.depth;
@@ -282,6 +249,13 @@ where
             .nodes
             .get(&(depth, index))
             .unwrap_or_else(|| &self.cached_nodes[depth]);
+        let log = format!(
+            "depth: {}, index: {}, node at depth[index]: {}",
+            depth,
+            index,
+            &node.to_string()
+        );
+        dbg!(log);
         node
     }
 
@@ -291,10 +265,14 @@ where
 
     fn hash_couple(&mut self, depth: usize, index: usize) -> H::Fr {
         let b = index & !1;
-        H::hash(&[self.get_node(depth, b), self.get_node(depth, b + 1)])
+        let l = self.get_node(depth, b);
+        let r = self.get_node(depth, b + 1);
+        dbg!(l.to_string(), r.to_string());
+        H::hash(&[l, r])
     }
 
     fn recalculate_from(&mut self, index: usize) -> Result<()> {
+        dbg!("running recalc from");
         let mut i = index;
         let mut depth = self.depth;
         loop {
@@ -302,7 +280,8 @@ where
             i >>= 1;
             depth -= 1;
             self.nodes.insert((depth, i), h);
-            self.cached_leaves_indices[index] = 1;
+            let log = format!("inserting {} at {depth}[{i}]", h.to_string());
+            dbg!(log);
             if depth == 0 {
                 break;
             }

utils/tests/merkle_tree.rs

@@ -1,8 +1,7 @@
 // Tests adapted from https://github.com/worldcoin/semaphore-rs/blob/d462a4372f1fd9c27610f2acfe4841fab1d396aa/src/merkle_tree.rs
 #[cfg(test)]
-pub mod test {
+mod test {
     use hex_literal::hex;
-    use std::{fmt::Display, str::FromStr};
     use tiny_keccak::{Hasher as _, Keccak};
     use zerokit_utils::{
         FullMerkleConfig, FullMerkleTree, Hasher, OptimalMerkleConfig, OptimalMerkleTree,
@@ -11,257 +10,74 @@ pub mod test {
     #[derive(Clone, Copy, Eq, PartialEq)]
     struct Keccak256;
 
-    #[derive(Clone, Copy, Eq, PartialEq, Debug, Default)]
-    struct TestFr([u8; 32]);
-
     impl Hasher for Keccak256 {
-        type Fr = TestFr;
+        type Fr = [u8; 32];
 
         fn default_leaf() -> Self::Fr {
-            TestFr([0; 32])
+            [0; 32]
         }
 
         fn hash(inputs: &[Self::Fr]) -> Self::Fr {
             let mut output = [0; 32];
             let mut hasher = Keccak::v256();
             for element in inputs {
-                hasher.update(element.0.as_slice());
+                hasher.update(element);
             }
             hasher.finalize(&mut output);
-            TestFr(output)
+            output
         }
     }
 
-    impl Display for TestFr {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(f, "{}", hex::encode(self.0.as_slice()))
-        }
-    }
-
-    impl FromStr for TestFr {
-        type Err = std::string::FromUtf8Error;
-
-        fn from_str(s: &str) -> Result<Self, Self::Err> {
-            Ok(TestFr(s.as_bytes().try_into().unwrap()))
-        }
-    }
-
-    impl From<u32> for TestFr {
-        fn from(value: u32) -> Self {
-            let mut bytes: Vec<u8> = vec![0; 28];
-            bytes.extend_from_slice(&value.to_be_bytes());
-            TestFr(bytes.as_slice().try_into().unwrap())
-        }
-    }
-
-    const DEFAULT_DEPTH: usize = 2;
-
-    fn default_full_merkle_tree(depth: usize) -> FullMerkleTree<Keccak256> {
-        FullMerkleTree::<Keccak256>::new(depth, TestFr([0; 32]), FullMerkleConfig::default())
-            .unwrap()
-    }
-
-    fn default_optimal_merkle_tree(depth: usize) -> OptimalMerkleTree<Keccak256> {
-        OptimalMerkleTree::<Keccak256>::new(depth, TestFr([0; 32]), OptimalMerkleConfig::default())
-            .unwrap()
-    }
-
     #[test]
     fn test_root() {
-        let default_tree_root = TestFr(hex!(
-            "b4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30"
-        ));
+        let leaves = [
+            hex!("0000000000000000000000000000000000000000000000000000000000000001"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000002"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000003"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000004"),
+        ];
+
+        let default_tree_root =
+            hex!("b4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30");
 
         let roots = [
             hex!("c1ba1812ff680ce84c1d5b4f1087eeb08147a4d510f3496b2849df3a73f5af95"),
             hex!("893760ec5b5bee236f29e85aef64f17139c3c1b7ff24ce64eb6315fca0f2485b"),
             hex!("222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c"),
             hex!("a9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36"),
-        ]
-        .map(TestFr);
+        ];
 
-        let nof_leaves = 4;
-        let leaves: Vec<TestFr> = (1..=nof_leaves as u32).map(TestFr::from).collect();
-
-        let mut tree = default_full_merkle_tree(DEFAULT_DEPTH);
+        let mut tree =
+            FullMerkleTree::<Keccak256>::new(2, [0; 32], FullMerkleConfig::default()).unwrap();
         assert_eq!(tree.root(), default_tree_root);
-        for i in 0..nof_leaves {
+        for i in 0..leaves.len() {
             tree.set(i, leaves[i]).unwrap();
             assert_eq!(tree.root(), roots[i]);
         }
 
-        let mut tree = default_optimal_merkle_tree(DEFAULT_DEPTH);
+        let mut tree =
+            OptimalMerkleTree::<Keccak256>::new(2, [0; 32], OptimalMerkleConfig::default())
+                .unwrap();
         assert_eq!(tree.root(), default_tree_root);
-        for i in 0..nof_leaves {
+        for i in 0..leaves.len() {
             tree.set(i, leaves[i]).unwrap();
             assert_eq!(tree.root(), roots[i]);
         }
     }
 
-    #[test]
-    fn test_get_empty_leaves_indices() {
-        let depth = 4;
-        let nof_leaves: usize = 1 << (depth - 1);
-        let leaves: Vec<TestFr> = (0..nof_leaves as u32).map(TestFr::from).collect();
-        let leaves_2: Vec<TestFr> = (0u32..2).map(TestFr::from).collect();
-        let leaves_4: Vec<TestFr> = (0u32..4).map(TestFr::from).collect();
-
-        let mut tree_full = default_full_merkle_tree(depth);
-        let _ = tree_full.set_range(0, leaves.clone());
-        assert!(tree_full.get_empty_leaves_indices().is_empty());
-
-        let mut vec_idxs = Vec::new();
-        for i in 0..nof_leaves {
-            vec_idxs.push(i);
-            let _ = tree_full.delete(i);
-            assert_eq!(tree_full.get_empty_leaves_indices(), vec_idxs);
-        }
-
-        for i in (0..nof_leaves).rev() {
-            vec_idxs.pop();
-            let _ = tree_full.set(i, leaves[i]);
-            assert_eq!(tree_full.get_empty_leaves_indices(), vec_idxs);
-        }
-
-        // Check situation when the number of items to insert is less than the number of items to delete
-        tree_full
-            .override_range(0, leaves_2.clone(), [0, 1, 2, 3])
-            .unwrap();
-
-        // check if the indexes for write and delete are the same
-        tree_full
-            .override_range(0, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        assert_eq!(tree_full.get_empty_leaves_indices(), vec![]);
-
-        // check if indexes for deletion are before indexes for overwriting
-        tree_full
-            .override_range(4, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        assert_eq!(tree_full.get_empty_leaves_indices(), vec![0, 1, 2, 3]);
-
-        // check if the indices for write and delete do not overlap completely
-        tree_full
-            .override_range(2, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        assert_eq!(tree_full.get_empty_leaves_indices(), vec![0, 1]);
-
-        //// Optimal Merkle Tree Trest
-
-        let mut tree_opt = default_optimal_merkle_tree(depth);
-        let _ = tree_opt.set_range(0, leaves.clone());
-        assert!(tree_opt.get_empty_leaves_indices().is_empty());
-
-        let mut vec_idxs = Vec::new();
-        for i in 0..nof_leaves {
-            vec_idxs.push(i);
-            let _ = tree_opt.delete(i);
-            assert_eq!(tree_opt.get_empty_leaves_indices(), vec_idxs);
-        }
-        for i in (0..nof_leaves).rev() {
-            vec_idxs.pop();
-            let _ = tree_opt.set(i, leaves[i]);
-            assert_eq!(tree_opt.get_empty_leaves_indices(), vec_idxs);
-        }
-
-        // Check situation when the number of items to insert is less than the number of items to delete
-        tree_opt
-            .override_range(0, leaves_2.clone(), [0, 1, 2, 3])
-            .unwrap();
-
-        // check if the indexes for write and delete are the same
-        tree_opt
-            .override_range(0, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        assert_eq!(tree_opt.get_empty_leaves_indices(), vec![]);
-
-        // check if indexes for deletion are before indexes for overwriting
-        tree_opt
-            .override_range(4, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        assert_eq!(tree_opt.get_empty_leaves_indices(), vec![0, 1, 2, 3]);
-
-        // check if the indices for write and delete do not overlap completely
-        tree_opt
-            .override_range(2, leaves_4.clone(), [0, 1, 2, 3])
-            .unwrap();
-        assert_eq!(tree_opt.get_empty_leaves_indices(), vec![0, 1]);
-    }
-
-    #[test]
-    fn test_subtree_root() {
-        let depth = 3;
-        let nof_leaves: usize = 6;
-        let leaves: Vec<TestFr> = (0..nof_leaves as u32).map(TestFr::from).collect();
-
-        let mut tree_full = default_optimal_merkle_tree(depth);
-        let _ = tree_full.set_range(0, leaves.iter().cloned());
-
-        for i in 0..nof_leaves {
-            // check leaves
-            assert_eq!(
-                tree_full.get(i).unwrap(),
-                tree_full.get_subtree_root(depth, i).unwrap()
-            );
-
-            // check root
-            assert_eq!(tree_full.root(), tree_full.get_subtree_root(0, i).unwrap());
-        }
-
-        // check intermediate nodes
-        for n in (1..=depth).rev() {
-            for i in (0..(1 << n)).step_by(2) {
-                let idx_l = i * (1 << (depth - n));
-                let idx_r = (i + 1) * (1 << (depth - n));
-                let idx_sr = idx_l;
-
-                let prev_l = tree_full.get_subtree_root(n, idx_l).unwrap();
-                let prev_r = tree_full.get_subtree_root(n, idx_r).unwrap();
-                let subroot = tree_full.get_subtree_root(n - 1, idx_sr).unwrap();
-
-                // check intermediate nodes
-                assert_eq!(Keccak256::hash(&[prev_l, prev_r]), subroot);
-            }
-        }
-
-        let mut tree_opt = default_full_merkle_tree(depth);
-        let _ = tree_opt.set_range(0, leaves.iter().cloned());
-
-        for i in 0..nof_leaves {
-            // check leaves
-            assert_eq!(
-                tree_opt.get(i).unwrap(),
-                tree_opt.get_subtree_root(depth, i).unwrap()
-            );
-            // check root
-            assert_eq!(tree_opt.root(), tree_opt.get_subtree_root(0, i).unwrap());
-        }
-
-        // check intermediate nodes
-        for n in (1..=depth).rev() {
-            for i in (0..(1 << n)).step_by(2) {
-                let idx_l = i * (1 << (depth - n));
-                let idx_r = (i + 1) * (1 << (depth - n));
-                let idx_sr = idx_l;
-
-                let prev_l = tree_opt.get_subtree_root(n, idx_l).unwrap();
-                let prev_r = tree_opt.get_subtree_root(n, idx_r).unwrap();
-                let subroot = tree_opt.get_subtree_root(n - 1, idx_sr).unwrap();
-
-                // check intermediate nodes
-                assert_eq!(Keccak256::hash(&[prev_l, prev_r]), subroot);
-            }
-        }
-    }
-
     #[test]
     fn test_proof() {
-        let nof_leaves = 4;
-        let leaves: Vec<TestFr> = (0..nof_leaves as u32).map(TestFr::from).collect();
+        let leaves = [
+            hex!("0000000000000000000000000000000000000000000000000000000000000001"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000002"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000003"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000004"),
+        ];
 
         // We thest the FullMerkleTree implementation
-        let mut tree = default_full_merkle_tree(DEFAULT_DEPTH);
-        for i in 0..nof_leaves {
+        let mut tree =
+            FullMerkleTree::<Keccak256>::new(2, [0; 32], FullMerkleConfig::default()).unwrap();
+        for i in 0..leaves.len() {
             // We set the leaves
             tree.set(i, leaves[i]).unwrap();
 
@@ -278,12 +94,16 @@ pub mod test {
             assert_eq!(proof.compute_root_from(&leaves[i]), tree.root());
 
             // We check that the proof is not valid for another leaf
-            assert!(!tree.verify(&leaves[(i + 1) % nof_leaves], &proof).unwrap());
+            assert!(!tree
+                .verify(&leaves[(i + 1) % leaves.len()], &proof)
+                .unwrap());
         }
 
         // We test the OptimalMerkleTree implementation
-        let mut tree = default_optimal_merkle_tree(DEFAULT_DEPTH);
-        for i in 0..nof_leaves {
+        let mut tree =
+            OptimalMerkleTree::<Keccak256>::new(2, [0; 32], OptimalMerkleConfig::default())
+                .unwrap();
+        for i in 0..leaves.len() {
             // We set the leaves
             tree.set(i, leaves[i]).unwrap();
 
@@ -300,25 +120,32 @@ pub mod test {
             assert_eq!(proof.compute_root_from(&leaves[i]), tree.root());
 
             // We check that the proof is not valid for another leaf
-            assert!(!tree.verify(&leaves[(i + 1) % nof_leaves], &proof).unwrap());
+            assert!(!tree
+                .verify(&leaves[(i + 1) % leaves.len()], &proof)
+                .unwrap());
         }
     }
 
     #[test]
     fn test_override_range() {
-        let nof_leaves = 4;
-        let leaves: Vec<TestFr> = (0..nof_leaves as u32).map(TestFr::from).collect();
+        let initial_leaves = [
+            hex!("0000000000000000000000000000000000000000000000000000000000000001"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000002"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000003"),
+            hex!("0000000000000000000000000000000000000000000000000000000000000004"),
+        ];
 
-        let mut tree = default_optimal_merkle_tree(DEFAULT_DEPTH);
+        let mut tree =
+            OptimalMerkleTree::<Keccak256>::new(2, [0; 32], OptimalMerkleConfig::default())
+                .unwrap();
 
         // We set the leaves
-        tree.set_range(0, leaves.iter().cloned()).unwrap();
+        tree.set_range(0, initial_leaves.iter().cloned()).unwrap();
 
         let new_leaves = [
             hex!("0000000000000000000000000000000000000000000000000000000000000005"),
             hex!("0000000000000000000000000000000000000000000000000000000000000006"),
-        ]
-        .map(TestFr);
+        ];
 
         let to_delete_indices: [usize; 2] = [0, 1];
 
@@ -331,8 +158,8 @@ pub mod test {
         .unwrap();
 
         // ensure that the leaves are set correctly
-        for (i, &new_leaf) in new_leaves.iter().enumerate() {
-            assert_eq!(tree.get_leaf(i), new_leaf);
+        for i in 0..new_leaves.len() {
+            assert_eq!(tree.get_leaf(i), new_leaves[i]);
         }
     }
 }

utils/tests/poseidon_constants.rs

@@ -25,10 +25,16 @@ mod test {
         input_clean = input_clean.trim().to_string();
 
         if radix == 10 {
-            BigUint::from_str_radix(&input_clean, radix).unwrap().into()
+            BigUint::from_str_radix(&input_clean, radix)
+                .unwrap()
+                .try_into()
+                .unwrap()
         } else {
             input_clean = input_clean.replace("0x", "");
-            BigUint::from_str_radix(&input_clean, radix).unwrap().into()
+            BigUint::from_str_radix(&input_clean, radix)
+                .unwrap()
+                .try_into()
+                .unwrap()
         }
     }
     // The following constants were taken from https://github.com/arnaucube/poseidon-rs/blob/233027d6075a637c29ad84a8a44f5653b81f0410/src/constants.rs
@@ -3494,21 +3500,21 @@ mod test {
     fn load_constants() -> (Vec<Vec<Fr>>, Vec<Vec<Vec<Fr>>>) {
         let (c_str, m_str) = constants();
         let mut c: Vec<Vec<Fr>> = Vec::new();
-        for c_i in c_str {
-            let mut ci: Vec<Fr> = Vec::new();
-            for c_i_j in c_i {
-                let b: Fr = str_to_fr(c_i_j, 10);
-                ci.push(b);
+        for i in 0..c_str.len() {
+            let mut cci: Vec<Fr> = Vec::new();
+            for j in 0..c_str[i].len() {
+                let b: Fr = str_to_fr(c_str[i][j], 10);
+                cci.push(b);
             }
-            c.push(ci);
+            c.push(cci);
         }
         let mut m: Vec<Vec<Vec<Fr>>> = Vec::new();
-        for m_i in m_str {
+        for i in 0..m_str.len() {
             let mut mi: Vec<Vec<Fr>> = Vec::new();
-            for m_i_j in m_i {
+            for j in 0..m_str[i].len() {
                 let mut mij: Vec<Fr> = Vec::new();
-                for m_i_j_k in m_i_j {
-                    let b: Fr = str_to_fr(m_i_j_k, 10);
+                for k in 0..m_str[i][j].len() {
+                    let b: Fr = str_to_fr(m_str[i][j][k], 10);
                     mij.push(b);
                 }
                 mi.push(mij);
@@ -3536,7 +3542,7 @@ mod test {
                 assert_eq!(loaded_m[i], poseidon_parameters[i].m);
             }
         } else {
-            unreachable!();
+            assert!(false);
         }
     }
 }