feat: expose hash, poseidon_hash and delete_leaf

Co-authored-by: tyshkor <tyshko1@gmail.com>

rln-wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rln-wasm"
-version = "0.0.7"
+version = "0.0.8"
 edition = "2021"
 license = "MIT or Apache2"
 

rln-wasm/src/lib.rs

@@ -7,7 +7,7 @@ use std::vec::Vec;
 
 use js_sys::{BigInt as JsBigInt, Object, Uint8Array};
 use num_bigint::BigInt;
-use rln::public::RLN;
+use rln::public::{hash, poseidon_hash, RLN};
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
@@ -79,6 +79,15 @@ macro_rules! call_with_error_msg {
     }
 }
 
+macro_rules! call {
+    ($instance:expr, $method:ident $(, $arg:expr)*) => {
+        {
+            let new_instance: &mut RLNWrapper = $instance.process();
+            new_instance.instance.$method($($arg.process()),*)
+        }
+    }
+}
+
 macro_rules! call_bool_method_with_error_msg {
     ($instance:expr, $method:ident, $error_msg:expr $(, $arg:expr)*) => {
         {
@@ -88,6 +97,40 @@ macro_rules! call_bool_method_with_error_msg {
     }
 }
 
+// Macro to execute a function with arbitrary amount of arguments,
+// First argument is the function to execute
+// Rest are all other arguments to the method
+macro_rules! fn_call_with_output_and_error_msg {
+    // this variant is needed for the case when
+    // there are zero other arguments
+    ($func:ident, $error_msg:expr) => {
+        {
+            let mut output_data: Vec<u8> = Vec::new();
+            if let Err(err) = $func(&mut output_data) {
+                std::mem::forget(output_data);
+                Err(format!("Msg: {:#?}, Error: {:#?}", $error_msg, err))
+            } else {
+                let result = Uint8Array::from(&output_data[..]);
+                std::mem::forget(output_data);
+                Ok(result)
+            }
+        }
+    };
+    ($func:ident, $error_msg:expr, $( $arg:expr ),* ) => {
+        {
+            let mut output_data: Vec<u8> = Vec::new();
+            if let Err(err) = $func($($arg.process()),*, &mut output_data) {
+                std::mem::forget(output_data);
+                Err(format!("Msg: {:#?}, Error: {:#?}", $error_msg, err))
+            } else {
+                let result = Uint8Array::from(&output_data[..]);
+                std::mem::forget(output_data);
+                Ok(result)
+            }
+        }
+    };
+}
+
 trait ProcessArg {
     type ReturnType;
     fn process(self) -> Self::ReturnType;
@@ -155,12 +198,8 @@ pub fn wasm_get_serialized_rln_witness(
     ctx: *mut RLNWrapper,
     input: Uint8Array,
 ) -> Result<Uint8Array, String> {
-    let wrapper = unsafe { &mut *ctx };
-    let rln_witness = wrapper
-        .instance
-        .get_serialized_rln_witness(&input.to_vec()[..])
+    let rln_witness = call!(ctx, get_serialized_rln_witness, &input.to_vec()[..])
         .map_err(|err| format!("{:#?}", err))?;
-
     Ok(Uint8Array::from(&rln_witness[..]))
 }
 
@@ -191,6 +230,12 @@ pub fn wasm_set_leaves_from(
     )
 }
 
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[wasm_bindgen(js_name = deleteLeaf)]
+pub fn wasm_delete_leaf(ctx: *mut RLNWrapper, index: usize) -> Result<(), String> {
+    call_with_error_msg!(ctx, delete_leaf, "could not delete leaf".to_string(), index)
+}
+
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[wasm_bindgen(js_name = initTreeWithLeaves)]
 pub fn wasm_init_tree_with_leaves(ctx: *mut RLNWrapper, input: Uint8Array) -> Result<(), String> {
@@ -208,12 +253,8 @@ pub fn rln_witness_to_json(
     ctx: *mut RLNWrapper,
     serialized_witness: Uint8Array,
 ) -> Result<Object, String> {
-    let wrapper = unsafe { &mut *ctx };
-    let inputs = wrapper
-        .instance
-        .get_rln_witness_json(&serialized_witness.to_vec()[..])
+    let inputs = call!(ctx, get_rln_witness_json, &serialized_witness.to_vec()[..])
         .map_err(|err| err.to_string())?;
-
     let js_value = serde_wasm_bindgen::to_value(&inputs).map_err(|err| err.to_string())?;
     Object::from_entries(&js_value).map_err(|err| format!("{:#?}", err))
 }
@@ -332,3 +373,17 @@ pub fn wasm_verify_with_roots(
 pub fn wasm_get_root(ctx: *const RLNWrapper) -> Result<Uint8Array, String> {
     call_with_output_and_error_msg!(ctx, get_root, "could not obtain root")
 }
+
+#[wasm_bindgen(js_name = hash)]
+pub fn wasm_hash(input: Uint8Array) -> Result<Uint8Array, String> {
+    fn_call_with_output_and_error_msg!(hash, "could not generate hash", &input.to_vec()[..])
+}
+
+#[wasm_bindgen(js_name = poseidonHash)]
+pub fn wasm_poseidon_hash(input: Uint8Array) -> Result<Uint8Array, String> {
+    fn_call_with_output_and_error_msg!(
+        poseidon_hash,
+        "could not generate poseidon hash",
+        &input.to_vec()[..]
+    )
+}

rln/src/hashers.rs

@@ -1,7 +1,8 @@
 // This crate instantiate the Poseidon hash algorithm
 
-use crate::circuit::Fr;
+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 hardcodes the supported round parameters tuples (t, RF, RN, SKIP_MATRICES) for the Bn254 scalar field
@@ -26,3 +27,17 @@ pub fn poseidon_hash(input: &[Fr]) -> Fr {
         .hash(input.to_vec())
         .expect("hash with fixed input size can't fail")
 }
+
+// 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);
+    hasher.finalize(&mut hash);
+
+    // We export the hash as a field element
+    let (el, _) = bytes_le_to_fr(hash.as_ref());
+    el
+}

rln/src/lib.rs

@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 
 pub mod circuit;
-pub mod poseidon_hash;
+pub mod hashers;
 pub mod poseidon_tree;
 pub mod protocol;
 pub mod public;

rln/src/poseidon_tree.rs

@@ -3,7 +3,7 @@
 // Implementation inspired by https://github.com/worldcoin/semaphore-rs/blob/d462a4372f1fd9c27610f2acfe4841fab1d396aa/src/poseidon_tree.rs (no differences)
 
 use crate::circuit::Fr;
-use crate::poseidon_hash::poseidon_hash;
+use crate::hashers::poseidon_hash;
 use cfg_if::cfg_if;
 use utils::merkle_tree::*;
 

rln/src/protocol.rs

@@ -17,7 +17,8 @@ use thiserror::Error;
 use tiny_keccak::{Hasher as _, Keccak};
 
 use crate::circuit::{Curve, Fr};
-use crate::poseidon_hash::poseidon_hash;
+use crate::hashers::hash_to_field;
+use crate::hashers::poseidon_hash;
 use crate::poseidon_tree::*;
 use crate::public::RLN_IDENTIFIER;
 use crate::utils::*;
@@ -483,20 +484,6 @@ pub fn extended_seeded_keygen(signal: &[u8]) -> (Fr, Fr, Fr, Fr) {
     )
 }
 
-// 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);
-    hasher.finalize(&mut hash);
-
-    // We export the hash as a field element
-    let (el, _) = bytes_le_to_fr(hash.as_ref());
-    el
-}
-
 pub fn compute_id_secret(
     share1: (Fr, Fr),
     share2: (Fr, Fr),

rln/src/public.rs

@@ -1,5 +1,5 @@
 use crate::circuit::{vk_from_raw, zkey_from_raw, Curve, Fr};
-use crate::poseidon_hash::poseidon_hash as utils_poseidon_hash;
+use crate::hashers::{hash_to_field, poseidon_hash as utils_poseidon_hash};
 use crate::poseidon_tree::PoseidonTree;
 use crate::protocol::*;
 use crate::utils::*;

rln/tests/ffi.rs

@@ -4,7 +4,7 @@ mod test {
     use rand::Rng;
     use rln::circuit::*;
     use rln::ffi::{hash as ffi_hash, poseidon_hash as ffi_poseidon_hash, *};
-    use rln::poseidon_hash::{poseidon_hash as utils_poseidon_hash, ROUND_PARAMS};
+    use rln::hashers::{hash_to_field, poseidon_hash as utils_poseidon_hash, ROUND_PARAMS};
     use rln::protocol::*;
     use rln::public::RLN;
     use rln::utils::*;

rln/tests/poseidon_tree.rs

@@ -88,7 +88,7 @@ mod pmtree_test {
 
     use pmtree::*;
     use rln::circuit::Fr;
-    use rln::poseidon_hash::poseidon_hash;
+    use rln::hashers::{hash_to_field, poseidon_hash};
     use rln::poseidon_tree::PoseidonHash;
     use rln::protocol::hash_to_field;
     use rln::utils::str_to_fr;

rln/tests/protocol.rs

@@ -4,7 +4,7 @@ mod test {
         circom_from_folder, vk_from_folder, zkey_from_folder, Fr, TEST_RESOURCES_FOLDER,
         TEST_TREE_HEIGHT,
     };
-    use rln::poseidon_hash::poseidon_hash;
+    use rln::hashers::{hash_to_field, poseidon_hash};
     use rln::poseidon_tree::PoseidonTree;
     use rln::protocol::*;
     use rln::utils::str_to_fr;

rln/tests/public.rs

@@ -3,8 +3,8 @@ mod test {
     use ark_std::{rand::thread_rng, UniformRand};
     use rand::Rng;
     use rln::circuit::{Fr, TEST_RESOURCES_FOLDER, TEST_TREE_HEIGHT};
-    use rln::poseidon_hash::{poseidon_hash as utils_poseidon_hash, ROUND_PARAMS};
-    use rln::protocol::{compute_tree_root, deserialize_identity_tuple, hash_to_field};
+    use rln::hashers::{hash_to_field, poseidon_hash as utils_poseidon_hash, ROUND_PARAMS};
+    use rln::protocol::{compute_tree_root, deserialize_identity_tuple};
     use rln::public::{hash as public_hash, poseidon_hash as public_poseidon_hash, RLN};
     use rln::utils::*;
     use std::io::Cursor;