refactor: removed Result<> from hash_to_field_le/be and all related tests, examples and docs

vinhtc27 · vinhtc27 · commit 65ce63f8a283 · 2026-03-24T14:20:20.000+07:00
diff --git a/rln-cli/src/examples/multi_message_id.rs b/rln-cli/src/examples/multi_message_id.rs
@@ -195,7 +195,7 @@ impl RLNSystem {
         };
 
         let (path_elements, identity_path_index) = self.rln.get_merkle_proof(user_index)?;
-        let x = hash_to_field_le(signal.as_bytes())?;
+        let x = hash_to_field_le(signal.as_bytes());
 
         let witness = RLNWitnessInput::new(
             identity.identity_secret.clone(),
@@ -291,8 +291,8 @@ fn main() -> Result<()> {
     println!("Initializing RLN multi-message-id instance...");
     print!("\x1B[2J\x1B[1;1H");
     let mut rln_system = RLNSystem::new()?;
-    let rln_epoch = hash_to_field_le(b"epoch")?;
-    let rln_identifier = hash_to_field_le(b"rln-identifier")?;
+    let rln_epoch = hash_to_field_le(b"epoch");
+    let rln_identifier = hash_to_field_le(b"rln-identifier");
     let external_nullifier = poseidon_hash(&[rln_epoch, rln_identifier]).unwrap();
     println!("RLN Multi-Message-ID Example:");
     println!("Message Limit: {MESSAGE_LIMIT}");
diff --git a/rln-cli/src/examples/partial.rs b/rln-cli/src/examples/partial.rs
@@ -242,7 +242,7 @@ impl RLNSystem {
             None => return Err(format!("User {user_index} not found").into()),
         };
 
-        let x = hash_to_field_le(signal.as_bytes())?;
+        let x = hash_to_field_le(signal.as_bytes());
         let current_root = self.rln.get_root();
 
         let (witness, partial_proof) = match self.partial_proofs.get(&user_index) {
@@ -366,8 +366,8 @@ impl RLNSystem {
 fn main() -> Result<()> {
     println!("Initializing RLN instance...");
     print!("\x1B[2J\x1B[1;1H");
-    let rln_epoch = hash_to_field_le(b"epoch")?;
-    let rln_identifier = hash_to_field_le(b"rln-identifier")?;
+    let rln_epoch = hash_to_field_le(b"epoch");
+    let rln_identifier = hash_to_field_le(b"rln-identifier");
     let external_nullifier = poseidon_hash(&[rln_epoch, rln_identifier]).unwrap();
     let mut rln_system = RLNSystem::new(external_nullifier)?;
     println!("RLN Partial Proof Example:");
diff --git a/rln-cli/src/examples/relay.rs b/rln-cli/src/examples/relay.rs
@@ -147,7 +147,7 @@ impl RLNSystem {
         };
 
         let (path_elements, identity_path_index) = self.rln.get_merkle_proof(user_index)?;
-        let x = hash_to_field_le(signal.as_bytes())?;
+        let x = hash_to_field_le(signal.as_bytes());
 
         let witness = RLNWitnessInput::new(
             identity.identity_secret.clone(),
@@ -230,8 +230,8 @@ fn main() -> Result<()> {
     println!("Initializing RLN instance...");
     print!("\x1B[2J\x1B[1;1H");
     let mut rln_system = RLNSystem::new()?;
-    let rln_epoch = hash_to_field_le(b"epoch")?;
-    let rln_identifier = hash_to_field_le(b"rln-identifier")?;
+    let rln_epoch = hash_to_field_le(b"epoch");
+    let rln_identifier = hash_to_field_le(b"rln-identifier");
     let external_nullifier = poseidon_hash(&[rln_epoch, rln_identifier]).unwrap();
     println!("RLN Relay Example:");
     println!("Message Limit: {MESSAGE_LIMIT}");
diff --git a/rln-cli/src/examples/stateless.rs b/rln-cli/src/examples/stateless.rs
@@ -126,7 +126,7 @@ impl RLNSystem {
         };
 
         let merkle_proof = self.tree.proof(user_index)?;
-        let x = hash_to_field_le(signal.as_bytes())?;
+        let x = hash_to_field_le(signal.as_bytes());
 
         let witness = RLNWitnessInput::new(
             identity.identity_secret.clone(),
@@ -219,8 +219,8 @@ fn main() -> Result<()> {
     println!("Initializing RLN instance...");
     print!("\x1B[2J\x1B[1;1H");
     let mut rln_system = RLNSystem::new()?;
-    let rln_epoch = hash_to_field_le(b"epoch")?;
-    let rln_identifier = hash_to_field_le(b"rln-identifier")?;
+    let rln_epoch = hash_to_field_le(b"epoch");
+    let rln_identifier = hash_to_field_le(b"rln-identifier");
     let external_nullifier = poseidon_hash(&[rln_epoch, rln_identifier]).unwrap();
     println!("RLN Stateless Example:");
     println!("Message Limit: {MESSAGE_LIMIT}");
diff --git a/rln-wasm/src/wasm_utils.rs b/rln-wasm/src/wasm_utils.rs
@@ -200,17 +200,13 @@ pub struct Hasher;
 #[wasm_bindgen]
 impl Hasher {
     #[wasm_bindgen(js_name = hashToFieldLE)]
-    pub fn hash_to_field_le(input: &Uint8Array) -> Result<WasmFr, String> {
-        hash_to_field_le(&input.to_vec())
-            .map(WasmFr)
-            .map_err(|err| err.to_string())
+    pub fn hash_to_field_le(input: &Uint8Array) -> WasmFr {
+        WasmFr(hash_to_field_le(&input.to_vec()))
     }
 
     #[wasm_bindgen(js_name = hashToFieldBE)]
-    pub fn hash_to_field_be(input: &Uint8Array) -> Result<WasmFr, String> {
-        hash_to_field_be(&input.to_vec())
-            .map(WasmFr)
-            .map_err(|err| err.to_string())
+    pub fn hash_to_field_be(input: &Uint8Array) -> WasmFr {
+        WasmFr(hash_to_field_be(&input.to_vec()))
     }
 
     #[wasm_bindgen(js_name = poseidonHashPair)]
diff --git a/rln-wasm/tests/browser.rs b/rln-wasm/tests/browser.rs
@@ -131,9 +131,9 @@ mod test {
         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 epoch = Hasher::hash_to_field_le(&Uint8Array::from(b"test-epoch" as &[u8]));
         let rln_identifier =
-            Hasher::hash_to_field_le(&Uint8Array::from(b"test-rln-identifier" as &[u8])).unwrap();
+            Hasher::hash_to_field_le(&Uint8Array::from(b"test-rln-identifier" as &[u8]));
         let external_nullifier = Hasher::poseidon_hash_pair(&epoch, &rln_identifier).unwrap();
 
         let identity_index = tree.leaves_set();
@@ -147,7 +147,7 @@ mod test {
         #[cfg(not(feature = "multi-message-id"))]
         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 x = Hasher::hash_to_field_le(&Uint8Array::from(&signal[..]));
 
         let merkle_proof: OptimalMerkleProof<PoseidonHash> = tree.proof(identity_index).unwrap();
 
diff --git a/rln-wasm/tests/node.rs b/rln-wasm/tests/node.rs
@@ -90,9 +90,9 @@ mod test {
         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 epoch = Hasher::hash_to_field_le(&Uint8Array::from(b"test-epoch" as &[u8]));
         let rln_identifier =
-            Hasher::hash_to_field_le(&Uint8Array::from(b"test-rln-identifier" as &[u8])).unwrap();
+            Hasher::hash_to_field_le(&Uint8Array::from(b"test-rln-identifier" as &[u8]));
         let external_nullifier = Hasher::poseidon_hash_pair(&epoch, &rln_identifier).unwrap();
 
         let identity_index = tree.leaves_set();
@@ -103,7 +103,7 @@ mod test {
 
         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 x = Hasher::hash_to_field_le(&Uint8Array::from(&signal[..]));
 
         let merkle_proof: OptimalMerkleProof<PoseidonHash> = tree.proof(identity_index).unwrap();
         let mut path_elements = VecWasmFr::new();
@@ -157,9 +157,9 @@ mod test {
         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 epoch = Hasher::hash_to_field_le(&Uint8Array::from(b"test-epoch" as &[u8]));
         let rln_identifier =
-            Hasher::hash_to_field_le(&Uint8Array::from(b"test-rln-identifier" as &[u8])).unwrap();
+            Hasher::hash_to_field_le(&Uint8Array::from(b"test-rln-identifier" as &[u8]));
         let external_nullifier = Hasher::poseidon_hash_pair(&epoch, &rln_identifier).unwrap();
 
         let identity_index = tree.leaves_set();
@@ -172,7 +172,7 @@ mod test {
 
         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 x = Hasher::hash_to_field_le(&Uint8Array::from(&signal[..]));
 
         let merkle_proof: OptimalMerkleProof<PoseidonHash> = tree.proof(identity_index).unwrap();
 
diff --git a/rln-wasm/tests/utils.rs b/rln-wasm/tests/utils.rs
@@ -186,12 +186,12 @@ mod test {
         let signal_gen: [u8; 32] = rng.gen();
         let signal = Uint8Array::from(&signal_gen[..]);
 
-        let wasmfr_le_1 = Hasher::hash_to_field_le(&signal).unwrap();
-        let fr_le_2 = hash_to_field_le(&signal_gen).unwrap();
+        let wasmfr_le_1 = Hasher::hash_to_field_le(&signal);
+        let fr_le_2 = hash_to_field_le(&signal_gen);
         assert_eq!(*wasmfr_le_1, fr_le_2);
 
-        let wasmfr_be_1 = Hasher::hash_to_field_be(&signal).unwrap();
-        let fr_be_2 = hash_to_field_be(&signal_gen).unwrap();
+        let wasmfr_be_1 = Hasher::hash_to_field_be(&signal);
+        let fr_be_2 = hash_to_field_be(&signal_gen);
         assert_eq!(*wasmfr_be_1, fr_be_2);
 
         assert_eq!(*wasmfr_le_1, *wasmfr_be_1);
diff --git a/rln/README.md b/rln/README.md
@@ -61,10 +61,10 @@ fn main() {
     // 5. Set up external nullifier (epoch + app identifier)
     // We generate epoch from a date seed and we ensure is
     // mapped to a field element by hashing-to-field its content
-    let epoch = hash_to_field_le(b"Today at noon, this year").unwrap();
+    let epoch = hash_to_field_le(b"Today at noon, this year");
     // We generate rln_identifier from an application identifier and
     // we ensure is mapped to a field element by hashing-to-field its content
-    let rln_identifier = hash_to_field_le(b"test-rln-identifier").unwrap();
+    let rln_identifier = hash_to_field_le(b"test-rln-identifier");
     // We generate a external nullifier
     let external_nullifier = poseidon_hash(&[epoch, rln_identifier]).unwrap();
     // We choose a message_id satisfy 0 <= message_id < user_message_limit
@@ -74,7 +74,7 @@ fn main() {
     let signal = b"RLN is awesome";
 
     // 7. Compute x from the signal
-    let x = hash_to_field_le(signal).unwrap();
+    let x = hash_to_field_le(signal);
 
     // 8. Create witness input for RLN proof generation
     let witness = RLNWitnessInput::new(
diff --git a/rln/benches/partial_proof.rs b/rln/benches/partial_proof.rs
@@ -24,11 +24,11 @@ fn get_test_witness() -> RLNWitnessInput {
     let merkle_proof = tree.proof(leaf_index).unwrap();
 
     let signal = b"hey hey";
-    let x = hash_to_field_le(signal).unwrap();
+    let x = hash_to_field_le(signal);
 
     // We set the remaining values to random ones
-    let epoch = hash_to_field_le(b"test-epoch").unwrap();
-    let rln_identifier = hash_to_field_le(b"test-rln-identifier").unwrap();
+    let epoch = hash_to_field_le(b"test-epoch");
+    let rln_identifier = hash_to_field_le(b"test-rln-identifier");
     let external_nullifier = poseidon_hash(&[epoch, rln_identifier]).unwrap();
 
     let message_id = Fr::from(1);
diff --git a/rln/ffi_c_examples/main.c b/rln/ffi_c_examples/main.c
@@ -330,14 +330,7 @@ int main(int argc, char const *const argv[])
     printf("\nHashing signal\n");
     uint8_t signal[32] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     Vec_uint8_t signal_vec = {signal, 32, 32};
-    CResult_CFr_ptr_Vec_uint8_t x_result = ffi_hash_to_field_le(&signal_vec);
-    if (!x_result.ok)
-    {
-        fprintf(stderr, "Hash signal error: %s\n", x_result.err.ptr);
-        ffi_c_string_free(x_result.err);
-        return EXIT_FAILURE;
-    }
-    CFr_t *x = x_result.ok;
+    CFr_t *x = ffi_hash_to_field_le(&signal_vec);
 
     debug = ffi_cfr_debug(x);
     printf("  - x = %s\n", debug.ptr);
@@ -346,14 +339,7 @@ int main(int argc, char const *const argv[])
     printf("\nHashing epoch\n");
     const char *epoch_str = "test-epoch";
     Vec_uint8_t epoch_vec = {(uint8_t *)epoch_str, strlen(epoch_str), strlen(epoch_str)};
-    CResult_CFr_ptr_Vec_uint8_t epoch_result = ffi_hash_to_field_le(&epoch_vec);
-    if (!epoch_result.ok)
-    {
-        fprintf(stderr, "Hash epoch error: %s\n", epoch_result.err.ptr);
-        ffi_c_string_free(epoch_result.err);
-        return EXIT_FAILURE;
-    }
-    CFr_t *epoch = epoch_result.ok;
+    CFr_t *epoch = ffi_hash_to_field_le(&epoch_vec);
 
     debug = ffi_cfr_debug(epoch);
     printf("  - epoch = %s\n", debug.ptr);
@@ -362,14 +348,7 @@ int main(int argc, char const *const argv[])
     printf("\nHashing RLN identifier\n");
     const char *rln_id_str = "test-rln-identifier";
     Vec_uint8_t rln_id_vec = {(uint8_t *)rln_id_str, strlen(rln_id_str), strlen(rln_id_str)};
-    CResult_CFr_ptr_Vec_uint8_t rln_identifier_result = ffi_hash_to_field_le(&rln_id_vec);
-    if (!rln_identifier_result.ok)
-    {
-        fprintf(stderr, "Hash RLN identifier error: %s\n", rln_identifier_result.err.ptr);
-        ffi_c_string_free(rln_identifier_result.err);
-        return EXIT_FAILURE;
-    }
-    CFr_t *rln_identifier = rln_identifier_result.ok;
+    CFr_t *rln_identifier = ffi_hash_to_field_le(&rln_id_vec);
 
     debug = ffi_cfr_debug(rln_identifier);
     printf("  - rln_identifier = %s\n", debug.ptr);
@@ -887,14 +866,7 @@ int main(int argc, char const *const argv[])
     printf("\nHashing second signal\n");
     uint8_t signal2[32] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
     Vec_uint8_t signal2_vec = {signal2, 32, 32};
-    CResult_CFr_ptr_Vec_uint8_t x2_result = ffi_hash_to_field_le(&signal2_vec);
-    if (!x2_result.ok)
-    {
-        fprintf(stderr, "Hash second signal error: %s\n", x2_result.err.ptr);
-        ffi_c_string_free(x2_result.err);
-        return EXIT_FAILURE;
-    }
-    CFr_t *x2 = x2_result.ok;
+    CFr_t *x2 = ffi_hash_to_field_le(&signal2_vec);
 
     debug = ffi_cfr_debug(x2);
     printf("  - x2 = %s\n", debug.ptr);
diff --git a/rln/ffi_nim_examples/main.nim b/rln/ffi_nim_examples/main.nim
@@ -159,9 +159,9 @@ proc ffi_vec_u8_free*(v: Vec_uint8) {.importc: "ffi_vec_u8_free", cdecl,
     dynlib: RLN_LIB.}
 
 # Hashing functions
-proc ffi_hash_to_field_le*(input: ptr Vec_uint8): CResultCFrPtrVecU8 {.importc: "ffi_hash_to_field_le",
+proc ffi_hash_to_field_le*(input: ptr Vec_uint8): ptr CFr {.importc: "ffi_hash_to_field_le",
     cdecl, dynlib: RLN_LIB.}
-proc ffi_hash_to_field_be*(input: ptr Vec_uint8): CResultCFrPtrVecU8 {.importc: "ffi_hash_to_field_be",
+proc ffi_hash_to_field_be*(input: ptr Vec_uint8): ptr CFr {.importc: "ffi_hash_to_field_be",
     cdecl, dynlib: RLN_LIB.}
 proc ffi_poseidon_hash_pair*(a: ptr CFr,
     b: ptr CFr): CResultCFrPtrVecU8 {.importc: "ffi_poseidon_hash_pair", cdecl,
@@ -746,12 +746,7 @@ when isMainModule:
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
   var signalVec = Vec_uint8(dataPtr: cast[ptr uint8](addr signal[0]),
       len: CSize(signal.len), cap: CSize(signal.len))
-  let xResult = ffi_hash_to_field_be(addr signalVec)
-  if xResult.ok.isNil:
-    stderr.writeLine "Hash signal error: ", asString(xResult.err)
-    ffi_c_string_free(xResult.err)
-    quit 1
-  let x = xResult.ok
+  let x = ffi_hash_to_field_be(addr signalVec)
 
   block:
     let debug = ffi_cfr_debug(x)
@@ -763,12 +758,7 @@ when isMainModule:
   var epochBytes = newSeq[uint8](epochStr.len)
   for i in 0..<epochStr.len: epochBytes[i] = uint8(epochStr[i])
   var epochVec = asVecU8(epochBytes)
-  let epochResult = ffi_hash_to_field_be(addr epochVec)
-  if epochResult.ok.isNil:
-    stderr.writeLine "Hash epoch error: ", asString(epochResult.err)
-    ffi_c_string_free(epochResult.err)
-    quit 1
-  let epoch = epochResult.ok
+  let epoch = ffi_hash_to_field_be(addr epochVec)
 
   block:
     let debug = ffi_cfr_debug(epoch)
@@ -780,13 +770,7 @@ when isMainModule:
   var rlnIdBytes = newSeq[uint8](rlnIdStr.len)
   for i in 0..<rlnIdStr.len: rlnIdBytes[i] = uint8(rlnIdStr[i])
   var rlnIdVec = asVecU8(rlnIdBytes)
-  let rlnIdentifierResult = ffi_hash_to_field_be(addr rlnIdVec)
-  if rlnIdentifierResult.ok.isNil:
-    stderr.writeLine "Hash RLN identifier error: ", asString(
-        rlnIdentifierResult.err)
-    ffi_c_string_free(rlnIdentifierResult.err)
-    quit 1
-  let rlnIdentifier = rlnIdentifierResult.ok
+  let rlnIdentifier = ffi_hash_to_field_be(addr rlnIdVec)
 
   block:
     let debug = ffi_cfr_debug(rlnIdentifier)
@@ -1254,12 +1238,7 @@ when isMainModule:
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
   var signal2Vec = Vec_uint8(dataPtr: cast[ptr uint8](addr signal2[0]),
       len: CSize(signal2.len), cap: CSize(signal2.len))
-  let x2Result = ffi_hash_to_field_be(addr signal2Vec)
-  if x2Result.ok.isNil:
-    stderr.writeLine "Hash second signal error: ", asString(x2Result.err)
-    ffi_c_string_free(x2Result.err)
-    quit 1
-  let x2 = x2Result.ok
+  let x2 = ffi_hash_to_field_be(addr signal2Vec)
 
   block:
     let debug = ffi_cfr_debug(x2)
diff --git a/rln/src/ffi/ffi_utils.rs b/rln/src/ffi/ffi_utils.rs
@@ -286,31 +286,13 @@ pub fn ffi_vec_u8_free(v: repr_c::Vec<u8>) {
 // Utility APIs
 
 #[ffi_export]
-pub fn ffi_hash_to_field_le(input: &repr_c::Vec<u8>) -> CResult<repr_c::Box<CFr>, repr_c::String> {
-    match hash_to_field_le(input) {
-        Ok(hash_result) => CResult {
-            ok: Some(CFr::from(hash_result).into()),
-            err: None,
-        },
-        Err(err) => CResult {
-            ok: None,
-            err: Some(format!("{:?}", err).into()),
-        },
-    }
+pub fn ffi_hash_to_field_le(input: &repr_c::Vec<u8>) -> repr_c::Box<CFr> {
+    CFr::from(hash_to_field_le(input)).into()
 }
 
 #[ffi_export]
-pub fn ffi_hash_to_field_be(input: &repr_c::Vec<u8>) -> CResult<repr_c::Box<CFr>, repr_c::String> {
-    match hash_to_field_be(input) {
-        Ok(hash_result) => CResult {
-            ok: Some(CFr::from(hash_result).into()),
-            err: None,
-        },
-        Err(err) => CResult {
-            ok: None,
-            err: Some(format!("{:?}", err).into()),
-        },
-    }
+pub fn ffi_hash_to_field_be(input: &repr_c::Vec<u8>) -> repr_c::Box<CFr> {
+    CFr::from(hash_to_field_be(input)).into()
 }
 
 #[ffi_export]
diff --git a/rln/src/hashers.rs b/rln/src/hashers.rs
diff --git a/rln/tests/ffi.rs b/rln/tests/ffi.rs
diff --git a/rln/tests/ffi_utils.rs b/rln/tests/ffi_utils.rs
diff --git a/rln/tests/protocol.rs b/rln/tests/protocol.rs
diff --git a/rln/tests/public.rs b/rln/tests/public.rs
