fix commit

Cargo.lock

@@ -2412,15 +2412,6 @@ dependencies = [
  "plotters-backend",
 ]
 
-[[package]]
-name = "pmtree"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e054322ee96d2ccd86cd47b87797166682e45f5d67571c48eaa864668d26f510"
-dependencies = [
- "rayon",
-]
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
@@ -2695,7 +2686,7 @@ dependencies = [
 
 [[package]]
 name = "rln"
-version = "0.3.4"
+version = "0.3.0"
 dependencies = [
  "ark-bn254 0.4.0",
  "ark-circom 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -3513,6 +3504,15 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4dad5567ad0cf5b760e5665964bec1b47dfd077ba8a2544b513f3556d3d239a2"
 
+[[package]]
+name = "vacp2p_pmtree"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee78790de52d6774ea318eb747a488fd5d96055bfe75ec2e7f605b15e21c664"
+dependencies = [
+ "rayon",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.0"
@@ -4260,7 +4260,7 @@ dependencies = [
 
 [[package]]
 name = "zerokit_utils"
-version = "0.3.2"
+version = "0.3.0"
 dependencies = [
  "ark-bn254 0.4.0",
  "ark-ff 0.4.1",
@@ -4269,8 +4269,8 @@ dependencies = [
  "hex-literal",
  "num-bigint",
  "num-traits",
- "pmtree",
  "serde",
  "sled",
  "tiny-keccak",
+ "vacp2p_pmtree",
 ]

Cargo.toml

@@ -8,7 +8,6 @@ members = [
   "rln-wasm",
   "utils",
 ]
-resolver = "2"
 
 # Compilation profile for any non-workspace member.
 # Dependencies are optimized, even in a dev build. This improves dev performance
@@ -21,4 +20,4 @@ opt-level = 3
 opt-level = "s"
 
 [profile.release.package."semaphore"]
-codegen-units = 1
+codegen-units = 1

rln-cli/src/commands.rs

@@ -15,8 +15,6 @@ pub(crate) enum Commands {
         /// Sets a custom config file
         #[arg(short, long)]
         config: PathBuf,
-        #[arg(short, long)]
-        tree_config_input: PathBuf,
     },
     SetTree {
         tree_height: usize,

rln-cli/src/main.rs

@@ -34,7 +34,6 @@ fn main() -> Result<()> {
         Some(Commands::NewWithParams {
             tree_height,
             config,
-            tree_config_input,
         }) => {
             let mut resources: Vec<Vec<u8>> = Vec::new();
             for filename in ["rln.wasm", "rln_final.zkey", "verification_key.json"] {
@@ -45,13 +44,11 @@ fn main() -> Result<()> {
                 file.read_exact(&mut buffer)?;
                 resources.push(buffer);
             }
-            let tree_config_input_file = File::open(&tree_config_input)?;
             state.rln = Some(RLN::new_with_params(
                 *tree_height,
                 resources[0].clone(),
                 resources[1].clone(),
                 resources[2].clone(),
-                tree_config_input_file,
             )?);
             Ok(())
         }

rln-cli/src/state.rs

@@ -2,7 +2,7 @@ use color_eyre::Result;
 use rln::public::RLN;
 use std::fs::File;
 
-use crate::config::{Config, InnerConfig};
+use crate::config::{InnerConfig, Config};
 
 #[derive(Default)]
 pub(crate) struct State<'a> {

rln-wasm/src/lib.rs

@@ -250,7 +250,11 @@ pub fn wasm_set_metadata(ctx: *mut RLNWrapper, input: Uint8Array) -> Result<(),
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[wasm_bindgen(js_name = getMetadata)]
 pub fn wasm_get_metadata(ctx: *mut RLNWrapper) -> Result<Uint8Array, String> {
-    call_with_output_and_error_msg!(ctx, get_metadata, "could not get metadata".to_string())
+    call_with_output_and_error_msg!(
+        ctx,
+        get_metadata,
+        "could not get metadata".to_string()
+    )
 }
 
 #[allow(clippy::not_unsafe_ptr_arg_deref)]

rln/Cargo.toml

@@ -1,12 +1,9 @@
 [package]
 name = "rln"
-version = "0.3.4"
+version = "0.3.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "APIs to manage, compute and verify zkSNARK proofs and RLN primitives"
-documentation = "https://github.com/vacp2p/zerokit"
-homepage = "https://vac.dev"
-repository = "https://github.com/vacp2p/zerokit"
 
 [lib]
 crate-type = ["rlib", "staticlib"]
@@ -42,7 +39,7 @@ 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.3.2", path = "../utils/", default-features = false }
+utils = { package = "zerokit_utils", version = "=0.3.0", path = "../utils/", default-features = false }
 
 # serialization
 serde_json = "=1.0.96"

rln/src/ffi.rs

@@ -12,15 +12,7 @@ macro_rules! call {
     ($instance:expr, $method:ident $(, $arg:expr)*) => {
         {
             let new_instance: &mut RLN = $instance.process();
-            match new_instance.$method($($arg.process()),*) {
-                Ok(()) => {
-                    true
-                }
-                Err(err) => {
-                    eprintln!("execution error: {err}");
-                    false
-                }
-            }
+            new_instance.$method($($arg.process()),*).is_ok()
         }
     }
 }
@@ -38,17 +30,13 @@ macro_rules! call_with_output_arg {
         {
             let mut output_data: Vec<u8> = Vec::new();
             let new_instance = $instance.process();
-            match new_instance.$method(&mut output_data) {
-                Ok(()) => {
-                    unsafe { *$output_arg = Buffer::from(&output_data[..]) };
-                    std::mem::forget(output_data);
-                    true
-                }
-                Err(err) => {
-                    std::mem::forget(output_data);
-                    eprintln!("execution error: {err}");
-                    false
-                }
+            if new_instance.$method(&mut output_data).is_ok() {
+                unsafe { *$output_arg = Buffer::from(&output_data[..]) };
+                std::mem::forget(output_data);
+                true
+            } else {
+                std::mem::forget(output_data);
+                false
             }
         }
     };
@@ -56,17 +44,13 @@ macro_rules! call_with_output_arg {
         {
             let mut output_data: Vec<u8> = Vec::new();
             let new_instance = $instance.process();
-            match new_instance.$method($($arg.process()),*, &mut output_data) {
-                Ok(()) => {
-                    unsafe { *$output_arg = Buffer::from(&output_data[..]) };
-                    std::mem::forget(output_data);
-                    true
-                }
-                Err(err) => {
-                    std::mem::forget(output_data);
-                    eprintln!("execution error: {err}");
-                    false
-                }
+            if new_instance.$method($($arg.process()),*, &mut output_data).is_ok() {
+                unsafe { *$output_arg = Buffer::from(&output_data[..]) };
+                std::mem::forget(output_data);
+                true
+            } else {
+                std::mem::forget(output_data);
+                false
             }
         }
     };
@@ -82,17 +66,13 @@ macro_rules! no_ctx_call_with_output_arg {
     ($method:ident, $output_arg:expr, $( $arg:expr ),* ) => {
         {
             let mut output_data: Vec<u8> = Vec::new();
-            match $method($($arg.process()),*, &mut output_data) {
-                Ok(()) => {
-                    unsafe { *$output_arg = Buffer::from(&output_data[..]) };
-                    std::mem::forget(output_data);
-                    true
-                }
-                Err(err) => {
-                    std::mem::forget(output_data);
-                    eprintln!("execution error: {err}");
-                    false
-                }
+            if $method($($arg.process()),*, &mut output_data).is_ok() {
+                unsafe { *$output_arg = Buffer::from(&output_data[..]) };
+                std::mem::forget(output_data);
+                true
+            } else {
+                std::mem::forget(output_data);
+                false
             }
         }
     }
@@ -109,11 +89,8 @@ macro_rules! call_with_bool_arg {
         {
             let new_instance = $instance.process();
             if match new_instance.$method($($arg.process()),*,) {
-                Ok(result) => result,
-                Err(err) => {
-                    eprintln!("execution error: {err}");
-                    return false
-                },
+                Ok(verified) => verified,
+                Err(_) => return false,
             } {
                 unsafe { *$bool_arg = true };
             } else {
@@ -194,15 +171,11 @@ impl<'a> From<&Buffer> for &'a [u8] {
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn new(tree_height: usize, input_buffer: *const Buffer, ctx: *mut *mut RLN) -> bool {
-    match RLN::new(tree_height, input_buffer.process()) {
-        Ok(rln) => {
-            unsafe { *ctx = Box::into_raw(Box::new(rln)) };
-            true
-        }
-        Err(err) => {
-            eprintln!("could not instantiate rln: {err}");
-            false
-        }
+    if let Ok(rln) = RLN::new(tree_height, input_buffer.process()) {
+        unsafe { *ctx = Box::into_raw(Box::new(rln)) };
+        true
+    } else {
+        false
     }
 }
 
@@ -213,24 +186,18 @@ pub extern "C" fn new_with_params(
     circom_buffer: *const Buffer,
     zkey_buffer: *const Buffer,
     vk_buffer: *const Buffer,
-    tree_config: *const Buffer,
     ctx: *mut *mut RLN,
 ) -> bool {
-    match RLN::new_with_params(
+    if let Ok(rln) = RLN::new_with_params(
         tree_height,
         circom_buffer.process().to_vec(),
         zkey_buffer.process().to_vec(),
         vk_buffer.process().to_vec(),
-        tree_config.process(),
     ) {
-        Ok(rln) => {
-            unsafe { *ctx = Box::into_raw(Box::new(rln)) };
-            true
-        }
-        Err(err) => {
-            eprintln!("could not instantiate rln: {err}");
-            false
-        }
+        unsafe { *ctx = Box::into_raw(Box::new(rln)) };
+        true
+    } else {
+        false
     }
 }
 
@@ -261,12 +228,6 @@ pub extern "C" fn get_leaf(ctx: *mut RLN, index: usize, output_buffer: *mut Buff
     call_with_output_arg!(ctx, get_leaf, output_buffer, index)
 }
 
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[no_mangle]
-pub extern "C" fn leaves_set(ctx: *mut RLN) -> usize {
-    ctx.process().leaves_set()
-}
-
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn set_next_leaf(ctx: *mut RLN, input_buffer: *const Buffer) -> bool {
@@ -300,22 +261,6 @@ pub extern "C" fn atomic_operation(
     call!(ctx, atomic_operation, index, leaves_buffer, indices_buffer)
 }
 
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-#[no_mangle]
-pub extern "C" fn seq_atomic_operation(
-    ctx: *mut RLN,
-    leaves_buffer: *const Buffer,
-    indices_buffer: *const Buffer,
-) -> bool {
-    call!(
-        ctx,
-        atomic_operation,
-        ctx.process().leaves_set(),
-        leaves_buffer,
-        indices_buffer
-    )
-}
-
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn get_root(ctx: *const RLN, output_buffer: *mut Buffer) -> bool {

rln/src/hashers.rs

@@ -1,12 +1,13 @@
-/// This crate instantiates the Poseidon hash algorithm.
+// This crate instantiate the Poseidon hash algorithm
+
 use crate::{circuit::Fr, utils::bytes_le_to_fr};
 use once_cell::sync::Lazy;
 use tiny_keccak::{Hasher, Keccak};
 use utils::poseidon::Poseidon;
 
-/// These indexed constants hardcode the supported round parameters tuples (t, RF, RN, SKIP_MATRICES) for the Bn254 scalar field.
-/// SKIP_MATRICES is the index of the randomly generated secure MDS matrix.
-/// TODO: generate these parameters
+// These indexed constants hardcodes the supported round parameters tuples (t, RF, RN, SKIP_MATRICES) for the Bn254 scalar field
+// SKIP_MATRICES is the index of the randomly generated secure MDS matrix. See security note in the zerokit_utils::poseidon::poseidon_constants crate on this.
+// TODO: generate these parameters
 pub const ROUND_PARAMS: [(usize, usize, usize, usize); 8] = [
     (2, 8, 56, 0),
     (3, 8, 57, 0),
@@ -18,7 +19,7 @@ pub const ROUND_PARAMS: [(usize, usize, usize, usize); 8] = [
     (9, 8, 63, 0),
 ];
 
-/// Poseidon Hash wrapper over above implementation.
+// Poseidon Hash wrapper over above implementation. Adapted from semaphore-rs poseidon hash wrapper.
 static POSEIDON: Lazy<Poseidon<Fr>> = Lazy::new(|| Poseidon::<Fr>::from(&ROUND_PARAMS));
 
 pub fn poseidon_hash(input: &[Fr]) -> Fr {
@@ -27,11 +28,11 @@ pub fn poseidon_hash(input: &[Fr]) -> Fr {
         .expect("hash with fixed input size can't fail")
 }
 
-/// The zerokit RLN Merkle tree Hasher.
+// The zerokit RLN Merkle tree Hasher
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct PoseidonHash;
 
-/// The default Hasher trait used by Merkle tree implementation in utils.
+// The default Hasher trait used by Merkle tree implementation in utils
 impl utils::merkle_tree::Hasher for PoseidonHash {
     type Fr = Fr;
 
@@ -44,9 +45,10 @@ impl utils::merkle_tree::Hasher for PoseidonHash {
     }
 }
 
-/// Hashes arbitrary signal to the underlying prime field.
+// Hashes arbitrary signal to the underlying prime field
 pub fn hash_to_field(signal: &[u8]) -> Fr {
     // We hash the input signal using Keccak256
+    // (note that a bigger curve order might require a bigger hash blocksize)
     let mut hash = [0; 32];
     let mut hasher = Keccak::v256();
     hasher.update(signal);

rln/src/pm_tree_adapter.rs

@@ -1,16 +1,14 @@
-use std::fmt::Debug;
-use std::path::PathBuf;
-use std::str::FromStr;
-
-use color_eyre::{Report, Result};
-use serde_json::Value;
-
-use utils::pmtree::{Database, Hasher};
-use utils::*;
-
 use crate::circuit::Fr;
 use crate::hashers::{poseidon_hash, PoseidonHash};
 use crate::utils::{bytes_le_to_fr, fr_to_bytes_le};
+use color_eyre::{Report, Result};
+use serde_json::Value;
+use std::collections::HashSet;
+use std::fmt::Debug;
+use std::path::PathBuf;
+use std::str::FromStr;
+use utils::pmtree::{Database, Hasher};
+use utils::*;
 
 const METADATA_KEY: [u8; 8] = *b"metadata";
 
@@ -27,9 +25,13 @@ pub struct PmTreeProof {
 pub type FrOf<H> = <H as Hasher>::Fr;
 
 // The pmtree Hasher trait used by pmtree Merkle tree
-impl Hasher for PoseidonHash {
+impl pmtree::Hasher for PoseidonHash {
     type Fr = Fr;
 
+    fn default_leaf() -> Self::Fr {
+        Fr::from(0)
+    }
+
     fn serialize(value: Self::Fr) -> pmtree::Value {
         fr_to_bytes_le(&value)
     }
@@ -39,16 +41,12 @@ impl Hasher for PoseidonHash {
         fr
     }
 
-    fn default_leaf() -> Self::Fr {
-        Fr::from(0)
-    }
-
     fn hash(inputs: &[Self::Fr]) -> Self::Fr {
         poseidon_hash(inputs)
     }
 }
 
-fn get_tmp_path() -> PathBuf {
+fn get_tmp_path() -> std::path::PathBuf {
     std::env::temp_dir().join(format!("pmtree-{}", rand::random::<u64>()))
 }
 
@@ -56,7 +54,7 @@ fn get_tmp() -> bool {
     true
 }
 
-pub struct PmtreeConfig(Config);
+pub struct PmtreeConfig(pm_tree::Config);
 
 impl FromStr for PmtreeConfig {
     type Err = Report;
@@ -87,7 +85,7 @@ impl FromStr for PmtreeConfig {
             )));
         }
 
-        let config = Config::new()
+        let config = pm_tree::Config::new()
             .temporary(temporary.unwrap_or(get_tmp()))
             .path(path.unwrap_or(get_tmp_path()))
             .cache_capacity(cache_capacity.unwrap_or(1024 * 1024 * 1024))
@@ -102,7 +100,7 @@ impl Default for PmtreeConfig {
     fn default() -> Self {
         let tmp_path = get_tmp_path();
         PmtreeConfig(
-            Config::new()
+            pm_tree::Config::new()
                 .temporary(true)
                 .path(tmp_path)
                 .cache_capacity(150_000)
@@ -147,6 +145,10 @@ impl ZerokitMerkleTree for PmTree {
         })
     }
 
+    fn close_db_connection(&mut self) -> Result<()> {
+        self.tree.db.close().map_err(|e| Report::msg(e.to_string()))
+    }
+
     fn depth(&self) -> usize {
         self.tree.depth()
     }
@@ -163,16 +165,16 @@ impl ZerokitMerkleTree for PmTree {
         self.tree.root()
     }
 
-    fn compute_root(&mut self) -> Result<FrOf<Self::Hasher>> {
-        Ok(self.tree.root())
-    }
-
     fn set(&mut self, index: usize, leaf: FrOf<Self::Hasher>) -> Result<()> {
         self.tree
             .set(index, leaf)
             .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 set_range<I: IntoIterator<Item = FrOf<Self::Hasher>>>(
         &mut self,
         start: usize,
@@ -183,10 +185,6 @@ impl ZerokitMerkleTree for PmTree {
             .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 override_range<I: IntoIterator<Item = FrOf<Self::Hasher>>, J: IntoIterator<Item = usize>>(
         &mut self,
         start: usize,
@@ -194,17 +192,33 @@ impl ZerokitMerkleTree for PmTree {
         indices: J,
     ) -> Result<()> {
         let leaves = leaves.into_iter().collect::<Vec<_>>();
-        let mut indices = indices.into_iter().collect::<Vec<_>>();
-        indices.sort();
+        let indices = indices.into_iter().collect::<HashSet<_>>();
+        let end = start + leaves.len();
 
-        match (leaves.len(), indices.len()) {
-            (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_with_leaves(start, leaves),
-            (0, _) => self.remove_indices(&indices),
-            (_, _) => self.remove_indices_and_set_leaves(start, leaves, &indices),
+        if leaves.len() + start - indices.len() > self.capacity() {
+            return Err(Report::msg("index out of bounds"));
         }
+
+        // extend the range to include indices to be removed
+        let min_index = indices.iter().min().unwrap_or(&start);
+        let max_index = indices.iter().max().unwrap_or(&end);
+
+        let mut new_leaves = Vec::new();
+
+        // insert leaves into new_leaves
+        for i in *min_index..*max_index {
+            if indices.contains(&i) {
+                // insert 0
+                new_leaves.push(Self::Hasher::default_leaf());
+            } else {
+                // insert leaf
+                new_leaves.push(leaves[i - start]);
+            }
+        }
+
+        self.tree
+            .set_range(start, new_leaves)
+            .map_err(|e| Report::msg(e.to_string()))
     }
 
     fn update_next(&mut self, leaf: FrOf<Self::Hasher>) -> Result<()> {
@@ -232,6 +246,10 @@ impl ZerokitMerkleTree for PmTree {
         }
     }
 
+    fn compute_root(&mut self) -> Result<FrOf<Self::Hasher>> {
+        Ok(self.tree.root())
+    }
+
     fn set_metadata(&mut self, metadata: &[u8]) -> Result<()> {
         self.tree.db.put(METADATA_KEY, metadata.to_vec())?;
         self.metadata = metadata.to_vec();
@@ -250,59 +268,6 @@ impl ZerokitMerkleTree for PmTree {
         }
         Ok(data.unwrap())
     }
-
-    fn close_db_connection(&mut self) -> Result<()> {
-        self.tree.db.close().map_err(|e| Report::msg(e.to_string()))
-    }
-}
-
-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;
-
-        let new_leaves = (start..end).map(|_| PmTreeHasher::default_leaf());
-
-        self.tree
-            .set_range(start, new_leaves)
-            .map_err(|e| Report::msg(e.to_string()))
-    }
-
-    fn remove_indices_and_set_leaves(
-        &mut self,
-        start: usize,
-        leaves: Vec<FrOfPmTreeHasher>,
-        indices: &[usize],
-    ) -> Result<()> {
-        let min_index = *indices.first().unwrap();
-        let max_index = start + leaves.len();
-
-        let mut set_values = vec![PmTreeHasher::default_leaf(); max_index - min_index];
-
-        for i in min_index..start {
-            if !indices.contains(&i) {
-                let value = self.tree.get(i)?;
-                set_values[i - min_index] = value;
-            }
-        }
-
-        for (i, &leaf) in leaves.iter().enumerate() {
-            set_values[start - min_index + i] = leaf;
-        }
-
-        self.tree
-            .set_range(min_index, set_values)
-            .map_err(|e| Report::msg(e.to_string()))
-    }
 }
 
 impl ZerokitMerkleProof for PmTreeProof {

rln/src/public.rs

@@ -117,7 +117,6 @@ impl RLN<'_> {
     /// - `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`) as binary file
     /// - `vk_vec`: a byte vector containing to the verification key (`verification_key.json`) as binary file
-    /// - `tree_config`: a reader for a string containing a json with the merkle tree configuration
     ///
     /// Example:
     /// ```
@@ -135,8 +134,6 @@ impl RLN<'_> {
     ///     let mut buffer = vec![0; metadata.len() as usize];
     ///     file.read_exact(&mut buffer).expect("buffer overflow");
     ///     resources.push(buffer);
-    ///     let tree_config = "{}".to_string();
-    ///     let tree_config_buffer = &Buffer::from(tree_config.as_bytes());
     /// }
     ///
     /// let mut rln = RLN::new_with_params(
@@ -144,51 +141,11 @@ impl RLN<'_> {
     ///     resources[0].clone(),
     ///     resources[1].clone(),
     ///     resources[2].clone(),
-    ///     tree_config_buffer,
     /// );
     /// ```
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn new_with_params<R: Read>(
-        tree_height: usize,
-        circom_vec: Vec<u8>,
-        zkey_vec: Vec<u8>,
-        vk_vec: Vec<u8>,
-        mut tree_config_input: R,
-    ) -> Result<RLN<'static>> {
-        #[cfg(not(target_arch = "wasm32"))]
-        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)?;
-
-        let mut tree_config_vec: Vec<u8> = Vec::new();
-        tree_config_input.read_to_end(&mut tree_config_vec)?;
-        let tree_config_str = String::from_utf8(tree_config_vec)?;
-        let tree_config: <PoseidonTree as ZerokitMerkleTree>::Config = if tree_config_str.is_empty()
-        {
-            <PoseidonTree as ZerokitMerkleTree>::Config::default()
-        } else {
-            <PoseidonTree as ZerokitMerkleTree>::Config::from_str(&tree_config_str)?
-        };
-
-        // We compute a default empty tree
-        let tree = PoseidonTree::new(
-            tree_height,
-            <PoseidonTree as ZerokitMerkleTree>::Hasher::default_leaf(),
-            tree_config,
-        )?;
-
-        Ok(RLN {
-            witness_calculator,
-            proving_key,
-            verification_key,
-            tree,
-        })
-    }
-
-    #[cfg(target_arch = "wasm32")]
     pub fn new_with_params(
         tree_height: usize,
+        #[cfg(not(target_arch = "wasm32"))] circom_vec: Vec<u8>,
         zkey_vec: Vec<u8>,
         vk_vec: Vec<u8>,
     ) -> Result<RLN<'static>> {
@@ -202,9 +159,12 @@ impl RLN<'_> {
         let tree = PoseidonTree::default(tree_height)?;
 
         Ok(RLN {
+            #[cfg(not(target_arch = "wasm32"))]
+            witness_calculator,
             proving_key,
             verification_key,
             tree,
+            #[cfg(target_arch = "wasm32")]
             _marker: PhantomData,
         })
     }
@@ -402,14 +362,10 @@ impl RLN<'_> {
         // We set the leaves
         self.tree
             .override_range(index, leaves, indices)
-            .map_err(|e| Report::msg(format!("Could not perform the batch operation: {e}")))?;
+            .map_err(|_| Report::msg("Could not perform the batch operation"))?;
         Ok(())
     }
 
-    pub fn leaves_set(&mut self) -> usize {
-        self.tree.leaves_set()
-    }
-
     /// Sets a leaf value at the next available never-set leaf index.
     ///
     /// This function updates the internal Merkle tree `next_index` value indicating the next available index corresponding to a never-set leaf as `next_index = next_index + 1`.
@@ -1431,7 +1387,7 @@ mod test {
 
         assert_eq!(root_batch_with_init, root_single_additions);
 
-        rln.flush().unwrap();
+        rln.flush();
     }
 
     #[test]
@@ -1474,7 +1430,7 @@ mod test {
         let indices_buffer = Cursor::new(vec_u8_to_bytes_le(&indices).unwrap());
         let leaves_buffer = Cursor::new(vec_fr_to_bytes_le(&last_leaf).unwrap());
 
-        rln.atomic_operation(last_leaf_index, leaves_buffer, indices_buffer)
+        rln.atomic_operation(no_of_leaves, leaves_buffer, indices_buffer)
             .unwrap();
 
         // We get the root of the tree obtained after a no-op
@@ -1485,105 +1441,6 @@ mod test {
         assert_eq!(root_after_insertion, root_after_noop);
     }
 
-    #[test]
-    fn test_atomic_operation_zero_indexed() {
-        // Test duplicated from https://github.com/waku-org/go-zerokit-rln/pull/12/files
-        let tree_height = TEST_TREE_HEIGHT;
-        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 {
-            leaves.push(Fr::rand(&mut rng));
-        }
-
-        // We create a new tree
-        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());
-        rln.init_tree_with_leaves(&mut buffer).unwrap();
-
-        // We check if number of leaves set is consistent
-        assert_eq!(rln.tree.leaves_set(), no_of_leaves);
-
-        // We get the root of the tree obtained adding leaves in batch
-        let mut buffer = Cursor::new(Vec::<u8>::new());
-        rln.get_root(&mut buffer).unwrap();
-        let (root_after_insertion, _) = bytes_le_to_fr(&buffer.into_inner());
-
-        let zero_index = 0;
-        let indices = vec![zero_index as u8];
-        let zero_leaf: Vec<Fr> = vec![];
-        let indices_buffer = Cursor::new(vec_u8_to_bytes_le(&indices).unwrap());
-        let leaves_buffer = Cursor::new(vec_fr_to_bytes_le(&zero_leaf).unwrap());
-        rln.atomic_operation(0, leaves_buffer, indices_buffer)
-            .unwrap();
-
-        // We get the root of the tree obtained after a deletion
-        let mut buffer = Cursor::new(Vec::<u8>::new());
-        rln.get_root(&mut buffer).unwrap();
-        let (root_after_deletion, _) = bytes_le_to_fr(&buffer.into_inner());
-
-        assert_ne!(root_after_insertion, root_after_deletion);
-    }
-
-    #[test]
-    fn test_atomic_operation_consistency() {
-        // Test duplicated from https://github.com/waku-org/go-zerokit-rln/pull/12/files
-        let tree_height = TEST_TREE_HEIGHT;
-        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 {
-            leaves.push(Fr::rand(&mut rng));
-        }
-
-        // We create a new tree
-        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());
-        rln.init_tree_with_leaves(&mut buffer).unwrap();
-
-        // We check if number of leaves set is consistent
-        assert_eq!(rln.tree.leaves_set(), no_of_leaves);
-
-        // We get the root of the tree obtained adding leaves in batch
-        let mut buffer = Cursor::new(Vec::<u8>::new());
-        rln.get_root(&mut buffer).unwrap();
-        let (root_after_insertion, _) = bytes_le_to_fr(&buffer.into_inner());
-
-        let set_index = rng.gen_range(0..no_of_leaves) as usize;
-        let indices = vec![set_index as u8];
-        let zero_leaf: Vec<Fr> = vec![];
-        let indices_buffer = Cursor::new(vec_u8_to_bytes_le(&indices).unwrap());
-        let leaves_buffer = Cursor::new(vec_fr_to_bytes_le(&zero_leaf).unwrap());
-        rln.atomic_operation(0, leaves_buffer, indices_buffer)
-            .unwrap();
-
-        // We get the root of the tree obtained after a deletion
-        let mut buffer = Cursor::new(Vec::<u8>::new());
-        rln.get_root(&mut buffer).unwrap();
-        let (root_after_deletion, _) = bytes_le_to_fr(&buffer.into_inner());
-
-        assert_ne!(root_after_insertion, root_after_deletion);
-
-        // We get the leaf
-        let mut output_buffer = Cursor::new(Vec::<u8>::new());
-        rln.get_leaf(set_index, &mut output_buffer).unwrap();
-        let (received_leaf, _) = bytes_le_to_fr(output_buffer.into_inner().as_ref());
-
-        assert_eq!(received_leaf, Fr::from(0));
-    }
-
     #[allow(unused_must_use)]
     #[test]
     // This test checks if `set_leaves_from` throws an error when the index is out of bounds

rln/tests/ffi.rs

@@ -143,8 +143,6 @@ mod test {
         assert!(success, "RLN object creation failed");
         let rln_pointer = unsafe { &mut *rln_pointer.assume_init() };
 
-        assert_eq!(rln_pointer.leaves_set(), 0);
-
         // We generate a vector of random leaves
         let mut leaves: Vec<Fr> = Vec::new();
         let mut rng = thread_rng();
@@ -161,7 +159,6 @@ mod test {
         let input_buffer = &Buffer::from(leaves_ser.as_ref());
         let success = init_tree_with_leaves(rln_pointer, input_buffer);
         assert!(success, "init tree with leaves call failed");
-        assert_eq!(rln_pointer.leaves_set(), no_of_leaves);
 
         // We get the root of the tree obtained adding leaves in batch
         let mut output_buffer = MaybeUninit::<Buffer>::uninit();
@@ -268,7 +265,7 @@ mod test {
 
         let success = atomic_operation(
             rln_pointer,
-            last_leaf_index as usize,
+            no_of_leaves as usize,
             leaves_buffer,
             indices_buffer,
         );
@@ -620,14 +617,11 @@ mod test {
 
         // Creating a RLN instance passing the raw data
         let mut rln_pointer_raw_bytes = MaybeUninit::<*mut RLN>::uninit();
-        let tree_config = "".to_string();
-        let tree_config_buffer = &Buffer::from(tree_config.as_bytes());
         let success = new_with_params(
             tree_height,
             circom_data,
             zkey_data,
             vk_data,
-            tree_config_buffer,
             rln_pointer_raw_bytes.as_mut_ptr(),
         );
         assert!(success, "RLN object creation failed");

semaphore/Cargo.toml

@@ -47,4 +47,4 @@ opt-level = 3
 # 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
+opt-level = 3

utils/Cargo.toml

@@ -1,12 +1,9 @@
 [package]
 name = "zerokit_utils"
-version = "0.3.2"
+version = "0.3.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Various utilities for Zerokit"
-documentation = "https://github.com/vacp2p/zerokit"
-homepage = "https://vac.dev"
-repository = "https://github.com/vacp2p/zerokit"
 
 [lib]
 bench = false
@@ -15,7 +12,7 @@ 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 = "pmtree", version = "=2.0.0", optional = true}
+pmtree = { package = "vacp2p_pmtree", version = "=1.0.0", optional = true}
 sled = "=0.34.7"
 serde = "=1.0.163"
 

utils/src/pm_tree/sled_adapter.rs

@@ -2,51 +2,29 @@ use pmtree::*;
 
 use sled::Db as Sled;
 use std::collections::HashMap;
-use std::thread;
-use std::time::Duration;
 
 pub struct SledDB(Sled);
 
-impl SledDB {
-    fn new_with_tries(config: <SledDB as Database>::Config, tries: u32) -> PmtreeResult<Self> {
-        // If we've tried more than 10 times, we give up and return an error.
-        if tries >= 10 {
-            return Err(PmtreeErrorKind::DatabaseError(
-                DatabaseErrorKind::CustomError(format!(
-                    "Cannot create database: exceeded maximum retry attempts. {config:#?}"
-                )),
-            ));
-        }
-        match config.open() {
-            Ok(db) => Ok(SledDB(db)),
-            Err(e) if e.to_string().contains("WouldBlock") => {
-                // try till the fd is freed
-                // sleep for 10^tries milliseconds, then recursively try again
-                thread::sleep(Duration::from_millis(10u64.pow(tries)));
-                Self::new_with_tries(config, tries + 1)
-            }
-            Err(e) => {
-                // On any other error, we return immediately.
-                Err(PmtreeErrorKind::DatabaseError(
-                    DatabaseErrorKind::CustomError(format!(
-                        "Cannot create database: {e} {config:#?}"
-                    )),
-                ))
-            }
-        }
-    }
-}
-
 impl Database for SledDB {
     type Config = sled::Config;
 
     fn new(config: Self::Config) -> PmtreeResult<Self> {
-        let db = Self::new_with_tries(config, 0)?;
-        Ok(db)
+        let db: Sled = match config.open() {
+            Ok(db) => db,
+            Err(e) => {
+                return Err(PmtreeErrorKind::DatabaseError(
+                    DatabaseErrorKind::CustomError(format!(
+                        "Cannot create database: {e} {config:#?}",
+                    )),
+                ))
+            }
+        };
+
+        Ok(SledDB(db))
     }
 
     fn load(config: Self::Config) -> PmtreeResult<Self> {
-        let db = match config.open() {
+        let db: Sled = match sled::open(&config.path) {
             Ok(db) => db,
             Err(e) => {
                 return Err(PmtreeErrorKind::DatabaseError(