move MainPod layouting to mainpod (#196)

* move MainPod layouting to mainpod

* wip

* use MerkleClaimAndProof in merkle circuit set_targets

* fix empty mt proof

Author: ed255

src/backends/plonky2/circuits/common.rs

@@ -19,7 +19,7 @@ use plonky2::{
 use crate::{
     backends::plonky2::{
         basetypes::D,
-        mock::mainpod::{Operation, OperationArg, Statement},
+        mainpod::{Operation, OperationArg, Statement},
         primitives::merkletree::MerkleClaimAndProofTarget,
     },
     middleware::{

src/backends/plonky2/circuits/mainpod.rs

@@ -16,10 +16,9 @@ use crate::{
             },
             signedpod::{SignedPodVerifyGadget, SignedPodVerifyTarget},
         },
-        mock::{mainpod, mainpod::MerkleClaimAndProof},
-        primitives::{
-            merkletree,
-            merkletree::{MerkleClaimAndProofTarget, MerkleProofGadget},
+        mainpod,
+        primitives::merkletree::{
+            MerkleClaimAndProof, MerkleClaimAndProofTarget, MerkleProofGadget,
         },
         signedpod::SignedPod,
     },
@@ -495,20 +494,8 @@ 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.siblings.len(), self.params.max_depth_mt_gadget);
-            self.merkle_proofs[i].set_targets(
-                pw,
-                mp.enabled,
-                mp.existence,
-                mp.root,
-                mp.clone().try_into().unwrap_or(merkletree::MerkleProof {
-                    existence: mp.existence,
-                    siblings: mp.siblings.clone(),
-                    other_leaf: None,
-                }),
-                mp.key,
-                mp.value,
-            )?;
+            assert_eq!(mp.proof.siblings.len(), self.params.max_depth_mt_gadget);
+            self.merkle_proofs[i].set_targets(pw, mp)?;
         }
         Ok(())
     }
@@ -531,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 {
@@ -595,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
@@ -730,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,32 +160,24 @@ 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;
         }
         // sanity check
         assert!(curr <= self.params.max_signed_pod_values);
 
         // add the proofs of empty leaves (if needed), till the max_signed_pod_values
+        let mut mp = MerkleClaimAndProof::empty(self.params.max_depth_mt_gadget);
+        mp.root = pod.dict.commitment();
         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,
-            )?;
+            self.mt_proofs[i].set_targets(pw, &mp)?;
         }
 
         // get the signer pk