test: RLN-WASM bindings error cases (#381)

## Description

A batch of tests to cover negative/invalid input cases for RLN-WASM
bindings.

## Tests added

rln-wasm/tests/node.rs:
- test_wasm_invalid_inputs

rln-wasm/tests/utils.rs:
- test_wasmfr_from_bytes_invalid
- test_vec_wasmfr_from_bytes_invalid
- test_uint8array_utils_from_bytes_invalid
- test_identity_from_bytes_invalid_len
- test_extended_identity_from_bytes_invalid_len

## Other changes
- Add `cargo make fmt` and `cargo make fmt_check` to cover excluded
modules.

## Checklist

- [x] My PR title follows [Conventional
Commits](https://www.conventionalcommits.org/en/v1.0.0/) format
- [x] I have linked the related issue(s)
- [x] `cargo fmt --all -- --check` produces no changes
- [x] Clippy passes for all affected crate/feature combinations (see
[Linting](#linting-mirrors-ci) above)
- [x] `make test` passes locally
- [x] No new `unwrap()` / `expect()` / `panic!()` in library code
- [x] New code includes appropriate tests (unit / integration / WASM
where applicable)
- [x] I have run the CI coverage report — add the `run-coverage` label
to enable it
- [x] All CI checks pass and the PR is marked **Ready for review**

Author: romanzac

Makefile.toml

@@ -1,2 +1,18 @@
 [env]
 CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
+
+[tasks.fmt]
+description = "Format workspace members and excluded crates"
+command = "sh"
+args = [
+  "-c",
+  "cd .. && cargo +nightly fmt --all && cargo +nightly fmt --manifest-path rln-cli/Cargo.toml --all && cargo +nightly fmt --manifest-path rln-wasm/Cargo.toml --all",
+]
+
+[tasks.fmt_check]
+description = "Check formatting for workspace members and excluded crates"
+command = "sh"
+args = [
+  "-c",
+  "cd .. && cargo +nightly fmt --all -- --check && cargo +nightly fmt --manifest-path rln-cli/Cargo.toml --all -- --check && cargo +nightly fmt --manifest-path rln-wasm/Cargo.toml --all -- --check",
+]

rln-wasm/tests/node.rs

@@ -6,7 +6,8 @@ mod test {
     use js_sys::{BigInt as JsBigInt, Date, Object, Uint8Array};
     use rln::prelude::*;
     use rln_wasm::{
-        Hasher, Identity, VecWasmFr, WasmFr, WasmRLN, WasmRLNProof, WasmRLNWitnessInput,
+        Hasher, Identity, VecWasmFr, WasmFr, WasmRLN, WasmRLNProof, WasmRLNProofValues,
+        WasmRLNWitnessInput,
     };
     use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
     use wasm_bindgen_test::{console_log, wasm_bindgen_test};
@@ -72,6 +73,55 @@ mod test {
 
     const CIRCOM_PATH: &str = "../rln/resources/tree_depth_20/rln.wasm";
 
+    fn build_witness_parts() -> (
+        WasmFr,
+        WasmFr,
+        WasmFr,
+        VecWasmFr,
+        Uint8Array,
+        WasmFr,
+        WasmFr,
+    ) {
+        let mut tree: OptimalMerkleTree<PoseidonHash> =
+            OptimalMerkleTree::default(DEFAULT_TREE_DEPTH).unwrap();
+
+        let identity_pair = Identity::generate().unwrap();
+        let identity_secret = identity_pair.get_secret_hash();
+        let id_commitment = identity_pair.get_commitment();
+
+        let epoch = Hasher::hash_to_field_le(&Uint8Array::from(b"test-epoch" as &[u8])).unwrap();
+        let rln_identifier =
+            Hasher::hash_to_field_le(&Uint8Array::from(b"test-rln-identifier" as &[u8])).unwrap();
+        let external_nullifier = Hasher::poseidon_hash_pair(&epoch, &rln_identifier).unwrap();
+
+        let identity_index = tree.leaves_set();
+        let user_message_limit = WasmFr::from_uint(10);
+        let rate_commitment =
+            Hasher::poseidon_hash_pair(&id_commitment, &user_message_limit).unwrap();
+        tree.update_next(*rate_commitment).unwrap();
+
+        let message_id = WasmFr::from_uint(0);
+        let signal: [u8; 32] = [0; 32];
+        let x = Hasher::hash_to_field_le(&Uint8Array::from(&signal[..])).unwrap();
+
+        let merkle_proof: OptimalMerkleProof<PoseidonHash> = tree.proof(identity_index).unwrap();
+        let mut path_elements = VecWasmFr::new();
+        for path_element in merkle_proof.get_path_elements() {
+            path_elements.push(&WasmFr::from(path_element));
+        }
+        let path_index = Uint8Array::from(&merkle_proof.get_path_index()[..]);
+
+        (
+            identity_secret,
+            user_message_limit,
+            message_id,
+            path_elements,
+            path_index,
+            x,
+            external_nullifier,
+        )
+    }
+
     #[wasm_bindgen_test]
     pub async fn rln_wasm_benchmark() {
         // Initialize witness calculator
@@ -230,4 +280,107 @@ mod test {
         // Log the results
         console_log!("{results}");
     }
+
+    #[wasm_bindgen_test]
+    pub fn test_wasm_invalid_inputs() {
+        // Invalid zkey data
+        let invalid_zkey = Uint8Array::from(&[0u8; 16][..]);
+        assert!(WasmRLN::new(&invalid_zkey).is_err());
+
+        let (
+            identity_secret,
+            user_message_limit,
+            message_id,
+            path_elements,
+            path_index,
+            x,
+            external_nullifier,
+        ) = build_witness_parts();
+
+        // Invalid user message limit (zero)
+        let zero_limit = WasmFr::zero();
+        let result = WasmRLNWitnessInput::new(
+            &identity_secret,
+            &zero_limit,
+            &message_id,
+            &path_elements,
+            &path_index,
+            &x,
+            &external_nullifier,
+        );
+        assert!(result.is_err());
+
+        // Invalid message id (>= limit)
+        let invalid_message_id = user_message_limit;
+        let result = WasmRLNWitnessInput::new(
+            &identity_secret,
+            &user_message_limit,
+            &invalid_message_id,
+            &path_elements,
+            &path_index,
+            &x,
+            &external_nullifier,
+        );
+        assert!(result.is_err());
+
+        // Invalid merkle proof length (path elements vs path index)
+        let mut shorter_path_elements = VecWasmFr::new();
+        for i in 0..path_elements.length().saturating_sub(1) {
+            shorter_path_elements.push(&path_elements.get(i).unwrap());
+        }
+        let result = WasmRLNWitnessInput::new(
+            &identity_secret,
+            &user_message_limit,
+            &message_id,
+            &shorter_path_elements,
+            &path_index,
+            &x,
+            &external_nullifier,
+        );
+        assert!(result.is_err());
+
+        // Witness bytes: truncated and extra data
+        let valid_witness = WasmRLNWitnessInput::new(
+            &identity_secret,
+            &user_message_limit,
+            &message_id,
+            &path_elements,
+            &path_index,
+            &x,
+            &external_nullifier,
+        )
+        .unwrap();
+
+        let witness_le = valid_witness.to_bytes_le().unwrap();
+        let witness_le_vec = witness_le.to_vec();
+        let truncated_le = Uint8Array::from(&witness_le_vec[..witness_le_vec.len() - 1]);
+        assert!(WasmRLNWitnessInput::from_bytes_le(&truncated_le).is_err());
+
+        let mut extra_le_vec = witness_le_vec.clone();
+        extra_le_vec.push(0);
+        let extra_le = Uint8Array::from(&extra_le_vec[..]);
+        assert!(WasmRLNWitnessInput::from_bytes_le(&extra_le).is_err());
+
+        let witness_be = valid_witness.to_bytes_be().unwrap();
+        let witness_be_vec = witness_be.to_vec();
+        let truncated_be = Uint8Array::from(&witness_be_vec[..witness_be_vec.len() - 1]);
+        assert!(WasmRLNWitnessInput::from_bytes_be(&truncated_be).is_err());
+
+        let mut extra_be_vec = witness_be_vec.clone();
+        extra_be_vec.push(0);
+        let extra_be = Uint8Array::from(&extra_be_vec[..]);
+        assert!(WasmRLNWitnessInput::from_bytes_be(&extra_be).is_err());
+
+        // Proof values bytes: insufficient length
+        let short_pv = [0u8; FR_BYTE_SIZE * 5 - 1];
+        let short_pv = Uint8Array::from(&short_pv[..]);
+        assert!(WasmRLNProofValues::from_bytes_le(&short_pv).is_err());
+        assert!(WasmRLNProofValues::from_bytes_be(&short_pv).is_err());
+
+        // Proof bytes: insufficient length (no proof values)
+        let short_proof = [0u8; COMPRESS_PROOF_SIZE];
+        let short_proof = Uint8Array::from(&short_proof[..]);
+        assert!(WasmRLNProof::from_bytes_le(&short_proof).is_err());
+        assert!(WasmRLNProof::from_bytes_be(&short_proof).is_err());
+    }
 }

rln-wasm/tests/utils.rs

@@ -8,7 +8,9 @@ mod test {
     use js_sys::Uint8Array;
     use rand::Rng;
     use rln::prelude::*;
-    use rln_wasm::{ExtendedIdentity, Hasher, Identity, VecWasmFr, WasmFr};
+    use rln_wasm::{
+        wasm_utils::Uint8ArrayUtils, ExtendedIdentity, Hasher, Identity, VecWasmFr, WasmFr,
+    };
     use wasm_bindgen_test::wasm_bindgen_test;
 
     #[wasm_bindgen_test]
@@ -219,4 +221,94 @@ mod test {
 
         assert_eq!(*received_hash, expected_hash);
     }
+
+    #[wasm_bindgen_test]
+    fn test_wasmfr_from_bytes_invalid() {
+        let short_bytes = [0u8; FR_BYTE_SIZE - 1];
+        let short = Uint8Array::from(&short_bytes[..]);
+        assert!(WasmFr::from_bytes_le(&short).is_err());
+        assert!(WasmFr::from_bytes_be(&short).is_err());
+
+        let empty = Uint8Array::from(&[][..]);
+        assert!(WasmFr::from_bytes_le(&empty).is_err());
+        assert!(WasmFr::from_bytes_be(&empty).is_err());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_vec_wasmfr_from_bytes_invalid() {
+        let vec_fr = vec![Fr::from(1u8)];
+        let bytes_le = vec_fr_to_bytes_le(&vec_fr);
+        let truncated = Uint8Array::from(&bytes_le[..bytes_le.len() - 1]);
+        assert!(VecWasmFr::from_bytes_le(&truncated).is_err());
+
+        let mut wrong_len = bytes_le.clone();
+        wrong_len[..8].copy_from_slice(&normalize_usize_le(2));
+        let wrong_len = Uint8Array::from(&wrong_len[..]);
+        assert!(VecWasmFr::from_bytes_le(&wrong_len).is_err());
+
+        let max_safe_len = (usize::MAX - 8) / FR_BYTE_SIZE;
+        let mut overflow_len = [0u8; 8];
+        overflow_len[..8].copy_from_slice(&normalize_usize_le(max_safe_len));
+        let overflow_len = Uint8Array::from(&overflow_len[..]);
+        assert!(VecWasmFr::from_bytes_le(&overflow_len).is_err());
+
+        let bytes_be = vec_fr_to_bytes_be(&vec_fr);
+        let truncated_be = Uint8Array::from(&bytes_be[..bytes_be.len() - 1]);
+        assert!(VecWasmFr::from_bytes_be(&truncated_be).is_err());
+
+        let mut wrong_len_be = bytes_be.clone();
+        wrong_len_be[..8].copy_from_slice(&normalize_usize_be(2));
+        let wrong_len_be = Uint8Array::from(&wrong_len_be[..]);
+        assert!(VecWasmFr::from_bytes_be(&wrong_len_be).is_err());
+
+        let mut overflow_len_be = [0u8; 8];
+        overflow_len_be[..8].copy_from_slice(&normalize_usize_be(max_safe_len));
+        let overflow_len_be = Uint8Array::from(&overflow_len_be[..]);
+        assert!(VecWasmFr::from_bytes_be(&overflow_len_be).is_err());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_uint8array_utils_from_bytes_invalid() {
+        let short = Uint8Array::from(&[0u8; 7][..]);
+        assert!(Uint8ArrayUtils::from_bytes_le(&short).is_err());
+        assert!(Uint8ArrayUtils::from_bytes_be(&short).is_err());
+
+        let invalid_len_le = Vec::from(normalize_usize_le(5));
+        let invalid_len_le = Uint8Array::from(&invalid_len_le[..]);
+        assert!(Uint8ArrayUtils::from_bytes_le(&invalid_len_le).is_err());
+
+        let invalid_len_be = Vec::from(normalize_usize_be(5));
+        let invalid_len_be = Uint8Array::from(&invalid_len_be[..]);
+        assert!(Uint8ArrayUtils::from_bytes_be(&invalid_len_be).is_err());
+
+        let overflow_len_le = Vec::from(normalize_usize_le(usize::MAX - 8));
+        let overflow_len_le = Uint8Array::from(&overflow_len_le[..]);
+        assert!(Uint8ArrayUtils::from_bytes_le(&overflow_len_le).is_err());
+
+        let overflow_len_be = Vec::from(normalize_usize_be(usize::MAX - 8));
+        let overflow_len_be = Uint8Array::from(&overflow_len_be[..]);
+        assert!(Uint8ArrayUtils::from_bytes_be(&overflow_len_be).is_err());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_identity_from_bytes_invalid_len() {
+        let bytes_le = vec_fr_to_bytes_le(&[Fr::from(1u8)]);
+        let bytes_le = Uint8Array::from(&bytes_le[..]);
+        assert!(Identity::from_bytes_le(&bytes_le).is_err());
+
+        let bytes_be = vec_fr_to_bytes_be(&[Fr::from(1u8)]);
+        let bytes_be = Uint8Array::from(&bytes_be[..]);
+        assert!(Identity::from_bytes_be(&bytes_be).is_err());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_extended_identity_from_bytes_invalid_len() {
+        let bytes_le = vec_fr_to_bytes_le(&[Fr::from(1u8), Fr::from(2u8), Fr::from(3u8)]);
+        let bytes_le = Uint8Array::from(&bytes_le[..]);
+        assert!(ExtendedIdentity::from_bytes_le(&bytes_le).is_err());
+
+        let bytes_be = vec_fr_to_bytes_be(&[Fr::from(1u8), Fr::from(2u8), Fr::from(3u8)]);
+        let bytes_be = Uint8Array::from(&bytes_be[..]);
+        assert!(ExtendedIdentity::from_bytes_be(&bytes_be).is_err());
+    }
 }