add benchmark

* chore(rln): optimize into Lazy OnceCells

* fix

* fix: dont change duration

* fix: increase duration?

* chore: add backtrace

* fix: remove plotter to avoid f64 range failure

* fix: remove ci alteration

* fix: use arc over witness calc

* fix: remove more lifetimes

* fix: benchmark correct fn call, not the getter

* fix: bench config

Cargo.lock

@@ -1460,25 +1460,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "include_dir"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18762faeff7122e89e0857b02f7ce6fcc0d101d5e9ad2ad7846cc01d61b7f19e"
-dependencies = [
- "include_dir_macros",
-]
-
-[[package]]
-name = "include_dir_macros"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b139284b5cf57ecfa712bcc66950bb635b31aff41c188e8a4cfc758eca374a3f"
-dependencies = [
- "proc-macro2",
- "quote",
-]
-
 [[package]]
 name = "indenter"
 version = "0.3.3"
@@ -2289,7 +2270,7 @@ dependencies = [
 
 [[package]]
 name = "rln"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "ark-bn254",
  "ark-circom",
@@ -2303,7 +2284,7 @@ dependencies = [
  "cfg-if",
  "color-eyre",
  "criterion 0.4.0",
- "include_dir",
+ "lazy_static 1.4.0",
  "num-bigint",
  "num-traits",
  "once_cell",
@@ -3564,7 +3545,7 @@ dependencies = [
 
 [[package]]
 name = "zerokit_utils"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "ark-bn254",
  "ark-ff",

rln-cli/src/main.rs

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

rln-cli/src/state.rs

@@ -5,12 +5,12 @@ use std::fs::File;
 use crate::config::{Config, InnerConfig};
 
 #[derive(Default)]
-pub(crate) struct State<'a> {
-    pub rln: Option<RLN<'a>>,
+pub(crate) struct State {
+    pub rln: Option<RLN>,
 }
 
-impl<'a> State<'a> {
-    pub(crate) fn load_state() -> Result<State<'a>> {
+impl State {
+    pub(crate) fn load_state() -> Result<State> {
         let config = Config::load_config()?;
         let rln = if let Some(InnerConfig { file, tree_height }) = config.inner {
             let resources = File::open(&file)?;

rln-wasm/src/lib.rs

@@ -19,7 +19,7 @@ pub fn init_panic_hook() {
 pub struct RLNWrapper {
     // The purpose of this wrapper is to hold a RLN instance with the 'static lifetime
     // because wasm_bindgen does not allow returning elements with lifetimes
-    instance: RLN<'static>,
+    instance: RLN,
 }
 
 // Macro to call methods with arbitrary amount of arguments,
@@ -150,8 +150,8 @@ impl<T> ProcessArg for Vec<T> {
     }
 }
 
-impl<'a> ProcessArg for *const RLN<'a> {
-    type ReturnType = &'a RLN<'a>;
+impl ProcessArg for *const RLN {
+    type ReturnType = &'static RLN;
     fn process(self) -> Self::ReturnType {
         unsafe { &*self }
     }

rln-wasm/tests/rln-wasm.rs

@@ -25,7 +25,7 @@ mod tests {
         let circom_path = format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/rln.wasm");
         let zkey_path = format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/rln_final.zkey");
         let vk_path =
-            format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/verification_key.json");
+            format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/verification_key.arkvkey");
         let zkey = read_file(&zkey_path).unwrap();
         let vk = read_file(&vk_path).unwrap();
 
@@ -129,7 +129,7 @@ mod tests {
         let tree_height = TEST_TREE_HEIGHT;
         let zkey_path = format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/rln_final.zkey");
         let vk_path =
-            format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/verification_key.json");
+            format!("../rln/resources/tree_height_{TEST_TREE_HEIGHT}/verification_key.arkvkey");
         let zkey = read_file(&zkey_path).unwrap();
         let vk = read_file(&vk_path).unwrap();
 

rln/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rln"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "APIs to manage, compute and verify zkSNARK proofs and RLN primitives"
@@ -48,18 +48,17 @@ num-bigint = { version = "=0.4.3", default-features = false, features = [
 ] }
 num-traits = "=0.2.15"
 once_cell = "=1.17.1"
+lazy_static = "=1.4.0"
 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.5.1", path = "../utils/", default-features = false }
 
 
 # serialization
 serde_json = "=1.0.96"
 serde = { version = "=1.0.163", features = ["derive"] }
 
-include_dir = "=0.7.3"
-
 [dev-dependencies]
 sled = "=0.34.7"
 criterion = { version = "=0.4.0", features = ["html_reports"] }
@@ -88,6 +87,14 @@ harness = false
 name = "circuit_loading_benchmark"
 harness = false
 
+[[bench]]
+name = "circuit_deser_benchmark"
+harness = false
+
 [[bench]]
 name = "poseidon_tree_benchmark"
 harness = false
+
+[[bench]]
+name = "serialize_benchmark"
+harness = false

rln/README.md

@@ -74,7 +74,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`) or (`rln_final.arkzkey`) and verification key (`verification_key.arkvkey`, 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.
 

rln/benches/circuit_deser_benchmark.rs

@@ -0,0 +1,22 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use rln::circuit::{vk_from_ark_serialized, VK_BYTES};
+
+// Here we benchmark how long the deserialization of the
+// verifying_key takes, only testing the json => verifying_key conversion,
+// and skipping conversion from bytes => string => serde_json::Value
+pub fn vk_deserialize_benchmark(c: &mut Criterion) {
+    let vk = VK_BYTES;
+
+    c.bench_function("vk::vk_from_ark_serialized", |b| {
+        b.iter(|| {
+            let _ = vk_from_ark_serialized(vk);
+        })
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().measurement_time(std::time::Duration::from_secs(10));
+    targets = vk_deserialize_benchmark
+}
+criterion_main!(benches);

rln/benches/circuit_loading_benchmark.rs

@@ -1,14 +1,21 @@
 use criterion::{criterion_group, criterion_main, Criterion};
+use rln::circuit::{zkey_from_raw, ZKEY_BYTES};
 
 // 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| {
+    let zkey = ZKEY_BYTES.to_vec();
+
+    c.bench_function("zkey::zkey_from_raw", |b| {
         b.iter(|| {
-            let _ = rln::circuit::zkey_from_folder();
+            let _ = zkey_from_raw(&zkey);
         })
     });
 }
 
-criterion_group!(benches, key_load_benchmark);
+criterion_group! {
+    name = benches;
+    config = Criterion::default().measurement_time(std::time::Duration::from_secs(250));
+    targets = key_load_benchmark
+}
 criterion_main!(benches);

rln/benches/serialize_benchmark.rs

@@ -0,0 +1,37 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use rln::circuit::TEST_TREE_HEIGHT;
+use rln::protocol::*;
+
+pub fn rln_witness_benchmark(c: &mut Criterion) {
+    let rln_witness = random_rln_witness(TEST_TREE_HEIGHT);
+
+    c.bench_function("rln_witness::full_cycle", |b| {
+        b.iter(|| {
+            let ser = serialize_witness(&rln_witness).unwrap();
+            let (deser, _) = deserialize_witness(&ser).unwrap();
+            let rln_witness_json = rln_witness_to_json(&deser).unwrap();
+            let _ = rln_witness_from_json(rln_witness_json).unwrap();
+        })
+    });
+
+    c.bench_function("rln_witness::serialize_cycle", |b| {
+        b.iter(|| {
+            let ser = serialize_witness(&rln_witness).unwrap();
+            let _ = deserialize_witness(&ser).unwrap();
+        })
+    });
+
+    c.bench_function("rln_witness::json_cycle", |b| {
+        b.iter(|| {
+            let rln_witness_json = rln_witness_to_json(&rln_witness).unwrap();
+            let _ = rln_witness_from_json(rln_witness_json).unwrap();
+        })
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().measurement_time(std::time::Duration::from_secs(10));
+    targets = rln_witness_benchmark
+}
+criterion_main!(benches);

rln/resources/tree_height_20/verification_key.json

@@ -1,114 +0,0 @@
-{
- "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": [
-  [
-   "17077735495685170943380938230836408503627170115414840315502244846025577589191",
-   "14030085636943255545683322474441991939484590437387381169642530788494152024614"
-  ],
-  [
-   "11568745146423307387256571230823432454624378106569286849514884592874522611163",
-   "1838524899938769516485895655063198583192139511330418290063560641219523306282"
-  ],
-  [
-   "1",
-   "0"
-  ]
- ],
- "vk_alphabeta_12": [
-  [
-   [
-    "2029413683389138792403550203267699914886160938906632433982220835551125967885",
-    "21072700047562757817161031222997517981543347628379360635925549008442030252106"
-   ],
-   [
-    "5940354580057074848093997050200682056184807770593307860589430076672439820312",
-    "12156638873931618554171829126792193045421052652279363021382169897324752428276"
-   ],
-   [
-    "7898200236362823042373859371574133993780991612861777490112507062703164551277",
-    "7074218545237549455313236346927434013100842096812539264420499035217050630853"
-   ]
-  ],
-  [
-   [
-    "7077479683546002997211712695946002074877511277312570035766170199895071832130",
-    "10093483419865920389913245021038182291233451549023025229112148274109565435465"
-   ],
-   [
-    "4595479056700221319381530156280926371456704509942304414423590385166031118820",
-    "19831328484489333784475432780421641293929726139240675179672856274388269393268"
-   ],
-   [
-    "11934129596455521040620786944827826205713621633706285934057045369193958244500",
-    "8037395052364110730298837004334506829870972346962140206007064471173334027475"
-   ]
-  ]
- ],
- "IC": [
-  [
-   "4920513730204767532050733107749276406754520419375654722016092399980613788208",
-   "10950491564509418434657706642388934308456795265036074733953533582377584967294",
-   "1"
-  ],
-  [
-   "6815064660695497986531118446154820702646540722664044216580897159556261271171",
-   "17838140936832571103329556013529166877877534025488014783346458943575275015438",
-   "1"
-  ],
-  [
-   "16364982450206976302246609763791333525052810246590359380676749324389440643932",
-   "17092624338100676284548565502349491320314889021833923882585524649862570629227",
-   "1"
-  ],
-  [
-   "3679639231485547795420532910726924727560917141402837495597760107842698404034",
-   "16213191511474848247596810551723578773353083440353745908057321946068926848382",
-   "1"
-  ],
-  [
-   "9215428431027260354679105025212521481930206886203677270216204485256690813172",
-   "934602510541226149881779979217731465262250233587980565969044391353665291792",
-   "1"
-  ],
-  [
-   "8935861545794299876685457331391349387048184820319250771243971382360441890897",
-   "4993459033694759724715904486381952906869986989682015547152342336961693234616",
-   "1"
-  ]
- ]
-}

rln/src/circuit.rs

@@ -6,42 +6,55 @@ use ark_bn254::{
 };
 use ark_groth16::{ProvingKey, VerifyingKey};
 use ark_relations::r1cs::ConstraintMatrices;
+use ark_serialize::CanonicalDeserialize;
 use cfg_if::cfg_if;
 use color_eyre::{Report, Result};
-use num_bigint::BigUint;
-use serde_json::Value;
-use std::str::FromStr;
-
-cfg_if! {
-    if #[cfg(not(target_arch = "wasm32"))] {
-        use ark_circom::{WitnessCalculator};
-        use once_cell::sync::OnceCell;
-        use std::sync::Mutex;
-        use wasmer::{Module, Store};
-        use include_dir::{include_dir, Dir};
-        use std::path::Path;
-    }
-}
-
-cfg_if! {
-    if #[cfg(feature = "arkzkey")] {
-        use ark_zkey::read_arkzkey_from_bytes;
-        const ARKZKEY_FILENAME: &str = "tree_height_20/rln_final.arkzkey";
-
-    } 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;
 
 #[cfg(not(target_arch = "wasm32"))]
-static RESOURCES_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/resources");
+use {
+    ark_circom::WitnessCalculator,
+    lazy_static::lazy_static,
+    std::sync::{Arc, Mutex},
+    wasmer::{Module, Store},
+};
+
+#[cfg(feature = "arkzkey")]
+use ark_zkey::read_arkzkey_from_bytes;
+
+#[cfg(not(feature = "arkzkey"))]
+use {ark_circom::read_zkey, std::io::Cursor};
+
+#[cfg(feature = "arkzkey")]
+const ARKZKEY_BYTES: &[u8] = include_bytes!("../resources/tree_height_20/rln_final.arkzkey");
+
+pub const ZKEY_BYTES: &[u8] = include_bytes!("../resources/tree_height_20/rln_final.zkey");
+pub const VK_BYTES: &[u8] = include_bytes!("../resources/tree_height_20/verification_key.arkvkey");
+const WASM_BYTES: &[u8] = include_bytes!("../resources/tree_height_20/rln.wasm");
+
+#[cfg(not(target_arch = "wasm32"))]
+lazy_static! {
+    #[cfg(not(target_arch = "wasm32"))]
+    static ref ZKEY: (ProvingKey<Curve>, ConstraintMatrices<Fr>) = {
+        cfg_if! {
+                if #[cfg(feature = "arkzkey")] {
+                    read_arkzkey_from_bytes(ARKZKEY_BYTES).expect("Failed to read arkzkey")
+                } else {
+                    let mut reader = Cursor::new(ZKEY_BYTES);
+                    read_zkey(&mut reader).expect("Failed to read zkey")
+                }
+        }
+    };
+
+    #[cfg(not(target_arch = "wasm32"))]
+    static ref VK: VerifyingKey<Curve> = vk_from_ark_serialized(VK_BYTES).expect("Failed to read vk");
+
+    #[cfg(not(target_arch = "wasm32"))]
+    static ref WITNESS_CALCULATOR: Arc<Mutex<WitnessCalculator>> = {
+        circom_from_raw(WASM_BYTES).expect("Failed to create witness calculator")
+    };
+}
+
+pub const TEST_TREE_HEIGHT: usize = 20;
 
 // The following types define the pairing friendly elliptic curve, the underlying finite fields and groups default to this module
 // Note that proofs are serialized assuming Fr to be 4x8 = 32 bytes in size. Hence, changing to a curve with different encoding will make proof verification to fail
@@ -55,227 +68,75 @@ pub type G2Affine = ArkG2Affine;
 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)?
-            }
-        };
-        Ok(proving_key_and_matrices)
-    } else {
-        Err(Report::msg("No proving key found!"))
+pub fn zkey_from_raw(zkey_data: &[u8]) -> Result<(ProvingKey<Curve>, ConstraintMatrices<Fr>)> {
+    if zkey_data.is_empty() {
+        return Err(Report::msg("No proving key found!"));
     }
+
+    let proving_key_and_matrices = match () {
+        #[cfg(feature = "arkzkey")]
+        () => read_arkzkey_from_bytes(zkey_data)?,
+        #[cfg(not(feature = "arkzkey"))]
+        () => {
+            let mut reader = Cursor::new(zkey_data);
+            read_zkey(&mut reader)?
+        }
+    };
+
+    Ok(proving_key_and_matrices)
 }
 
 // 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));
-
-    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)?
-            }
-        };
-        Ok(proving_key_and_matrices)
-    } else {
-        Err(Report::msg("No proving key found!"))
-    }
+pub fn zkey_from_folder() -> &'static (ProvingKey<Curve>, ConstraintMatrices<Fr>) {
+    &ZKEY
 }
 
 // Loads the verification key from a bytes vector
-pub fn vk_from_raw(vk_data: &[u8], zkey_data: &Vec<u8>) -> Result<VerifyingKey<Curve>> {
-    let verifying_key: VerifyingKey<Curve>;
-
+pub fn vk_from_raw(vk_data: &[u8], zkey_data: &[u8]) -> Result<VerifyingKey<Curve>> {
     if !vk_data.is_empty() {
-        verifying_key = vk_from_vector(vk_data)?;
-        Ok(verifying_key)
-    } else if !zkey_data.is_empty() {
-        let (proving_key, _matrices) = zkey_from_raw(zkey_data)?;
-        verifying_key = proving_key.vk;
-        Ok(verifying_key)
-    } else {
-        Err(Report::msg("No proving/verification key found!"))
+        return vk_from_ark_serialized(vk_data);
     }
+
+    if !zkey_data.is_empty() {
+        let (proving_key, _matrices) = zkey_from_raw(zkey_data)?;
+        return Ok(proving_key.vk);
+    }
+
+    Err(Report::msg("No proving/verification key found!"))
 }
 
 // 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));
-
-    let verifying_key: VerifyingKey<Curve>;
-    if let Some(vk) = vk {
-        verifying_key = vk_from_json(vk.contents_utf8().ok_or(Report::msg(
-            "Could not read verification key from JSON file!",
-        ))?)?;
-        Ok(verifying_key)
-    } else if let Some(_zkey) = zkey {
-        let (proving_key, _matrices) = zkey_from_folder()?;
-        verifying_key = proving_key.vk;
-        Ok(verifying_key)
-    } else {
-        Err(Report::msg("No proving/verification key found!"))
-    }
+pub fn vk_from_folder() -> &'static VerifyingKey<Curve> {
+    &VK
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-static WITNESS_CALCULATOR: OnceCell<Mutex<WitnessCalculator>> = OnceCell::new();
-
 // Initializes the witness calculator using a bytes vector
 #[cfg(not(target_arch = "wasm32"))]
-pub fn circom_from_raw(wasm_buffer: Vec<u8>) -> Result<&'static Mutex<WitnessCalculator>> {
-    WITNESS_CALCULATOR.get_or_try_init(|| {
-        let store = Store::default();
-        let module = Module::new(&store, wasm_buffer)?;
-        let result = WitnessCalculator::from_module(module)?;
-        Ok::<Mutex<WitnessCalculator>, Report>(Mutex::new(result))
-    })
+pub fn circom_from_raw(wasm_buffer: &[u8]) -> Result<Arc<Mutex<WitnessCalculator>>> {
+    let module = Module::new(&Store::default(), wasm_buffer)?;
+    let result = WitnessCalculator::from_module(module)?;
+    Ok(Arc::new(Mutex::new(result)))
 }
 
 // Initializes the witness calculator
 #[cfg(not(target_arch = "wasm32"))]
-pub fn circom_from_folder() -> Result<&'static Mutex<WitnessCalculator>> {
-    // We read the wasm file
-    let wasm = RESOURCES_DIR.get_file(Path::new(WASM_FILENAME));
-
-    if let Some(wasm) = wasm {
-        let wasm_buffer = wasm.contents();
-        circom_from_raw(wasm_buffer.to_vec())
-    } else {
-        Err(Report::msg("No wasm file found!"))
-    }
+pub fn circom_from_folder() -> &'static Arc<Mutex<WitnessCalculator>> {
+    &WITNESS_CALCULATOR
 }
 
-// The following function implementations are taken/adapted from https://github.com/gakonst/ark-circom/blob/1732e15d6313fe176b0b1abb858ac9e095d0dbd7/src/zkey.rs
-
-// 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)?))
-}
-
-// Extracts the element in G1 corresponding to its JSON serialization
-fn json_to_g1(json: &Value, key: &str) -> Result<G1Affine> {
-    let els: Vec<String> = json
-        .get(key)
-        .ok_or(Report::msg("no json value"))?
-        .as_array()
-        .ok_or(Report::msg("value not an array"))?
-        .iter()
-        .map(|i| i.as_str().ok_or(Report::msg("element is not a string")))
-        .map(|x| x.map(|v| v.to_owned()))
-        .collect::<Result<Vec<String>>>()?;
-
-    Ok(G1Affine::from(G1Projective::new(
-        fq_from_str(&els[0])?,
-        fq_from_str(&els[1])?,
-        fq_from_str(&els[2])?,
-    )))
-}
-
-// Extracts the vector of G1 elements corresponding to its JSON serialization
-fn json_to_g1_vec(json: &Value, key: &str) -> Result<Vec<G1Affine>> {
-    let els: Vec<Vec<String>> = json
-        .get(key)
-        .ok_or(Report::msg("no json value"))?
-        .as_array()
-        .ok_or(Report::msg("value not an array"))?
-        .iter()
-        .map(|i| {
-            i.as_array()
-                .ok_or(Report::msg("element is not an array"))
-                .and_then(|array| {
-                    array
-                        .iter()
-                        .map(|x| x.as_str().ok_or(Report::msg("element is not a string")))
-                        .map(|x| x.map(|v| v.to_owned()))
-                        .collect::<Result<Vec<String>>>()
-                })
-        })
-        .collect::<Result<Vec<Vec<String>>>>()?;
-
-    let mut res = vec![];
-    for coords in els {
-        res.push(G1Affine::from(G1Projective::new(
-            fq_from_str(&coords[0])?,
-            fq_from_str(&coords[1])?,
-            fq_from_str(&coords[2])?,
-        )))
-    }
-
-    Ok(res)
-}
-
-// Extracts the element in G2 corresponding to its JSON serialization
-fn json_to_g2(json: &Value, key: &str) -> Result<G2Affine> {
-    let els: Vec<Vec<String>> = json
-        .get(key)
-        .ok_or(Report::msg("no json value"))?
-        .as_array()
-        .ok_or(Report::msg("value not an array"))?
-        .iter()
-        .map(|i| {
-            i.as_array()
-                .ok_or(Report::msg("element is not an array"))
-                .and_then(|array| {
-                    array
-                        .iter()
-                        .map(|x| x.as_str().ok_or(Report::msg("element is not a string")))
-                        .map(|x| x.map(|v| v.to_owned()))
-                        .collect::<Result<Vec<String>>>()
-                })
-        })
-        .collect::<Result<Vec<Vec<String>>>>()?;
-
-    let x = Fq2::new(fq_from_str(&els[0][0])?, fq_from_str(&els[0][1])?);
-    let y = Fq2::new(fq_from_str(&els[1][0])?, fq_from_str(&els[1][1])?);
-    let z = Fq2::new(fq_from_str(&els[2][0])?, fq_from_str(&els[2][1])?);
-    Ok(G2Affine::from(G2Projective::new(x, y, z)))
-}
-
-// Converts JSON to a VerifyingKey
-fn to_verifying_key(json: serde_json::Value) -> Result<VerifyingKey<Curve>> {
-    Ok(VerifyingKey {
-        alpha_g1: json_to_g1(&json, "vk_alpha_1")?,
-        beta_g2: json_to_g2(&json, "vk_beta_2")?,
-        gamma_g2: json_to_g2(&json, "vk_gamma_2")?,
-        delta_g2: json_to_g2(&json, "vk_delta_2")?,
-        gamma_abc_g1: json_to_g1_vec(&json, "IC")?,
-    })
-}
-
-// Computes the verification key from its JSON serialization
-fn vk_from_json(vk: &str) -> Result<VerifyingKey<Curve>> {
-    let json: Value = serde_json::from_str(vk)?;
-    to_verifying_key(json)
-}
-
-// Computes the verification key from a bytes vector containing its JSON serialization
-fn vk_from_vector(vk: &[u8]) -> Result<VerifyingKey<Curve>> {
-    let json = String::from_utf8(vk.to_vec())?;
-    let json: Value = serde_json::from_str(&json)?;
-
-    to_verifying_key(json)
+// Computes the verification key from a bytes vector containing pre-processed ark-serialized verification key
+// uncompressed, unchecked
+pub fn vk_from_ark_serialized(data: &[u8]) -> Result<VerifyingKey<Curve>> {
+    let vk = VerifyingKey::<Curve>::deserialize_uncompressed_unchecked(data)?;
+    Ok(vk)
 }
 
 // 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()?;
+    let (proving_key, _matrices) = zkey_from_folder();
     if proving_key.vk == verifying_key {
         Ok(())
     } else {

rln/src/ffi.rs

@@ -143,15 +143,15 @@ impl ProcessArg for *const Buffer {
     }
 }
 
-impl<'a> ProcessArg for *const RLN<'a> {
-    type ReturnType = &'a RLN<'a>;
+impl ProcessArg for *const RLN {
+    type ReturnType = &'static RLN;
     fn process(self) -> Self::ReturnType {
         unsafe { &*self }
     }
 }
 
-impl<'a> ProcessArg for *mut RLN<'a> {
-    type ReturnType = &'a mut RLN<'a>;
+impl ProcessArg for *mut RLN {
+    type ReturnType = &'static mut RLN;
     fn process(self) -> Self::ReturnType {
         unsafe { &mut *self }
     }
@@ -361,6 +361,21 @@ 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/public.rs

@@ -11,7 +11,6 @@ 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};
 
@@ -23,9 +22,11 @@ cfg_if! {
         use ark_circom::WitnessCalculator;
         use serde_json::{json, Value};
         use utils::{Hasher};
+        use std::sync::Arc;
         use std::str::FromStr;
     } else {
         use std::marker::*;
+        use num_bigint::BigInt;
     }
 }
 
@@ -39,7 +40,7 @@ pub const RLN_IDENTIFIER: &[u8] = b"zerokit/rln/010203040506070809";
 /// It implements the methods required to update the internal Merkle Tree, generate and verify RLN ZK proofs.
 ///
 /// I/O is mostly done using writers and readers implementing `std::io::Write` and `std::io::Read`, respectively.
-pub struct RLN<'a> {
+pub struct RLN {
     proving_key: (ProvingKey<Curve>, ConstraintMatrices<Fr>),
     pub(crate) verification_key: VerifyingKey<Curve>,
     pub(crate) tree: PoseidonTree,
@@ -48,12 +49,12 @@ pub struct RLN<'a> {
     // contains a lifetime, a PhantomData is necessary to avoid a compiler
     // error since the lifetime is not being used
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) witness_calculator: &'a Mutex<WitnessCalculator>,
+    pub(crate) witness_calculator: Arc<Mutex<WitnessCalculator>>,
     #[cfg(target_arch = "wasm32")]
-    _marker: PhantomData<&'a ()>,
+    _marker: PhantomData<()>,
 }
 
-impl RLN<'_> {
+impl RLN {
     /// Creates a new RLN object by loading circuit resources from a folder.
     ///
     /// Input parameters are
@@ -70,7 +71,7 @@ impl RLN<'_> {
     /// let mut rln = RLN::new(tree_height, input);
     /// ```
     #[cfg(not(target_arch = "wasm32"))]
-    pub fn new<R: Read>(tree_height: usize, mut input_data: R) -> Result<RLN<'static>> {
+    pub fn new<R: Read>(tree_height: usize, mut input_data: R) -> Result<RLN> {
         // We read input
         let mut input: Vec<u8> = Vec::new();
         input_data.read_to_end(&mut input)?;
@@ -78,10 +79,10 @@ impl RLN<'_> {
         let rln_config: Value = serde_json::from_str(&String::from_utf8(input)?)?;
         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();
+        let proving_key = zkey_from_folder();
 
-        let verification_key = vk_from_folder()?;
+        let verification_key = vk_from_folder();
 
         let tree_config: <PoseidonTree as ZerokitMerkleTree>::Config = if tree_config.is_empty() {
             <PoseidonTree as ZerokitMerkleTree>::Config::default()
@@ -97,9 +98,9 @@ impl RLN<'_> {
         )?;
 
         Ok(RLN {
-            witness_calculator,
-            proving_key,
-            verification_key,
+            witness_calculator: witness_calculator.to_owned(),
+            proving_key: proving_key.to_owned(),
+            verification_key: verification_key.to_owned(),
             tree,
             #[cfg(target_arch = "wasm32")]
             _marker: PhantomData,
@@ -112,7 +113,7 @@ impl RLN<'_> {
     /// - `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
-    /// - `vk_vec`: a byte vector containing to the verification key (`verification_key.json`) as binary file
+    /// - `vk_vec`: a byte vector containing to the verification key (`verification_key.arkvkey`) as binary file
     /// - `tree_config_input`: a reader for a string containing a json with the merkle tree configuration
     ///
     /// Example:
@@ -124,7 +125,7 @@ impl RLN<'_> {
     /// let resources_folder = "./resources/tree_height_20/";
     ///
     /// let mut resources: Vec<Vec<u8>> = Vec::new();
-    /// for filename in ["rln.wasm", "rln_final.zkey", "verification_key.json"] {
+    /// for filename in ["rln.wasm", "rln_final.zkey", "verification_key.arkvkey"] {
     ///     let fullpath = format!("{resources_folder}{filename}");
     ///     let mut file = File::open(&fullpath).expect("no file found");
     ///     let metadata = std::fs::metadata(&fullpath).expect("unable to read metadata");
@@ -150,9 +151,9 @@ impl RLN<'_> {
         zkey_vec: Vec<u8>,
         vk_vec: Vec<u8>,
         mut tree_config_input: R,
-    ) -> Result<RLN<'static>> {
+    ) -> Result<RLN> {
         #[cfg(not(target_arch = "wasm32"))]
-        let witness_calculator = circom_from_raw(circom_vec)?;
+        let witness_calculator = circom_from_raw(&circom_vec)?;
 
         let proving_key = zkey_from_raw(&zkey_vec)?;
         let verification_key = vk_from_raw(&vk_vec, &zkey_vec)?;
@@ -179,15 +180,13 @@ impl RLN<'_> {
             proving_key,
             verification_key,
             tree,
+            #[cfg(target_arch = "wasm32")]
+            _marker: PhantomData,
         })
     }
 
     #[cfg(target_arch = "wasm32")]
-    pub fn new_with_params(
-        tree_height: usize,
-        zkey_vec: Vec<u8>,
-        vk_vec: Vec<u8>,
-    ) -> Result<RLN<'static>> {
+    pub fn new_with_params(tree_height: usize, zkey_vec: Vec<u8>, vk_vec: Vec<u8>) -> Result<RLN> {
         #[cfg(not(target_arch = "wasm32"))]
         let witness_calculator = circom_from_raw(circom_vec)?;
 
@@ -682,7 +681,7 @@ impl RLN<'_> {
         }
         */
 
-        let proof = generate_proof(self.witness_calculator, &self.proving_key, &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
         proof.serialize_compressed(&mut output_data)?;
@@ -805,7 +804,7 @@ impl RLN<'_> {
         let (rln_witness, _) = proof_inputs_to_rln_witness(&mut self.tree, &witness_byte)?;
         let proof_values = proof_values_from_witness(&rln_witness)?;
 
-        let proof = generate_proof(self.witness_calculator, &self.proving_key, &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
@@ -819,8 +818,7 @@ impl RLN<'_> {
     // 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
-    #[doc(hidden)]
+    #[cfg(target_arch = "wasm32")]
     pub fn generate_rln_proof_with_witness<W: Write>(
         &mut self,
         calculated_witness: Vec<BigInt>,
@@ -839,6 +837,30 @@ 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:
@@ -1261,7 +1283,7 @@ impl RLN<'_> {
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-impl Default for RLN<'_> {
+impl Default for RLN {
     fn default() -> Self {
         let tree_height = TEST_TREE_HEIGHT;
         let buffer = Cursor::new(json!({}).to_string());

rln/src/public_api_tests.rs

@@ -1,11 +1,10 @@
-use crate::circuit::{Curve, Fr, TEST_TREE_HEIGHT};
+use crate::circuit::{Fr, TEST_TREE_HEIGHT};
 use crate::hashers::{hash_to_field, poseidon_hash as utils_poseidon_hash};
 use crate::protocol::*;
 use crate::public::RLN;
 use crate::utils::*;
 use ark_groth16::Proof as ArkProof;
 use ark_serialize::{CanonicalDeserialize, Read};
-use num_bigint::BigInt;
 use std::io::Cursor;
 use std::str::FromStr;
 use utils::ZerokitMerkleTree;
@@ -646,32 +645,11 @@ fn test_rln_with_witness() {
 
     let serialized_witness = serialize_witness(&rln_witness).unwrap();
 
-    // Calculate witness outside zerokit (simulating what JS is doing)
-    let inputs = inputs_for_witness_calculation(&rln_witness)
-        .unwrap()
-        .into_iter()
-        .map(|(name, values)| (name.to_string(), values));
-    let calculated_witness = rln
-        .witness_calculator
-        .lock()
-        .expect("witness_calculator mutex should not get poisoned")
-        .calculate_witness_element::<Curve, _>(inputs, false)
-        .map_err(ProofError::WitnessError)
-        .unwrap();
-
-    let calculated_witness_vec: Vec<BigInt> = calculated_witness
-        .into_iter()
-        .map(|v| to_bigint(&v).unwrap())
-        .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(
-        calculated_witness_vec,
-        serialized_witness,
-        &mut output_buffer,
-    )
-    .unwrap();
+    rln.generate_rln_proof_with_witness(&mut input_buffer, &mut output_buffer)
+        .unwrap();
 
     // output_data is  [ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> ]
     let mut proof_data = output_buffer.into_inner();

rln/tests/ffi.rs

@@ -16,7 +16,7 @@ mod test {
 
     const NO_OF_LEAVES: usize = 256;
 
-    fn create_rln_instance() -> &'static mut RLN<'static> {
+    fn create_rln_instance() -> &'static mut RLN {
         let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
         let input_config = json!({}).to_string();
         let input_buffer = &Buffer::from(input_config.as_bytes());
@@ -427,7 +427,7 @@ mod test {
             .read_exact(&mut zkey_buffer)
             .expect("buffer overflow");
 
-        let vk_path = "./resources/tree_height_20/verification_key.json";
+        let vk_path = "./resources/tree_height_20/verification_key.arkvkey";
         let mut vk_file = File::open(&vk_path).expect("no file found");
         let metadata = std::fs::metadata(&vk_path).expect("unable to read metadata");
         let mut vk_buffer = vec![0; metadata.len() as usize];

rln/tests/protocol.rs

@@ -127,9 +127,9 @@ mod 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();
+        let proving_key = zkey_from_folder();
+        let verification_key = vk_from_folder();
+        let builder = circom_from_folder();
 
         // We compute witness from the json input
         let rln_witness = get_test_witness();
@@ -156,9 +156,9 @@ mod test {
         assert_eq!(rln_witness_deser, rln_witness);
 
         // 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();
+        let verification_key = vk_from_folder();
+        let builder = circom_from_folder();
 
         // Let's generate a zkSNARK proof
         let proof = generate_proof(builder, &proving_key, &rln_witness_deser).unwrap();

utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zerokit_utils"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Various utilities for Zerokit"