use MerkleClaimAndProof in merkle circuit set_targets

Author: ed255

src/backends/plonky2/circuits/mainpod.rs

@@ -495,15 +495,7 @@ impl MainPodVerifyTarget {
         assert_eq!(input.merkle_proofs.len(), self.params.max_merkle_proofs);
         for (i, mp) in input.merkle_proofs.iter().enumerate() {
             assert_eq!(mp.proof.siblings.len(), self.params.max_depth_mt_gadget);
-            self.merkle_proofs[i].set_targets(
-                pw,
-                mp.enabled,
-                mp.proof.existence,
-                mp.root,
-                mp.proof.clone(),
-                mp.key,
-                mp.value,
-            )?;
+            self.merkle_proofs[i].set_targets(pw, mp)?;
         }
         Ok(())
     }
@@ -526,26 +518,23 @@ impl MainPodVerifyCircuit {
 
 #[cfg(test)]
 mod tests {
-    use merkletree::MerkleTree;
     use plonky2::plonk::{circuit_builder::CircuitBuilder, circuit_data::CircuitConfig};
 
     use super::*;
     use crate::{
         backends::plonky2::{
             basetypes::C,
-            mock::{
-                mainpod,
-                mainpod::{OperationArg, OperationAux},
-            },
+            mainpod::{OperationArg, OperationAux},
+            primitives::merkletree::{MerkleClaimAndProof, MerkleTree},
         },
-        middleware::{OperationType, PodId, RawValue},
+        middleware::{Hash, OperationType, PodId, RawValue},
     };
 
     fn operation_verify(
         st: mainpod::Statement,
         op: mainpod::Operation,
         prev_statements: Vec<mainpod::Statement>,
-        merkle_proofs: Vec<mainpod::MerkleClaimAndProof>,
+        merkle_proofs: Vec<MerkleClaimAndProof>,
     ) -> Result<()> {
         let params = Params::default();
         let mp_gadget = MerkleProofGadget {
@@ -590,15 +579,7 @@ mod tests {
         for (merkle_proof_target, merkle_proof) in
             merkle_proofs_target.iter().zip(merkle_proofs.iter())
         {
-            merkle_proof_target.set_targets(
-                &mut pw,
-                merkle_proof.enabled,
-                merkle_proof.existence,
-                merkle_proof.root,
-                merkle_proof.clone().try_into()?,
-                merkle_proof.key,
-                merkle_proof.value,
-            )?
+            merkle_proof_target.set_targets(&mut pw, &merkle_proof)?
         }
 
         // generate & verify proof
@@ -725,10 +706,10 @@ mod tests {
             OperationAux::MerkleProofIndex(0),
         );
 
-        let merkle_proofs = vec![mainpod::MerkleClaimAndProof::try_from_middleware(
-            &params,
-            &root.raw(),
-            &key,
+        let merkle_proofs = vec![MerkleClaimAndProof::new(
+            params.max_depth_mt_gadget,
+            Hash::from(root.raw()),
+            key,
             None,
             &no_key_pf,
         )?];

src/backends/plonky2/circuits/signedpod.rs

@@ -16,14 +16,16 @@ use crate::{
         basetypes::D,
         circuits::common::{CircuitBuilderPod, StatementArgTarget, StatementTarget, ValueTarget},
         primitives::{
-            merkletree::{MerkleProof, MerkleProofExistenceGadget, MerkleProofExistenceTarget},
+            merkletree::{
+                MerkleClaimAndProof, MerkleProofExistenceGadget, MerkleProofExistenceTarget,
+            },
             signature::{PublicKey, SignatureVerifyGadget, SignatureVerifyTarget},
         },
         signedpod::SignedPod,
     },
     middleware::{
-        hash_str, Key, NativePredicate, Params, PodType, Predicate, RawValue, ToFields, Value,
-        EMPTY_VALUE, F, KEY_SIGNER, KEY_TYPE, SELF,
+        hash_str, Key, NativePredicate, Params, PodType, Predicate, RawValue, ToFields, Value, F,
+        KEY_SIGNER, KEY_TYPE, SELF,
     },
 };
 
@@ -132,11 +134,13 @@ impl SignedPodVerifyTarget {
                 let (v, proof) = pod.dict.prove(k)?;
                 self.mt_proofs[i].set_targets(
                     pw,
-                    true,
-                    pod.dict.commitment(),
-                    proof,
-                    k.raw(),
-                    v.raw(),
+                    &MerkleClaimAndProof::new(
+                        self.params.max_depth_mt_gadget,
+                        pod.dict.commitment(),
+                        k.raw(),
+                        Some(v.raw()),
+                        &proof,
+                    )?,
                 )?;
                 Ok(v)
             })
@@ -156,11 +160,13 @@ impl SignedPodVerifyTarget {
 
             self.mt_proofs[curr].set_targets(
                 pw,
-                true,
-                pod.dict.commitment(),
-                proof,
-                k.raw(),
-                v.raw(),
+                &MerkleClaimAndProof::new(
+                    self.params.max_depth_mt_gadget,
+                    pod.dict.commitment(),
+                    k.raw(),
+                    Some(v.raw()),
+                    &proof,
+                )?,
             )?;
             curr += 1;
         }
@@ -171,16 +177,7 @@ impl SignedPodVerifyTarget {
         for i in curr..self.params.max_signed_pod_values {
             self.mt_proofs[i].set_targets(
                 pw,
-                false, // disable verification
-                pod.dict.commitment(),
-                // use an empty proof:
-                MerkleProof {
-                    existence: true,
-                    siblings: vec![],
-                    other_leaf: None,
-                },
-                EMPTY_VALUE,
-                EMPTY_VALUE,
+                &MerkleClaimAndProof::empty(self.params.max_depth_mt_gadget),
             )?;
         }
 

src/backends/plonky2/mainpod/mod.rs

@@ -52,9 +52,9 @@ pub(crate) fn extract_merkle_proofs(
                 pf,
             ) => Some(MerkleClaimAndProof::new(
                 params.max_depth_mt_gadget,
-                &root.raw(),
-                &key.raw(),
-                Some(&value.raw()),
+                Hash::from(root.raw()),
+                key.raw(),
+                Some(value.raw()),
                 pf,
             )),
             middleware::Operation::NotContainsFromEntries(
@@ -63,8 +63,8 @@ pub(crate) fn extract_merkle_proofs(
                 pf,
             ) => Some(MerkleClaimAndProof::new(
                 params.max_depth_mt_gadget,
-                &root.raw(),
-                &key.raw(),
+                Hash::from(root.raw()),
+                key.raw(),
                 None,
                 pf,
             )),
@@ -435,7 +435,9 @@ pub mod tests {
     use super::*;
     use crate::{
         backends::plonky2::{
-            mock::mainpod::MockProver, primitives::signature::SecretKey, signedpod::Signer,
+            mock::mainpod::{MockMainPod, MockProver},
+            primitives::signature::SecretKey,
+            signedpod::Signer,
         },
         examples::{zu_kyc_pod_builder, zu_kyc_sign_pod_builders},
         frontend, middleware,

src/backends/plonky2/primitives/merkletree.rs

@@ -291,9 +291,9 @@ impl MerkleClaimAndProof {
     }
     pub fn new(
         max_depth: usize,
-        root: &RawValue,
-        key: &RawValue,
-        value: Option<&RawValue>,
+        root: Hash,
+        key: RawValue,
+        value: Option<RawValue>,
         proof: &MerkleProof,
     ) -> Result<Self> {
         if proof.siblings.len() > max_depth {
@@ -305,9 +305,9 @@ impl MerkleClaimAndProof {
         } else {
             Ok(Self {
                 enabled: true,
-                root: (*root).into(),
-                key: *key,
-                value: value.cloned().unwrap_or(EMPTY_VALUE),
+                root,
+                key,
+                value: value.unwrap_or(EMPTY_VALUE),
                 proof: MerkleProof {
                     existence: proof.existence,
                     siblings: proof

src/backends/plonky2/primitives/merkletree_circuit.rs

@@ -28,9 +28,9 @@ use crate::{
     backends::plonky2::{
         basetypes::D,
         circuits::common::{CircuitBuilderPod, ValueTarget},
-        primitives::merkletree::MerkleProof,
+        primitives::merkletree::MerkleClaimAndProof,
     },
-    middleware::{Hash, RawValue, EMPTY_HASH, EMPTY_VALUE, F, HASH_SIZE},
+    middleware::{EMPTY_HASH, EMPTY_VALUE, F, HASH_SIZE},
 };
 
 /// `MerkleProofGadget` allows to verify both proofs of existence and proofs
@@ -158,33 +158,20 @@ impl MerkleProofGadget {
 impl MerkleClaimAndProofTarget {
     /// assigns the given values to the targets
     #[allow(clippy::too_many_arguments)]
-    pub fn set_targets(
-        &self,
-        pw: &mut PartialWitness<F>,
-        enabled: bool,
-        existence: bool,
-        root: Hash,
-        proof: MerkleProof,
-        key: RawValue,
-        value: RawValue,
-    ) -> Result<()> {
-        pw.set_bool_target(self.enabled, enabled)?;
-        pw.set_hash_target(self.root, HashOut::from_vec(root.0.to_vec()))?;
-        pw.set_target_arr(&self.key.elements, &key.0)?;
-        pw.set_target_arr(&self.value.elements, &value.0)?;
-        pw.set_bool_target(self.existence, existence)?;
-
-        // pad siblings with zeros to length max_depth
-        let mut siblings = proof.siblings.clone();
-        siblings.resize(self.max_depth, EMPTY_HASH);
-        assert_eq!(self.siblings.len(), siblings.len());
-
-        for (i, sibling) in siblings.iter().enumerate() {
+    pub fn set_targets(&self, pw: &mut PartialWitness<F>, mp: &MerkleClaimAndProof) -> Result<()> {
+        pw.set_bool_target(self.enabled, mp.enabled)?;
+        pw.set_hash_target(self.root, HashOut::from_vec(mp.root.0.to_vec()))?;
+        pw.set_target_arr(&self.key.elements, &mp.key.0)?;
+        pw.set_target_arr(&self.value.elements, &mp.value.0)?;
+        pw.set_bool_target(self.existence, mp.proof.existence)?;
+
+        assert_eq!(mp.proof.siblings.len(), self.max_depth);
+        for (i, sibling) in mp.proof.siblings.iter().enumerate() {
             pw.set_hash_target(self.siblings[i], HashOut::from_vec(sibling.0.to_vec()))?;
         }
 
-        match proof.other_leaf {
-            Some((k, v)) if !existence => {
+        match mp.proof.other_leaf {
+            Some((k, v)) if !mp.proof.existence => {
                 // non-existence case ii) expected leaf does exist but it has a different key
                 pw.set_bool_target(self.case_ii_selector, true)?;
                 pw.set_target_arr(&self.other_key.elements, &k.0)?;
@@ -263,29 +250,18 @@ impl MerkleProofExistenceGadget {
 
 impl MerkleProofExistenceTarget {
     /// assigns the given values to the targets
-    pub fn set_targets(
-        &self,
-        pw: &mut PartialWitness<F>,
-        // `enabled` determines if the merkleproof verification is enabled
-        enabled: bool,
-        root: Hash,
-        proof: MerkleProof,
-        key: RawValue,
-        value: RawValue,
-    ) -> Result<()> {
-        assert!(proof.existence); // sanity check
+    pub fn set_targets(&self, pw: &mut PartialWitness<F>, mp: &MerkleClaimAndProof) -> Result<()> {
+        assert!(mp.proof.existence); // sanity check
 
-        pw.set_bool_target(self.enabled, enabled)?;
-        pw.set_hash_target(self.root, HashOut::from_vec(root.0.to_vec()))?;
-        pw.set_target_arr(&self.key.elements, &key.0)?;
-        pw.set_target_arr(&self.value.elements, &value.0)?;
+        pw.set_bool_target(self.enabled, mp.enabled)?;
+        pw.set_hash_target(self.root, HashOut::from_vec(mp.root.0.to_vec()))?;
+        pw.set_target_arr(&self.key.elements, &mp.key.0)?;
+        pw.set_target_arr(&self.value.elements, &mp.value.0)?;
 
         // pad siblings with zeros to length max_depth
-        let mut siblings = proof.siblings.clone();
-        siblings.resize(self.max_depth, EMPTY_HASH);
-        assert_eq!(self.siblings.len(), siblings.len());
+        assert_eq!(mp.proof.siblings.len(), self.max_depth);
 
-        for (i, sibling) in siblings.iter().enumerate() {
+        for (i, sibling) in mp.proof.siblings.iter().enumerate() {
             pw.set_hash_target(self.siblings[i], HashOut::from_vec(sibling.0.to_vec()))?;
         }
 
@@ -539,12 +515,7 @@ pub mod tests {
         let targets = MerkleProofGadget { max_depth }.eval(&mut builder)?;
         targets.set_targets(
             &mut pw,
-            true, // verification enabled
-            existence,
-            tree.root(),
-            proof,
-            key,
-            value,
+            &MerkleClaimAndProof::new(max_depth, tree.root(), key, Some(value), &proof)?,
         )?;
 
         // generate & verify proof
@@ -587,7 +558,10 @@ pub mod tests {
         let mut pw = PartialWitness::<F>::new();
 
         let targets = MerkleProofExistenceGadget { max_depth }.eval(&mut builder)?;
-        targets.set_targets(&mut pw, true, tree.root(), proof, key, value)?;
+        targets.set_targets(
+            &mut pw,
+            &MerkleClaimAndProof::new(max_depth, tree.root(), key, Some(value), &proof)?,
+        )?;
 
         // generate & verify proof
         let data = builder.build::<C>();
@@ -660,12 +634,7 @@ pub mod tests {
         let targets = MerkleProofGadget { max_depth }.eval(&mut builder)?;
         targets.set_targets(
             &mut pw,
-            true, // verification enabled
-            proof.existence,
-            tree.root(),
-            proof,
-            key,
-            value,
+            &MerkleClaimAndProof::new(max_depth, tree.root(), key, Some(value), &proof)?,
         )?;
 
         // generate & verify proof
@@ -707,15 +676,9 @@ pub mod tests {
         let mut pw = PartialWitness::<F>::new();
 
         let targets = MerkleProofGadget { max_depth }.eval(&mut builder)?;
-        targets.set_targets(
-            &mut pw,
-            true, // verification enabled
-            true, // proof of existence
-            tree2.root(),
-            proof.clone(),
-            key,
-            value,
-        )?;
+        // verification enabled & proof of existence
+        let mut mp = MerkleClaimAndProof::new(max_depth, tree2.root(), key, Some(value), &proof)?;
+        targets.set_targets(&mut pw, &mp)?;
 
         // generate proof, expecting it to fail (since we're using the wrong
         // root)
@@ -729,15 +692,9 @@ pub mod tests {
         let mut pw = PartialWitness::<F>::new();
 
         let targets = MerkleProofGadget { max_depth }.eval(&mut builder)?;
-        targets.set_targets(
-            &mut pw,
-            false, // verification disabled
-            true,  // proof of existence
-            tree2.root(),
-            proof,
-            key,
-            value,
-        )?;
+        // verification disabled & proof of existence
+        mp.enabled = false;
+        targets.set_targets(&mut pw, &mp)?;
 
         // generate proof, should pass despite using wrong witness, since the
         // `enabled=false`