feat: add verify_with_signal function and update related verification calls

vinhtc27 · vinhtc27 · commit 3e9bfe5dbf05 · 2026-06-13T19:26:50.000+07:00
diff --git a/rln-wasm/src/wasm_rln.rs b/rln-wasm/src/wasm_rln.rs
@@ -42,6 +42,13 @@ impl WasmRLN {
             .map_err(|err| err.to_string())
     }
 
+    #[wasm_bindgen(js_name = verifyWithSignal)]
+    pub fn verify_with_signal(&self, rln_proof: &WasmRLNProof, x: &WasmFr) -> Result<bool, String> {
+        self.0
+            .verify_with_signal(&rln_proof.0.proof, &rln_proof.0.values, x)
+            .map_err(|err| err.to_string())
+    }
+
     #[wasm_bindgen(js_name = verifyWithRoots)]
     pub fn verify_with_roots(
         &self,
diff --git a/rln/ffi_c_examples/basic_proof.c b/rln/ffi_c_examples/basic_proof.c
@@ -88,7 +88,7 @@ int main(void)
     ffi_cfr_free(proof_values_external_nullifier);
 
     printf("\nVerifying proof\n");
-    CBoolResult verify_result = ffi_rln_verify(&rln_instance, &rln_proof, x);
+    CBoolResult verify_result = verify_stateful_proof(&rln_instance, &rln_proof, x);
     if (verify_result.err.ptr)
     {
         fprintf(stderr, "Proof verification error: %s\n", verify_result.err.ptr);
diff --git a/rln/ffi_c_examples/common.c b/rln/ffi_c_examples/common.c
@@ -255,3 +255,14 @@ create_witness(const Member *member, const MerkleProof *merkle_proof,
                                                &merkle_proof->path_index, x,
                                                external_nullifier);
 }
+
+CBoolResult
+verify_stateful_proof(RLN **rln_instance, Proof **rln_proof, const CFr *x)
+{
+    CFr *root = ffi_rln_get_root(rln_instance);
+    Vec_CFr roots = ffi_vec_cfr_from_cfr(root);
+    CBoolResult result = ffi_rln_verify_with_roots(rln_instance, rln_proof, &roots, x);
+    ffi_vec_cfr_free(roots);
+    ffi_cfr_free(root);
+    return result;
+}
diff --git a/rln/ffi_c_examples/multi_message_id.c b/rln/ffi_c_examples/multi_message_id.c
@@ -116,7 +116,7 @@ int main(void)
     ffi_cfr_free(proof_values1_external_nullifier);
 
     printf("\nVerifying first proof\n");
-    CBoolResult verify1_result = ffi_rln_verify(&rln_instance, &rln_proof1, x1);
+    CBoolResult verify1_result = verify_stateful_proof(&rln_instance, &rln_proof1, x1);
     if (verify1_result.err.ptr)
     {
         fprintf(stderr, "Proof verification error: %s\n", verify1_result.err.ptr);
@@ -175,7 +175,7 @@ int main(void)
     printf("  - second proof generated successfully\n");
 
     printf("\nVerifying second proof\n");
-    CBoolResult verify2_result = ffi_rln_verify(&rln_instance, &rln_proof2, x2);
+    CBoolResult verify2_result = verify_stateful_proof(&rln_instance, &rln_proof2, x2);
     if (verify2_result.err.ptr)
     {
         fprintf(stderr, "Proof verification error: %s\n", verify2_result.err.ptr);
diff --git a/rln/ffi_c_examples/partial_proof.c b/rln/ffi_c_examples/partial_proof.c
@@ -90,7 +90,7 @@ int main(void)
     printf("  - partial proof finished successfully\n");
 
     printf("\nVerifying full proof\n");
-    CBoolResult verify_full_result = ffi_rln_verify(&rln_instance, &full_proof, x);
+    CBoolResult verify_full_result = verify_stateful_proof(&rln_instance, &full_proof, x);
     if (verify_full_result.err.ptr)
     {
         fprintf(stderr, "Full proof verification error: %s\n", verify_full_result.err.ptr);
diff --git a/rln/ffi_c_examples/recover_secret.c b/rln/ffi_c_examples/recover_secret.c
@@ -58,7 +58,7 @@ int main(void)
     printf("  - first proof generated successfully\n");
 
     printf("\nVerifying first proof\n");
-    CBoolResult verify1_result = ffi_rln_verify(&rln_instance, &rln_proof1, x1);
+    CBoolResult verify1_result = verify_stateful_proof(&rln_instance, &rln_proof1, x1);
     if (verify1_result.err.ptr)
     {
         fprintf(stderr, "Proof verification error: %s\n", verify1_result.err.ptr);
@@ -113,7 +113,7 @@ int main(void)
     printf("  - second proof generated successfully\n");
 
     printf("\nVerifying second proof\n");
-    CBoolResult verify2_result = ffi_rln_verify(&rln_instance, &rln_proof2, x2);
+    CBoolResult verify2_result = verify_stateful_proof(&rln_instance, &rln_proof2, x2);
     if (verify2_result.err.ptr)
     {
         fprintf(stderr, "Proof verification error: %s\n", verify2_result.err.ptr);
diff --git a/rln/ffi_c_examples/type_serialization.c b/rln/ffi_c_examples/type_serialization.c
@@ -99,7 +99,7 @@ int main(void)
     printf("  - proof deserialized successfully\n");
 
     printf("\nVerifying the deserialized proof\n");
-    CBoolResult verify_result = ffi_rln_verify(&rln_instance, &deser_proof, x);
+    CBoolResult verify_result = verify_stateful_proof(&rln_instance, &deser_proof, x);
     if (verify_result.err.ptr)
     {
         fprintf(stderr, "Proof verification error: %s\n", verify_result.err.ptr);
diff --git a/rln/ffi_nim_examples/basic_proof.nim b/rln/ffi_nim_examples/basic_proof.nim
@@ -70,7 +70,7 @@ proc main() =
   ffi_cfr_free(proofValuesExternalNullifier)
 
   echo "\nVerifying proof"
-  let verifyResult = ffi_rln_verify(addr rlnInstance, addr rlnProof, x)
+  let verifyResult = verifyStatefulProof(rlnInstance, rlnProof, x)
   if verifyResult.err.dataPtr != nil:
     stderr.writeLine("Proof verification error: " & asString(verifyResult.err))
     ffi_c_string_free(verifyResult.err)
diff --git a/rln/ffi_nim_examples/common.nim b/rln/ffi_nim_examples/common.nim
@@ -150,3 +150,11 @@ proc createWitness(member: Member,
   ffi_rln_witness_input_new_single(member.identitySecret,
       member.userMessageLimit, messageId, addr merkleProof.path_elements,
       addr merkleProof.path_index, x, externalNullifier)
+
+proc verifyStatefulProof(rlnInstance: var ptr RLN, rlnProof: var ptr Proof,
+    x: ptr CFr): CBoolResult =
+  let root = ffi_rln_get_root(addr rlnInstance)
+  var roots = ffi_vec_cfr_from_cfr(root)
+  result = ffi_rln_verify_with_roots(addr rlnInstance, addr rlnProof, addr roots, x)
+  ffi_vec_cfr_free(roots)
+  ffi_cfr_free(root)
diff --git a/rln/ffi_nim_examples/multi_message_id.nim b/rln/ffi_nim_examples/multi_message_id.nim
@@ -92,7 +92,7 @@ proc main() =
   ffi_cfr_free(proofValues1ExternalNullifier)
 
   echo "\nVerifying first proof"
-  let verify1Result = ffi_rln_verify(addr rlnInstance, addr rlnProof1, x1)
+  let verify1Result = verifyStatefulProof(rlnInstance, rlnProof1, x1)
   if verify1Result.err.dataPtr != nil:
     stderr.writeLine("Proof verification error: " & asString(verify1Result.err))
     ffi_c_string_free(verify1Result.err)
@@ -141,7 +141,7 @@ proc main() =
   echo "  - second proof generated successfully"
 
   echo "\nVerifying second proof"
-  let verify2Result = ffi_rln_verify(addr rlnInstance, addr rlnProof2, x2)
+  let verify2Result = verifyStatefulProof(rlnInstance, rlnProof2, x2)
   if verify2Result.err.dataPtr != nil:
     stderr.writeLine("Proof verification error: " & asString(verify2Result.err))
     ffi_c_string_free(verify2Result.err)
diff --git a/rln/ffi_nim_examples/partial_proof.nim b/rln/ffi_nim_examples/partial_proof.nim
@@ -75,7 +75,7 @@ proc main() =
   echo "  - partial proof finished successfully"
 
   echo "\nVerifying full proof"
-  let verifyFullResult = ffi_rln_verify(addr rlnInstance, addr fullProof, x)
+  let verifyFullResult = verifyStatefulProof(rlnInstance, fullProof, x)
   if verifyFullResult.err.dataPtr != nil:
     stderr.writeLine("Full proof verification error: " & asString(
         verifyFullResult.err))
diff --git a/rln/ffi_nim_examples/recover_secret.nim b/rln/ffi_nim_examples/recover_secret.nim
@@ -45,7 +45,7 @@ proc main() =
   echo "  - first proof generated successfully"
 
   echo "\nVerifying first proof"
-  let verify1Result = ffi_rln_verify(addr rlnInstance, addr rlnProof1, x1)
+  let verify1Result = verifyStatefulProof(rlnInstance, rlnProof1, x1)
   if verify1Result.err.dataPtr != nil:
     stderr.writeLine("Proof verification error: " & asString(verify1Result.err))
     ffi_c_string_free(verify1Result.err)
@@ -91,7 +91,7 @@ proc main() =
   echo "  - second proof generated successfully"
 
   echo "\nVerifying second proof"
-  let verify2Result = ffi_rln_verify(addr rlnInstance, addr rlnProof2, x2)
+  let verify2Result = verifyStatefulProof(rlnInstance, rlnProof2, x2)
   if verify2Result.err.dataPtr != nil:
     stderr.writeLine("Proof verification error: " & asString(verify2Result.err))
     ffi_c_string_free(verify2Result.err)
diff --git a/rln/ffi_nim_examples/rln.nim b/rln/ffi_nim_examples/rln.nim
@@ -208,8 +208,11 @@ proc ffi_rln_generate_proof*(rln: ptr ptr RLN,
     witness: ptr ptr Witness): ProofResult {.importc: "ffi_rln_generate_proof",
     cdecl, dynlib: RLN_LIB.}
 proc ffi_rln_verify*(rln: ptr ptr RLN,
+    proof: ptr ptr Proof): CBoolResult {.importc: "ffi_rln_verify",
+    cdecl, dynlib: RLN_LIB.}
+proc ffi_rln_verify_with_signal*(rln: ptr ptr RLN,
     proof: ptr ptr Proof,
-    x: ptr CFr): CBoolResult {.importc: "ffi_rln_verify",
+    x: ptr CFr): CBoolResult {.importc: "ffi_rln_verify_with_signal",
     cdecl, dynlib: RLN_LIB.}
 proc ffi_rln_verify_with_roots*(rln: ptr ptr RLN,
     proof: ptr ptr Proof,
diff --git a/rln/ffi_nim_examples/type_serialization.nim b/rln/ffi_nim_examples/type_serialization.nim
@@ -80,7 +80,7 @@ proc main() =
   echo "  - proof deserialized successfully"
 
   echo "\nVerifying the deserialized proof"
-  let verifyResult = ffi_rln_verify(addr rlnInstance, addr deserProof, x)
+  let verifyResult = verifyStatefulProof(rlnInstance, deserProof, x)
   if verifyResult.err.dataPtr != nil:
     stderr.writeLine("Proof verification error: " & asString(verifyResult.err))
     ffi_c_string_free(verifyResult.err)
diff --git a/rln/src/ffi/ffi_rln.rs b/rln/src/ffi/ffi_rln.rs
@@ -52,6 +52,28 @@ impl FFI_RLN_Inner {
         }
     }
 
+    fn verify_with_signal(
+        &self,
+        proof: &Proof,
+        values: &RLNProofValues,
+        x: &Fr,
+    ) -> Result<bool, String> {
+        match self {
+            Self::Stateless(r) => r
+                .verify_with_signal(proof, values, x)
+                .map_err(|err| err.to_string()),
+            Self::StatefulFullMerkleTree(r) => r
+                .verify_with_signal(proof, values, x)
+                .map_err(|err| err.to_string()),
+            Self::StatefulOptimalMerkleTree(r) => r
+                .verify_with_signal(proof, values, x)
+                .map_err(|err| err.to_string()),
+            Self::StatefulPmTree(r) => r
+                .verify_with_signal(proof, values, x)
+                .map_err(|err| err.to_string()),
+        }
+    }
+
     fn verify_with_roots(
         &self,
         proof: &Proof,
@@ -521,15 +543,29 @@ pub fn ffi_rln_generate_proof(
 pub fn ffi_rln_verify(
     rln: &repr_c::Box<FFI_RLN>,
     rln_proof: &repr_c::Box<FFI_RLNProof>,
-    x: &CFr,
 ) -> CBoolResult {
-    if rln_proof.0.values.x() != x.0 {
-        return CBoolResult {
-            ok: false,
+    match rln.0.verify(&rln_proof.0.proof, &rln_proof.0.values) {
+        Ok(verified) => CBoolResult {
+            ok: verified,
             err: None,
-        };
+        },
+        Err(err) => CBoolResult {
+            ok: false,
+            err: Some(err.into()),
+        },
     }
-    match rln.0.verify(&rln_proof.0.proof, &rln_proof.0.values) {
+}
+
+#[ffi_export]
+pub fn ffi_rln_verify_with_signal(
+    rln: &repr_c::Box<FFI_RLN>,
+    rln_proof: &repr_c::Box<FFI_RLNProof>,
+    x: &CFr,
+) -> CBoolResult {
+    match rln
+        .0
+        .verify_with_signal(&rln_proof.0.proof, &rln_proof.0.values, &x.0)
+    {
         Ok(verified) => CBoolResult {
             ok: verified,
             err: None,
diff --git a/rln/src/public.rs b/rln/src/public.rs
@@ -204,16 +204,12 @@ where
     ZkProof:
         RLNZkProof<Values = RLNProofValues, Proof = Proof, VerifyProofError = VerifyProofError>,
 {
-    pub fn verify_with_roots(
+    pub fn verify_with_signal(
         &self,
         proof: &Proof,
         values: &RLNProofValues,
         x: &Fr,
-        roots: &[Fr],
     ) -> Result<bool, VerifyProofError> {
-        if !roots.is_empty() && !roots.contains(&values.root()) {
-            return Err(VerifyProofError::InvalidRoot);
-        }
         if x != &values.x() {
             return Err(VerifyProofError::InvalidSignal);
         }
@@ -222,6 +218,19 @@ where
         }
         Ok(true)
     }
+
+    pub fn verify_with_roots(
+        &self,
+        proof: &Proof,
+        values: &RLNProofValues,
+        x: &Fr,
+        roots: &[Fr],
+    ) -> Result<bool, VerifyProofError> {
+        if !roots.is_empty() && !roots.contains(&values.root()) {
+            return Err(VerifyProofError::InvalidRoot);
+        }
+        self.verify_with_signal(proof, values, x)
+    }
 }
 
 pub struct RLNBuilder<ZKP>(PhantomData<ZKP>);
diff --git a/rln/tests/ffi_rln.rs b/rln/tests/ffi_rln.rs
@@ -324,12 +324,18 @@ mod test {
             "ffi_rln_generate_proof",
         );
 
-        assert_bool_ok(ffi_rln_verify(&rln, &rln_proof, &x), "ffi_rln_verify");
+        assert_bool_ok(
+            ffi_rln_verify_with_signal(&rln, &rln_proof, &x),
+            "ffi_rln_verify_with_signal",
+        );
 
         // Verification with a wrong signal fails
         let wrong_x = random_signal_hash();
-        let result = ffi_rln_verify(&rln, &rln_proof, &wrong_x);
+        let result = ffi_rln_verify_with_signal(&rln, &rln_proof, &wrong_x);
         assert!(!result.ok);
+
+        // Pure ZK verify accepts the proof without a signal binding
+        assert_bool_ok(ffi_rln_verify(&rln, &rln_proof), "ffi_rln_verify");
     }
 
     #[test]
@@ -443,7 +449,10 @@ mod test {
             "ffi_rln_finish_proof",
         );
 
-        assert_bool_ok(ffi_rln_verify(&rln, &rln_proof, &x), "ffi_rln_verify");
+        assert_bool_ok(
+            ffi_rln_verify_with_signal(&rln, &rln_proof, &x),
+            "ffi_rln_verify_with_signal",
+        );
     }
 
     #[test]
@@ -518,8 +527,8 @@ mod test {
 
                 let deser = unwrap_ok!($from_bytes(&bytes), "proof deserialization");
                 assert_bool_ok(
-                    ffi_rln_verify(&rln, &deser, &x),
-                    "ffi_rln_verify on deserialized proof",
+                    ffi_rln_verify_with_signal(&rln, &deser, &x),
+                    "ffi_rln_verify_with_signal on deserialized proof",
                 );
             }};
         }
@@ -582,7 +591,10 @@ mod test {
             ffi_rln_finish_proof(&rln, &partial_proof_deser, &witness),
             "ffi_rln_finish_proof",
         );
-        assert_bool_ok(ffi_rln_verify(&rln, &rln_proof, &x), "ffi_rln_verify");
+        assert_bool_ok(
+            ffi_rln_verify_with_signal(&rln, &rln_proof, &x),
+            "ffi_rln_verify_with_signal",
+        );
     }
 
     #[test]
diff --git a/rln/tests/proof.rs b/rln/tests/proof.rs
@@ -429,7 +429,7 @@ mod test {
     }
 
     #[test]
-    fn test_verify_with_roots_wrong_signal_fails_single() {
+    fn test_verify_with_signal_wrong_signal_fails_single() {
         let rln = make_rln(default_zkey_single(), default_graph_single());
         let x = Fr::from(42u64);
         let witness = single_witness(
@@ -441,7 +441,7 @@ mod test {
         );
         let (proof, vals) = rln.generate_proof(&witness).unwrap();
         assert!(matches!(
-            rln.verify_with_roots(&proof, &vals, &Fr::from(9999u64), &[]),
+            rln.verify_with_signal(&proof, &vals, &Fr::from(9999u64)),
             Err(VerifyProofError::InvalidSignal)
         ));
     }
diff --git a/rln/tests/public.rs b/rln/tests/public.rs
@@ -208,7 +208,7 @@ mod test {
 
         let ark_proof = ark_proof_from_snarkjs(&snarkjs_proof);
         assert!(rln
-            .verify_with_roots(&ark_proof, &proof_values, &x, &[])
+            .verify_with_signal(&ark_proof, &proof_values, &x)
             .is_ok());
     }
 
@@ -277,7 +277,7 @@ mod test {
 
         let ark_proof = ark_proof_from_snarkjs(&snarkjs_proof);
         assert!(rln
-            .verify_with_roots(&ark_proof, &proof_values, &x, &[])
+            .verify_with_signal(&ark_proof, &proof_values, &x)
             .is_ok());
     }
 

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ int main(void)`
`88`	`88`	`ffi_cfr_free(proof_values_external_nullifier);`
`89`	`89`
`90`	`90`	`printf("\nVerifying proof\n");`
`91`		`- CBoolResult verify_result = ffi_rln_verify(&rln_instance, &rln_proof, x);`
	`91`	`+ CBoolResult verify_result = verify_stateful_proof(&rln_instance, &rln_proof, x);`
`92`	`92`	`if (verify_result.err.ptr)`
`93`	`93`	`{`
`94`	`94`	`fprintf(stderr, "Proof verification error: %s\n", verify_result.err.ptr);`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ int main(void)`
`90`	`90`	`printf(" - partial proof finished successfully\n");`
`91`	`91`
`92`	`92`	`printf("\nVerifying full proof\n");`
`93`		`- CBoolResult verify_full_result = ffi_rln_verify(&rln_instance, &full_proof, x);`
	`93`	`+ CBoolResult verify_full_result = verify_stateful_proof(&rln_instance, &full_proof, x);`
`94`	`94`	`if (verify_full_result.err.ptr)`
`95`	`95`	`{`
`96`	`96`	`fprintf(stderr, "Full proof verification error: %s\n", verify_full_result.err.ptr);`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ int main(void)`
`99`	`99`	`printf(" - proof deserialized successfully\n");`
`100`	`100`
`101`	`101`	`printf("\nVerifying the deserialized proof\n");`
`102`		`- CBoolResult verify_result = ffi_rln_verify(&rln_instance, &deser_proof, x);`
	`102`	`+ CBoolResult verify_result = verify_stateful_proof(&rln_instance, &deser_proof, x);`
`103`	`103`	`if (verify_result.err.ptr)`
`104`	`104`	`{`
`105`	`105`	`fprintf(stderr, "Proof verification error: %s\n", verify_result.err.ptr);`