fix(rln-wasm): run tests again

rln-wasm/Cargo.toml

@@ -3,9 +3,6 @@ name = "rln-wasm"
 version = "0.0.13"
 edition = "2021"
 license = "MIT or Apache2"
-autobenches = false
-autotests = false
-autobins = false
 
 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -15,9 +12,12 @@ default = ["console_error_panic_hook"]
 
 [dependencies]
 rln = { path = "../rln", default-features = false, features = ["wasm"] }
-num-bigint = { version = "0.4", default-features = false, features = ["rand", "serde"] }
+num-bigint = { version = "0.4", default-features = false, features = [
+    "rand",
+    "serde",
+] }
 wasmer = { version = "2.3", default-features = false, features = ["js", "std"] }
-web-sys = {version = "0.3", features=["console"]}
+web-sys = { version = "0.3", features = ["console"] }
 getrandom = { version = "0.2.7", default-features = false, features = ["js"] }
 wasm-bindgen = "0.2.63"
 serde-wasm-bindgen = "0.4"

rln-wasm/Makefile.toml

@@ -7,11 +7,7 @@ script = "sed -i.bak 's/rln-wasm/zerokit-rln-wasm/g' pkg/package.json && rm pkg/
 
 [tasks.build]
 clear = true
-dependencies = [
-    "pack-build",
-    "pack-rename",
-    "post-build"
-]
+dependencies = ["pack-build", "pack-rename", "post-build"]
 
 [tasks.post-build]
 command = "wasm-strip"

rln-wasm/src/lib.rs

@@ -270,8 +270,12 @@ pub fn rln_witness_to_json(
     ctx: *mut RLNWrapper,
     serialized_witness: Uint8Array,
 ) -> Result<Object, String> {
-    let inputs = call!(ctx, get_rln_witness_json, &serialized_witness.to_vec()[..])
-        .map_err(|err| err.to_string())?;
+    let inputs = call!(
+        ctx,
+        get_rln_witness_bigint_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))
 }

rln/src/protocol.rs

@@ -739,30 +739,64 @@ where
     a.map_err(serde::de::Error::custom)
 }
 
-/// Converts a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
+/// Converts a JSON value into [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object.
 ///
 /// # Errors
 ///
-/// Returns an error if `message_id` is not within `user_message_limit`.
+/// Returns an error if `rln_witness.message_id` is not within `rln_witness.user_message_limit`.
 pub fn rln_witness_from_json(input_json: serde_json::Value) -> Result<RLNWitnessInput> {
     let rln_witness: RLNWitnessInput = serde_json::from_value(input_json).unwrap();
     message_id_range_check(&rln_witness.message_id, &rln_witness.user_message_limit)?;
 
     Ok(rln_witness)
 }
 
-/// Converts a JSON value into [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object.
+/// Converts a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
 ///
 /// # Errors
 ///
-/// Returns an error if `rln_witness.message_id` is not within `rln_witness.user_message_limit`.
+/// Returns an error if `message_id` is not within `user_message_limit`.
 pub fn rln_witness_to_json(rln_witness: &RLNWitnessInput) -> Result<serde_json::Value> {
     message_id_range_check(&rln_witness.message_id, &rln_witness.user_message_limit)?;
 
     let rln_witness_json = serde_json::to_value(rln_witness)?;
     Ok(rln_witness_json)
 }
 
+/// Converts a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
+/// Before serialisation the data should be translated into big int for further calculation in the witness calculator.
+///
+/// # Errors
+///
+/// Returns an error if `message_id` is not within `user_message_limit`.
+pub fn rln_witness_to_bigint_json(rln_witness: &RLNWitnessInput) -> Result<serde_json::Value> {
+    message_id_range_check(&rln_witness.message_id, &rln_witness.user_message_limit)?;
+
+    let mut path_elements = Vec::new();
+
+    for v in rln_witness.path_elements.iter() {
+        path_elements.push(to_bigint(v)?.to_str_radix(10));
+    }
+
+    let mut identity_path_index = Vec::new();
+    rln_witness
+        .identity_path_index
+        .iter()
+        .for_each(|v| identity_path_index.push(BigInt::from(*v).to_str_radix(10)));
+
+    let inputs = serde_json::json!({
+        "identitySecret": to_bigint(&rln_witness.identity_secret)?.to_str_radix(10),
+        "userMessageLimit": to_bigint(&rln_witness.user_message_limit)?.to_str_radix(10),
+        "messageId": to_bigint(&rln_witness.message_id)?.to_str_radix(10),
+        "pathElements": path_elements,
+        "identityPathIndex": identity_path_index,
+        "x": to_bigint(&rln_witness.x)?.to_str_radix(10),
+        "externalNullifier":  to_bigint(&rln_witness.external_nullifier)?.to_str_radix(10),
+    });
+
+    Ok(inputs)
+}
+
 pub fn message_id_range_check(message_id: &Fr, user_message_limit: &Fr) -> Result<()> {
     if message_id > user_message_limit {
         return Err(color_eyre::Report::msg(

rln/src/public.rs

@@ -60,6 +60,7 @@ impl RLN {
     /// Input parameters are
     /// - `tree_height`: the height of the internal Merkle tree
     /// - `input_data`: include `tree_config` a reader for a string containing a json with the merkle tree configuration
+    ///
     /// Example:
     /// ```
     /// use std::io::Cursor;
@@ -693,7 +694,7 @@ impl RLN {
     ///
     /// Input values are:
     /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values,
-    ///  i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`, where <_> indicates the byte length.
+    ///   i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`, where <_> indicates the byte length.
     ///
     /// The function returns true if the zkSNARK proof is valid with respect to the provided circuit output values, false otherwise.
     ///
@@ -865,7 +866,7 @@ impl RLN {
     ///
     /// Input values are:
     /// - `input_data`: a reader for the serialization of the RLN zkSNARK proof concatenated with a serialization of the circuit output values and the signal information,
-    ///  i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var>]`, where <_> indicates the byte length.
+    ///   i.e. `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var>]`, where <_> indicates the byte length.
     ///
     /// The function returns true if the zkSNARK proof is valid with respect to the provided circuit output values and signal. Returns false otherwise.
     ///
@@ -1175,8 +1176,8 @@ impl RLN {
     ///
     /// Input values are:
     /// - `input_proof_data_1`: a reader for the serialization of a RLN zkSNARK proof concatenated with a serialization of the circuit output values and -optionally- the signal information,
-    /// i.e. either `[proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`
-    /// or `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var> ]` (to maintain compatibility with both output of [`generate_rln_proof`](crate::public::RLN::generate_rln_proof) and input of [`verify_rln_proof`](crate::public::RLN::verify_rln_proof))
+    ///   i.e. either `[proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32>]`
+    ///   or `[ proof<128> | root<32> | external_nullifier<32> | x<32> | y<32> | nullifier<32> | signal_len<8> | signal<var> ]` (to maintain compatibility with both output of [`generate_rln_proof`](crate::public::RLN::generate_rln_proof) and input of [`verify_rln_proof`](crate::public::RLN::verify_rln_proof))
     /// - `input_proof_data_2`: same as `input_proof_data_1`
     ///
     /// Output values are:
@@ -1273,6 +1274,21 @@ impl RLN {
         rln_witness_to_json(&rln_witness)
     }
 
+    /// Converts a byte serialization of a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object to the corresponding JSON serialization.
+    /// Before serialisation the data will be translated into big int for further calculation in the witness calculator.
+    ///
+    /// Input values are:
+    /// - `serialized_witness`: the byte serialization of a [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object (serialization done with  [`rln::protocol::serialize_witness`](crate::protocol::serialize_witness)).
+    ///
+    /// The function returns the corresponding JSON encoding of the input [`RLNWitnessInput`](crate::protocol::RLNWitnessInput) object.
+    pub fn get_rln_witness_bigint_json(
+        &mut self,
+        serialized_witness: &[u8],
+    ) -> Result<serde_json::Value> {
+        let (rln_witness, _) = deserialize_witness(serialized_witness)?;
+        rln_witness_to_bigint_json(&rln_witness)
+    }
+
     /// Closes the connection to the Merkle tree database.
     /// This function should be called before the RLN object is dropped.
     /// If not called, the connection will be closed when the RLN object is dropped.