Remove max_depth in native MerkleTree (#442)

This simplifies the MerkleTree (and container) API.
Defer the max depth check when assigning the witness (merkle proof siblings) to the merkle tree circuit.

In this implementation the native Merkle Tree branches grow as much as they needed.  There are no checks of max depth in the merkle tree.  All keys are 256 bits (I added a debug_assert for this); so in the worst case a path will have depth 256.  It can't have a longer depth because the `insert` method calls `prove_nonexistence` which errors if the key already exists; another one may exist which must be different and thus require a path <= 256 depth. 

Resolve #436

Author: ed255

examples/main_pod_points.rs

@@ -35,7 +35,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mock_prover = MockProver {};
     let real_prover = Prover {};
     let (vd_set, prover): (_, &dyn MainPodProver) = if mock {
-        (&VDSet::new(8, &[])?, &mock_prover)
+        (&VDSet::new(&[]), &mock_prover)
     } else {
         println!("Prebuilding circuits to calculate vd_set...");
         let vd_set = &*DEFAULT_VD_SET;

examples/signed_dict.rs

@@ -30,10 +30,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .into_iter()
         .map(Value::from)
         .collect();
-    builder.insert(
-        "friends",
-        Set::new(params.max_merkle_proofs_containers, friends_set)?,
-    );
+    builder.insert("friends", Set::new(friends_set));
 
     // Sign the dict and verify it
     let signed_dict = builder.sign(&signer)?;

src/backends/plonky2/basetypes.rs

@@ -65,9 +65,8 @@ pub static DEFAULT_VD_LIST: LazyLock<Vec<VerifierOnlyCircuitData>> = LazyLock::n
 });
 
 pub static DEFAULT_VD_SET: LazyLock<VDSet> = LazyLock::new(|| {
-    let params = Params::default();
     let vds = &*DEFAULT_VD_LIST;
-    VDSet::new(params.max_depth_mt_vds, vds).unwrap()
+    VDSet::new(vds)
 });
 
 /// VDSet is the set of the allowed verifier_data hashes. When proving a
@@ -84,35 +83,29 @@ pub struct VDSet {
     #[serde(skip)]
     #[schemars(skip)]
     proofs_map: HashMap<Hash, MerkleClaimAndProof>,
-    tree_depth: usize,
     vds_hashes: Vec<Hash>,
 }
 
 impl PartialEq for VDSet {
     fn eq(&self, other: &Self) -> bool {
-        self.root == other.root
-            && self.tree_depth == other.tree_depth
-            && self.vds_hashes == other.vds_hashes
+        self.root == other.root && self.vds_hashes == other.vds_hashes
     }
 }
 impl Eq for VDSet {}
 
 impl VDSet {
-    fn new_from_vds_hashes(tree_depth: usize, mut vds_hashes: Vec<Hash>) -> Result<Self> {
+    fn new_from_vds_hashes(mut vds_hashes: Vec<Hash>) -> Self {
         // before using the hash values, sort them, so that each set of
         // verifier_datas gets the same VDSet root
         vds_hashes.sort();
 
-        let array = Array::new(
-            tree_depth,
-            vds_hashes.iter().map(|vd| Value::from(*vd)).collect(),
-        )?;
+        let array = Array::new(vds_hashes.iter().map(|vd| Value::from(*vd)).collect());
 
         let root = array.commitment();
         let mut proofs_map = HashMap::<Hash, MerkleClaimAndProof>::new();
 
         for (i, vd) in vds_hashes.iter().enumerate() {
-            let (value, proof) = array.prove(i)?;
+            let (value, proof) = array.prove(i).expect("exists");
             let p = MerkleClaimAndProof {
                 root,
                 key: RawValue::from(i as i64),
@@ -121,15 +114,14 @@ impl VDSet {
             };
             proofs_map.insert(*vd, p);
         }
-        Ok(Self {
+        Self {
             root,
             proofs_map,
-            tree_depth,
             vds_hashes,
-        })
+        }
     }
     /// builds the verifier_datas tree, and returns the root and the proofs
-    pub fn new(tree_depth: usize, vds: &[VerifierOnlyCircuitData]) -> Result<Self> {
+    pub fn new(vds: &[VerifierOnlyCircuitData]) -> Self {
         // compute the verifier_data's hashes
         let vds_hashes: Vec<HashOut> = vds
             .iter()
@@ -141,7 +133,7 @@ impl VDSet {
             .map(|h| Hash(h.elements))
             .collect::<Vec<_>>();
 
-        Self::new_from_vds_hashes(tree_depth, vds_hashes)
+        Self::new_from_vds_hashes(vds_hashes)
     }
     pub fn root(&self) -> Hash {
         self.root
@@ -172,10 +164,9 @@ impl<'de> Deserialize<'de> for VDSet {
     {
         #[derive(Deserialize)]
         struct Aux {
-            tree_depth: usize,
             vds_hashes: Vec<Hash>,
         }
         let aux = Aux::deserialize(deserializer)?;
-        VDSet::new_from_vds_hashes(aux.tree_depth, aux.vds_hashes).map_err(serde::de::Error::custom)
+        Ok(VDSet::new_from_vds_hashes(aux.vds_hashes))
     }
 }

src/backends/plonky2/circuits/mainpod.rs

@@ -2329,8 +2329,8 @@ mod tests {
 
     #[test]
     fn test_operation_verify_eq() -> Result<()> {
-        let dict1 = dict!(32, {"hello" => 55})?;
-        let dict2 = dict!(32, {"world" => 55})?;
+        let dict1 = dict!({"hello" => 55});
+        let dict2 = dict!({"world" => 55});
         let st1: mainpod::Statement = Statement::contains(dict1.clone(), "hello", 55).into();
         let st2: mainpod::Statement = Statement::contains(dict2.clone(), "world", 55).into();
         let st: mainpod::Statement = Statement::equal(
@@ -2349,8 +2349,8 @@ mod tests {
 
     #[test]
     fn test_operation_verify_neq() -> Result<()> {
-        let dict1 = dict!(32, {"hello" => 55})?;
-        let dict2 = dict!(32, {"world" => 75})?;
+        let dict1 = dict!({"hello" => 55});
+        let dict2 = dict!({"world" => 75});
         let st1: mainpod::Statement = Statement::contains(dict1.clone(), "hello", 55).into();
         let st2: mainpod::Statement = Statement::contains(dict2.clone(), "world", 75).into();
         let st: mainpod::Statement = Statement::not_equal(
@@ -2369,8 +2369,8 @@ mod tests {
 
     #[test]
     fn test_operation_verify_lt() -> Result<()> {
-        let dict1 = dict!(32, {"hello" => 55})?;
-        let dict2 = dict!(32, {"hello" => 56})?;
+        let dict1 = dict!({"hello" => 55});
+        let dict2 = dict!({"hello" => 56});
         let st1: mainpod::Statement = Statement::contains(dict1.clone(), "hello", 55).into();
         let st2: mainpod::Statement = Statement::contains(dict2.clone(), "hello", 56).into();
         let st: mainpod::Statement = Statement::lt(
@@ -2387,8 +2387,8 @@ mod tests {
         operation_verify(st, op, prev_statements, Aux::default())?;
 
         // Also check negative < negative
-        let dict3 = dict!(32, {"hola" => -56})?;
-        let dict4 = dict!(32, {"mundo" => -55})?;
+        let dict3 = dict!({"hola" => -56});
+        let dict4 = dict!({"mundo" => -55});
         let st3: mainpod::Statement = Statement::contains(dict3.clone(), "hola", -56).into();
         let st4: mainpod::Statement = Statement::contains(dict4.clone(), "mundo", -55).into();
         let st: mainpod::Statement = Statement::lt(
@@ -2421,12 +2421,12 @@ mod tests {
 
     #[test]
     fn test_operation_verify_lteq() -> Result<()> {
-        let local = dict!(32, {
+        let local = dict!({
             "n55" => 55,
             "n56" => 56,
             "n_56" => -56,
             "n_55" => -55,
-        })?;
+        });
         let st1: mainpod::Statement = Statement::contains(local.clone(), "n55", 55).into();
         let st2: mainpod::Statement = Statement::contains(local.clone(), "n56", 56).into();
         let st: mainpod::Statement = Statement::lt_eq(
@@ -2511,11 +2511,11 @@ mod tests {
         let v1 = hash_values(&input_values);
         let [v2, v3] = input_values;
 
-        let local = dict!(32, {
+        let local = dict!({
             "hola" => v1,
             "mundo" => v2.clone(),
             "!" => v3.clone(),
-        })?;
+        });
 
         let st1: mainpod::Statement = Statement::contains(local.clone(), "hola", v1).into();
         let st2: mainpod::Statement = Statement::contains(local.clone(), "mundo", v2).into();
@@ -2549,11 +2549,11 @@ mod tests {
                 overflow.not().then_some((a, b, sum))
             })
             .try_for_each(|(a, b, sum)| {
-                let local = dict!(32, {
+                let local = dict!({
                     "sum" => sum,
                     "a" => a,
                     "b" => b,
-                })?;
+                });
 
                 let st1: mainpod::Statement = Statement::contains(local.clone(), "sum", sum).into();
                 let st2: mainpod::Statement = Statement::contains(local.clone(), "a", a).into();
@@ -2588,11 +2588,11 @@ mod tests {
                 overflow.not().then_some((a, b, prod))
             })
             .try_for_each(|(a, b, prod)| {
-                let local = dict!(32, {
+                let local = dict!({
                     "prod" => prod,
                     "a" => a,
                     "b" => b,
-                })?;
+                });
 
                 let st1: mainpod::Statement =
                     Statement::contains(local.clone(), "prod", prod).into();
@@ -2623,11 +2623,11 @@ mod tests {
     fn test_operation_verify_maxof() -> Result<()> {
         I64_TEST_PAIRS.into_iter().try_for_each(|(a, b)| {
             let max = i64::max(a, b);
-            let local = dict!(32, {
+            let local = dict!({
                 "max" => max,
                 "a" => a,
                 "b" => b,
-            })?;
+            });
 
             let st1: mainpod::Statement = Statement::contains(local.clone(), "max", max).into();
             let st2: mainpod::Statement = Statement::contains(local.clone(), "a", a).into();
@@ -2689,10 +2689,10 @@ mod tests {
 
     #[test]
     fn test_operation_verify_lt_to_neq() -> Result<()> {
-        let local = dict!(32,{
+        let local = dict!({
             "a" => 10,
             "b" => 20,
-        })?;
+        });
         let st: mainpod::Statement = Statement::not_equal(
             AnchoredKey::from((&local, "a")),
             AnchoredKey::from((&local, "b")),
@@ -2714,11 +2714,11 @@ mod tests {
 
     #[test]
     fn test_operation_verify_transitive_eq() -> Result<()> {
-        let local = dict!(32,{
+        let local = dict!({
             "a" => 10,
             "b" => 10,
             "c" => 10,
-        })?;
+        });
         let st: mainpod::Statement = Statement::equal(
             AnchoredKey::from((&local, "a")),
             AnchoredKey::from((&local, "c")),
@@ -2745,23 +2745,21 @@ mod tests {
 
     #[test]
     fn test_operation_verify_sintains() -> Result<()> {
-        let params = Params::default();
-
         let kvs = [
             (1.into(), 55.into()),
             (2.into(), 88.into()),
             (175.into(), 0.into()),
         ]
         .into_iter()
         .collect();
-        let mt = MerkleTree::new(params.max_depth_mt_containers, &kvs)?;
+        let mt = MerkleTree::new(&kvs);
 
         let root = mt.root();
         let key = Value::from(5);
-        let local = dict!(32,{
+        let local = dict!({
             "merkle_root" => root,
             "key" => key.clone(),
-        })?;
+        });
         let root_ak = AnchoredKey::from((&local, "merkle_root"));
         let key_ak = AnchoredKey::from((&local, "key"));
 
@@ -2785,25 +2783,23 @@ mod tests {
 
     #[test]
     fn test_operation_verify_contains() -> Result<()> {
-        let params = Params::default();
-
         let kvs = [
             (1.into(), 55.into()),
             (2.into(), 88.into()),
             (175.into(), 0.into()),
         ]
         .into_iter()
         .collect();
-        let mt = MerkleTree::new(params.max_depth_mt_containers, &kvs)?;
+        let mt = MerkleTree::new(&kvs);
 
         let root = mt.root();
         let key = Value::from(175);
         let (value, key_pf) = mt.prove(&key.raw())?;
-        let local = dict!(32,{
+        let local = dict!({
             "merkle_root" => root,
             "key" => key.clone(),
             "value" => value,
-        })?;
+        });
         let root_ak = AnchoredKey::from((&local, "merkle_root"));
         let key_ak = AnchoredKey::from((&local, "key"));
         let value_ak = AnchoredKey::from((&local, "value"));
@@ -2833,9 +2829,7 @@ mod tests {
 
     #[test]
     fn test_operation_verify_merkle_insert() -> Result<()> {
-        let params = Params::default();
-
-        let mut tree = MerkleTree::new(params.max_depth_mt_containers, &[].into())?;
+        let mut tree = MerkleTree::new(&[].into());
 
         let key = Value::from(175);
         let value = Value::from(0);
@@ -2862,12 +2856,7 @@ mod tests {
 
     #[test]
     fn test_operation_verify_merkle_update() -> Result<()> {
-        let params = Params::default();
-
-        let mut tree = MerkleTree::new(
-            params.max_depth_mt_containers,
-            &[(175.into(), 55.into())].into(),
-        )?;
+        let mut tree = MerkleTree::new(&[(175.into(), 55.into())].into());
 
         let key = Value::from(175);
         let value = Value::from(0);
@@ -2894,12 +2883,7 @@ mod tests {
 
     #[test]
     fn test_operation_verify_merkle_delete() -> Result<()> {
-        let params = Params::default();
-
-        let mut tree = MerkleTree::new(
-            params.max_depth_mt_containers,
-            &[(175.into(), 55.into())].into(),
-        )?;
+        let mut tree = MerkleTree::new(&[(175.into(), 55.into())].into());
 
         let key = Value::from(175);
         let state_transition_proof = tree.delete(&key.raw())?;

src/backends/plonky2/emptypod.rs

@@ -260,7 +260,7 @@ pub mod tests {
     fn test_empty_pod() {
         let params = Params::default();
 
-        let empty_pod = EmptyPod::new_boxed(&params, VDSet::new(8, &[]).unwrap());
+        let empty_pod = EmptyPod::new_boxed(&params, VDSet::new(&[]));
         empty_pod.verify().unwrap();
     }
 }