chore: Release

.github/workflows/ci.yml

@@ -134,4 +134,4 @@ jobs:
       - uses: boa-dev/criterion-compare-action@v3
         with:
           branchName: ${{ github.base_ref }}
-          cwd: ${{ matrix.crate }}
+          cwd: ${{ matrix.crate }}

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.6"
+version = "0.3.1"
 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.1"
 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",
 ]

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"

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,6 +1,6 @@
 [package]
 name = "rln"
-version = "0.3.6"
+version = "0.3.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "APIs to manage, compute and verify zkSNARK proofs and RLN primitives"
@@ -42,7 +42,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.1", 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 {
@@ -361,21 +306,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

@@ -197,13 +197,11 @@ impl ZerokitMerkleTree for PmTree {
         let mut indices = indices.into_iter().collect::<Vec<_>>();
         indices.sort();
 
-        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),
+        match (leaves.is_empty(), indices.is_empty()) {
+            (true, true) => Err(Report::msg("no leaves or indices to be removed")),
+            (false, true) => self.set_range_with_leaves(start, leaves),
+            (true, false) => self.remove_indices(indices),
+            (false, false) => self.remove_indices_and_set_leaves(start, leaves, indices),
         }
     }
 
@@ -246,8 +244,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())
     }
@@ -267,11 +264,18 @@ impl PmTree {
             .map_err(|e| Report::msg(e.to_string()))
     }
 
-    fn remove_indices(&mut self, indices: &[usize]) -> Result<()> {
+    fn remove_indices(&mut self, indices: Vec<usize>) -> Result<()> {
         let start = indices[0];
         let end = indices.last().unwrap() + 1;
 
-        let new_leaves = (start..end).map(|_| PmTreeHasher::default_leaf());
+        let mut new_leaves: Vec<_> = (start..end)
+            .map(|i| self.tree.get(i))
+            .collect::<Result<_, _>>()?;
+
+        new_leaves
+            .iter_mut()
+            .take(indices.len())
+            .for_each(|leaf| *leaf = PmTreeHasher::default_leaf());
 
         self.tree
             .set_range(start, new_leaves)
@@ -282,13 +286,16 @@ impl PmTree {
         &mut self,
         start: usize,
         leaves: Vec<FrOfPmTreeHasher>,
-        indices: &[usize],
+        indices: Vec<usize>,
     ) -> Result<()> {
         let min_index = *indices.first().unwrap();
         let max_index = start + leaves.len();
 
+        // Generated a placeholder with the exact size needed,
+        // Initiated with default values to be overridden throughout the method
         let mut set_values = vec![PmTreeHasher::default_leaf(); max_index - min_index];
 
+        // If the index is not in indices list, keep the original value
         for i in min_index..start {
             if !indices.contains(&i) {
                 let value = self.tree.get(i)?;
@@ -296,6 +303,7 @@ impl PmTree {
             }
         }
 
+        // Insert new leaves after 'start' position
         for (i, &leaf) in leaves.iter().enumerate() {
             set_values[start - min_index + i] = leaf;
         }

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,
         })
     }
@@ -406,10 +366,6 @@ impl RLN<'_> {
         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`.
@@ -720,9 +676,9 @@ impl RLN<'_> {
         mut output_data: W,
     ) -> Result<()> {
         // We read input RLN witness and we serialize_compressed it
-        let mut input_byte: Vec<u8> = Vec::new();
-        input_data.read_to_end(&mut input_byte)?;
-        let (rln_witness, _) = proof_inputs_to_rln_witness(&mut self.tree, &input_byte)?;
+        let mut witness_byte: Vec<u8> = Vec::new();
+        input_data.read_to_end(&mut witness_byte)?;
+        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)?;
@@ -735,33 +691,12 @@ impl RLN<'_> {
         Ok(())
     }
 
+    // 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> | epoch<32> | share_x<32> | share_y<32> | nullifier<32> | rln_identifier<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(())
-    }
-
-    // Different in wasm since witness_calculator is not available
-    // See: https://github.com/vacp2p/zerokit/blob/b903d8d740e0b8b82057bcc5377ddce05ae5676b/rln/src/public.rs#L47-L49
-    #[cfg(target_arch = "wasm32")]
+    #[doc(hidden)]
     pub fn generate_rln_proof_with_witness<W: Write>(
         &mut self,
         calculated_witness: Vec<BigInt>,
@@ -1821,10 +1756,13 @@ mod test {
             .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> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ]
         let mut proof_data = output_buffer.into_inner();
@@ -2108,19 +2046,4 @@ mod test {
 
         assert_eq!(arbitrary_metadata, received_metadata);
     }
-
-    #[test]
-    fn test_empty_metadata() {
-        let tree_height = TEST_TREE_HEIGHT;
-
-        let input_buffer =
-            Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string());
-        let rln = RLN::new(tree_height, 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/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();
@@ -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");
@@ -1209,7 +1203,7 @@ mod test {
     }
 
     #[test]
-    fn test_valid_metadata() {
+    fn test_metadata() {
         // We create a RLN instance
         let tree_height = TEST_TREE_HEIGHT;
 
@@ -1235,25 +1229,4 @@ mod test {
 
         assert_eq!(result_data, seed_bytes.to_vec());
     }
-
-    #[test]
-    fn test_empty_metadata() {
-        // We create a RLN instance
-        let tree_height = TEST_TREE_HEIGHT;
-
-        let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit();
-        let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string();
-        let input_buffer = &Buffer::from(input_config.as_bytes());
-        let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr());
-        assert!(success, "RLN object creation failed");
-        let rln_pointer = unsafe { &mut *rln_pointer.assume_init() };
-
-        let mut output_buffer = MaybeUninit::<Buffer>::uninit();
-        let success = get_metadata(rln_pointer, output_buffer.as_mut_ptr());
-        assert!(success, "get_metadata call failed");
-
-        let output_buffer = unsafe { output_buffer.assume_init() };
-
-        assert_eq!(output_buffer.len, 0);
-    }
 }

utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zerokit_utils"
-version = "0.3.2"
+version = "0.3.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Various utilities for Zerokit"
@@ -15,7 +15,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(