traitify the MerkleTree to make it extendable by Containers, so that the tree methods are exposed at Dictionary,Set,Array types

Author: arnaucube

book/src/merkletree.md

@@ -144,31 +144,28 @@ For the current use cases, we don't need to prove that the key exists but the va
 ## Interface
 
 ```rust
-impl MerkleTree {
-    /// builds a new `MerkleTree` where the leaves contain the given key-values
-    fn new(kvs: HashMap<Value, Value>) -> Self;
-    
+trait MerkleTreeTrait {
     /// returns the root of the tree
     fn root(&self) -> Hash;
-    
+
     /// returns the value at the given key
-    pub fn get(&self, key: &Value) -> Value;
-    
+    fn get(&self, key: &Value) -> Result<Value>;
+
     /// returns a proof of existence, which proves that the given key exists in
     /// the tree. It returns the `MerkleProof`.
     fn prove(&self, key: &Value) -> Result<MerkleProof>;
-    
+
     /// returns a proof of non-existence, which proves that the given `key`
     /// does not exist in the tree
     fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof>;
-    
+
     /// verifies an inclusion proof for the given `key` and `value`
     fn verify(root: Hash, proof: &MerkleProof, key: &Value, value: &Value) -> Result<()>;
-    
+
     /// verifies a non-inclusion proof for the given `key`, that is, the given
     /// `key` does not exist in the tree
     fn verify_nonexistence(root: Hash, proof: &MerkleProof, key: &Value) -> Result<()>;
-    
+
     /// returns an iterator over the leaves of the tree
     fn iter(&self) -> std::collections::hash_map::Iter<Value, Value>;
 }

book/src/values.md

@@ -51,14 +51,16 @@ The array, set and dictionary types are similar types. While all of them use [a
     - `leaf.key=hash(original_key)`
     - `leaf.value=hash(original_value)`
 - **array**: the elements are placed at the value field of each leaf, and the key field is just the array index (integer)
-    - `leaf.value=original_value` 
     - `leaf.key=i` 
+    - `leaf.value=original_value` 
 - **set**: the value field of the leaf is unused, and the key contains the hash of the element
     -  `leaf.key=hash(original_value)`
     - `leaf.value=0`
 
 In the three types, the merkletree under the hood allows to prove inclusion & non-inclusion of the particular entry of the {dictionary/array/set} element.
 
+A concrete implementation of dictionary, array, set can be found at [pod2/src/middleware/containers.rs](https://github.com/0xPARC/pod2/blob/main/src/middleware/containers.rs).
+
 <br><br>
 
 ---

src/backends/mock_signed.rs

@@ -2,7 +2,7 @@ use crate::middleware::{
     containers::{Container, Dictionary},
     hash_str, Hash, Params, PodId, PodSigner, PodType, SignedPod, Value, KEY_SIGNER, KEY_TYPE,
 };
-use crate::primitives::merkletree::MerkleTree;
+use crate::primitives::merkletree::{MerkleTree, MerkleTreeTrait};
 use anyhow::Result;
 use std::any::Any;
 use std::collections::HashMap;
@@ -19,7 +19,7 @@ impl PodSigner for MockSigner {
         kvs.insert(hash_str(&KEY_TYPE), Value::from(PodType::MockSigned));
 
         let dict = Dictionary::new(&kvs);
-        let id = PodId(dict.cm());
+        let id = PodId(dict.root());
         let signature = format!("{}_signed_by_{}", id, pk_hash);
         Ok(Box::new(MockSignedPod {
             dict,
@@ -48,7 +48,7 @@ impl SignedPod for MockSignedPod {
         }
 
         // Verify id
-        let mt = MerkleTree::new(&self.dict.mt.kvs);
+        let mt = MerkleTree::construct(&self.dict.mt.kvs);
         let id = PodId(mt.root());
         if id != self.id {
             return false;
@@ -122,7 +122,7 @@ pub mod tests {
             .into_iter()
             .map(|(k, v)| (Value(k.0), v))
             .collect::<HashMap<Value, Value>>();
-        let bad_mt = MerkleTree::new(&bad_kvs_mt);
+        let bad_mt = MerkleTree::construct(&bad_kvs_mt);
         bad_pod.dict.mt = bad_mt;
         assert_eq!(bad_pod.verify(), false);
 
@@ -133,7 +133,7 @@ pub mod tests {
             .into_iter()
             .map(|(k, v)| (Value(k.0), v))
             .collect::<HashMap<Value, Value>>();
-        let bad_mt = MerkleTree::new(&bad_kvs_mt);
+        let bad_mt = MerkleTree::construct(&bad_kvs_mt);
         bad_pod.dict.mt = bad_mt;
         assert_eq!(bad_pod.verify(), false);
     }

src/frontend.rs

@@ -9,10 +9,11 @@ use std::fmt;
 
 use crate::middleware::{
     self,
-    containers::{Array, Container, Dictionary, Set},
+    containers::{Array, Dictionary, Set},
     hash_str, Hash, MainPodInputs, NativeOperation, NativeStatement, Params, PodId, PodProver,
     PodSigner, SELF,
 };
+use crate::primitives::merkletree::MerkleTreeTrait;
 
 /// This type is just for presentation purposes.
 #[derive(Clone, Debug, Default, Hash, PartialEq, Eq)]
@@ -52,9 +53,9 @@ impl From<&Value> for middleware::Value {
         match v {
             Value::String(s) => middleware::Value(hash_str(s).0),
             Value::Int(v) => middleware::Value::from(*v),
-            Value::Dictionary(d) => middleware::Value(d.cm().0),
-            Value::Set(s) => middleware::Value(s.cm().0),
-            Value::Array(a) => middleware::Value(a.cm().0),
+            Value::Dictionary(d) => middleware::Value(d.root().0),
+            Value::Set(s) => middleware::Value(s.root().0),
+            Value::Array(a) => middleware::Value(a.root().0),
         }
     }
 }
@@ -64,9 +65,9 @@ impl fmt::Display for Value {
         match self {
             Value::String(s) => write!(f, "\"{}\"", s),
             Value::Int(v) => write!(f, "{}", v),
-            Value::Dictionary(d) => write!(f, "dict:{}", d.cm()),
-            Value::Set(s) => write!(f, "set:{}", s.cm()),
-            Value::Array(a) => write!(f, "arr:{}", a.cm()),
+            Value::Dictionary(d) => write!(f, "dict:{}", d.root()),
+            Value::Set(s) => write!(f, "set:{}", s.root()),
+            Value::Array(a) => write!(f, "arr:{}", a.root()),
         }
     }
 }

src/middleware/containers.rs

@@ -1,28 +1,30 @@
 /// This file implements the types defined at
 /// https://0xparc.github.io/pod2/values.html#dictionary-array-set .
+use anyhow::Result;
 use plonky2::hash::poseidon::PoseidonHash;
 use plonky2::plonk::config::Hasher;
 use std::collections::HashMap;
 
 use super::{Hash, Value, EMPTY};
-use crate::primitives::merkletree::MerkleTree;
+use crate::primitives::merkletree::{MerkleProof, MerkleTree, MerkleTreeTrait};
 
 /// Container is a wrapper of a MerkleTree, used to achieve Dictionary, Set, Array frontend types.
-pub trait Container {
+/// It offers all the methods of the trait `MerkleTreeTrait`, with an additional constructor `new`
+/// that allows each specific type (ie. Dictionary, Set, Array) to define how each type is
+/// constructed (for example a Dictionary is built from HashMap<Hash,Value>, whereas a set is built
+/// from Vec<Value>).
+pub trait Container: MerkleTreeTrait {
     type Raw: Clone;
 
     fn new(raw: &Self::Raw) -> Self;
-
-    /// returns the commitment to the container
-    fn cm(&self) -> Hash;
 }
 
 /// Dictionary: the user original keys and values are hashed to be used in the leaf.
 ///    leaf.key=hash(original_key)
 ///    leaf.value=hash(original_value)
 #[derive(Clone, Debug)]
 pub struct Dictionary {
-    pub mt: MerkleTree,
+    mt: MerkleTree,
 }
 
 impl Container for Dictionary {
@@ -31,13 +33,33 @@ impl Container for Dictionary {
     fn new(raw: &Self::Raw) -> Self {
         let kvs: HashMap<Value, Value> = raw.into_iter().map(|(&k, &v)| (Value(k.0), v)).collect();
         Self {
-            mt: MerkleTree::new(&kvs),
+            mt: MerkleTree::construct(&kvs),
         }
     }
+}
 
-    fn cm(&self) -> Hash {
+impl MerkleTreeTrait for Dictionary {
+    fn root(&self) -> Hash {
         self.mt.root()
     }
+    fn get(&self, key: &Value) -> Result<Value> {
+        self.mt.get(key)
+    }
+    fn prove(&self, key: &Value) -> Result<MerkleProof> {
+        self.mt.prove(key)
+    }
+    fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
+        self.mt.prove_nonexistence(key)
+    }
+    fn verify(root: Hash, proof: &MerkleProof, key: &Value, value: &Value) -> Result<()> {
+        MerkleTree::verify(root, proof, key, value)
+    }
+    fn verify_nonexistence(root: Hash, proof: &MerkleProof, key: &Value) -> Result<()> {
+        MerkleTree::verify_nonexistence(root, proof, key)
+    }
+    fn iter(&self) -> std::collections::hash_map::Iter<Value, Value> {
+        self.mt.iter()
+    }
 }
 
 impl PartialEq for Dictionary {
@@ -67,13 +89,33 @@ impl Container for Set {
             })
             .collect();
         Self {
-            mt: MerkleTree::new(&kvs),
+            mt: MerkleTree::construct(&kvs),
         }
     }
+}
 
-    fn cm(&self) -> Hash {
+impl MerkleTreeTrait for Set {
+    fn root(&self) -> Hash {
         self.mt.root()
     }
+    fn get(&self, key: &Value) -> Result<Value> {
+        self.mt.get(key)
+    }
+    fn prove(&self, key: &Value) -> Result<MerkleProof> {
+        self.mt.prove(key)
+    }
+    fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
+        self.mt.prove_nonexistence(key)
+    }
+    fn verify(root: Hash, proof: &MerkleProof, key: &Value, value: &Value) -> Result<()> {
+        MerkleTree::verify(root, proof, key, value)
+    }
+    fn verify_nonexistence(root: Hash, proof: &MerkleProof, key: &Value) -> Result<()> {
+        MerkleTree::verify_nonexistence(root, proof, key)
+    }
+    fn iter(&self) -> std::collections::hash_map::Iter<Value, Value> {
+        self.mt.iter()
+    }
 }
 
 impl PartialEq for Set {
@@ -103,13 +145,33 @@ impl Container for Array {
             .collect();
 
         Self {
-            mt: MerkleTree::new(&kvs),
+            mt: MerkleTree::construct(&kvs),
         }
     }
+}
 
-    fn cm(&self) -> Hash {
+impl MerkleTreeTrait for Array {
+    fn root(&self) -> Hash {
         self.mt.root()
     }
+    fn get(&self, key: &Value) -> Result<Value> {
+        self.mt.get(key)
+    }
+    fn prove(&self, key: &Value) -> Result<MerkleProof> {
+        self.mt.prove(key)
+    }
+    fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
+        self.mt.prove_nonexistence(key)
+    }
+    fn verify(root: Hash, proof: &MerkleProof, key: &Value, value: &Value) -> Result<()> {
+        MerkleTree::verify(root, proof, key, value)
+    }
+    fn verify_nonexistence(root: Hash, proof: &MerkleProof, key: &Value) -> Result<()> {
+        MerkleTree::verify_nonexistence(root, proof, key)
+    }
+    fn iter(&self) -> std::collections::hash_map::Iter<Value, Value> {
+        self.mt.iter()
+    }
 }
 
 impl PartialEq for Array {