add dedicated type impls for Dictionary,Set,Array (without traits)

Author: arnaucube

book/src/merkletree.md

@@ -144,12 +144,15 @@ For the current use cases, we don't need to prove that the key exists but the va
 ## Interface
 
 ```rust
-trait MerkleTreeTrait {
+impl MerkleTree {
     /// returns the root of the tree
     fn root(&self) -> Hash;
 
     /// returns the value at the given key
     fn get(&self, key: &Value) -> Result<Value>;
+    
+    /// returns a boolean indicating whether the key exists in the tree
+    fn contains(&self, key: &Value) -> bool;
 
     /// returns a proof of existence, which proves that the given key exists in
     /// the tree. It returns the `MerkleProof`.

src/backends/mock_signed.rs

@@ -1,8 +1,8 @@
 use crate::middleware::{
-    containers::{Container, Dictionary},
-    hash_str, Hash, Params, PodId, PodSigner, PodType, SignedPod, Value, KEY_SIGNER, KEY_TYPE,
+    containers::Dictionary, hash_str, Hash, Params, PodId, PodSigner, PodType, SignedPod, Value,
+    KEY_SIGNER, KEY_TYPE,
 };
-use crate::primitives::merkletree::{MerkleTree, MerkleTreeTrait};
+use crate::primitives::merkletree::MerkleTree;
 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.root());
+        let id = PodId(dict.commitment());
         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::build(
+        let mt = MerkleTree::new(
             &self
                 .dict
                 .iter()
@@ -127,7 +127,7 @@ pub mod tests {
             .into_iter()
             .map(|(k, v)| (Value(k.0), v))
             .collect::<HashMap<Value, Value>>();
-        let bad_mt = MerkleTree::build(&bad_kvs_mt);
+        let bad_mt = MerkleTree::new(&bad_kvs_mt);
         bad_pod.dict.mt = bad_mt;
         assert_eq!(bad_pod.verify(), false);
 
@@ -138,7 +138,7 @@ pub mod tests {
             .into_iter()
             .map(|(k, v)| (Value(k.0), v))
             .collect::<HashMap<Value, Value>>();
-        let bad_mt = MerkleTree::build(&bad_kvs_mt);
+        let bad_mt = MerkleTree::new(&bad_kvs_mt);
         bad_pod.dict.mt = bad_mt;
         assert_eq!(bad_pod.verify(), false);
     }

src/examples.rs

@@ -1,10 +1,7 @@
 use std::collections::HashMap;
 
 use crate::frontend::{MainPodBuilder, SignedPod, SignedPodBuilder, Value};
-use crate::middleware::{
-    containers::{Container, Dictionary},
-    Params, PodType, KEY_SIGNER, KEY_TYPE,
-};
+use crate::middleware::{containers::Dictionary, Params, PodType, KEY_SIGNER, KEY_TYPE};
 use crate::op;
 
 // ZuKYC

src/frontend.rs

@@ -13,7 +13,6 @@ use crate::middleware::{
     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)]
@@ -53,9 +52,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.root().0),
-            Value::Set(s) => middleware::Value(s.root().0),
-            Value::Array(a) => middleware::Value(a.root().0),
+            Value::Dictionary(d) => middleware::Value(d.commitment().0),
+            Value::Set(s) => middleware::Value(s.commitment().0),
+            Value::Array(a) => middleware::Value(a.commitment().0),
         }
     }
 }
@@ -65,9 +64,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.root()),
-            Value::Set(s) => write!(f, "set:{}", s.root()),
-            Value::Array(a) => write!(f, "arr:{}", a.root()),
+            Value::Dictionary(d) => write!(f, "dict:{}", d.commitment()),
+            Value::Set(s) => write!(f, "set:{}", s.commitment()),
+            Value::Array(a) => write!(f, "arr:{}", a.commitment()),
         }
     }
 }

src/middleware/containers.rs

@@ -6,18 +6,7 @@ use plonky2::plonk::config::Hasher;
 use std::collections::HashMap;
 
 use super::{Hash, Value, EMPTY};
-use crate::primitives::merkletree::{MerkleProof, MerkleTree, MerkleTreeTrait};
-
-/// Container is a wrapper of a MerkleTree, used to achieve Dictionary, Set, Array frontend types.
-/// 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;
-}
+use crate::primitives::merkletree::{MerkleProof, MerkleTree};
 
 /// Dictionary: the user original keys and values are hashed to be used in the leaf.
 ///    leaf.key=hash(original_key)
@@ -28,37 +17,32 @@ pub struct Dictionary {
     pub(crate) mt: MerkleTree,
 }
 
-impl Container for Dictionary {
-    type Raw = HashMap<Hash, Value>;
-
-    fn new(raw: &Self::Raw) -> Self {
-        let kvs: HashMap<Value, Value> = raw.into_iter().map(|(&k, &v)| (Value(k.0), v)).collect();
+impl Dictionary {
+    pub fn new(kvs: &HashMap<Hash, Value>) -> Self {
+        let kvs: HashMap<Value, Value> = kvs.into_iter().map(|(&k, &v)| (Value(k.0), v)).collect();
         Self {
-            mt: MerkleTree::build(&kvs),
+            mt: MerkleTree::new(&kvs),
         }
     }
-}
-
-impl MerkleTreeTrait for Dictionary {
-    fn root(&self) -> Hash {
+    pub fn commitment(&self) -> Hash {
         self.mt.root()
     }
-    fn get(&self, key: &Value) -> Result<Value> {
+    pub fn get(&self, key: &Value) -> Result<Value> {
         self.mt.get(key)
     }
-    fn prove(&self, key: &Value) -> Result<MerkleProof> {
+    pub fn prove(&self, key: &Value) -> Result<MerkleProof> {
         self.mt.prove(key)
     }
-    fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
+    pub fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
         self.mt.prove_nonexistence(key)
     }
-    fn verify(root: Hash, proof: &MerkleProof, key: &Value, value: &Value) -> Result<()> {
+    pub 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<()> {
+    pub 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> {
+    pub fn iter(&self) -> std::collections::hash_map::Iter<Value, Value> {
         self.mt.iter()
     }
 }
@@ -86,43 +70,38 @@ pub struct Set {
     mt: MerkleTree,
 }
 
-impl Container for Set {
-    type Raw = Vec<Value>;
-
-    fn new(raw: &Self::Raw) -> Self {
-        let kvs: HashMap<Value, Value> = raw
+impl Set {
+    pub fn new(set: &Vec<Value>) -> Self {
+        let kvs: HashMap<Value, Value> = set
             .into_iter()
             .map(|e| {
                 let h = PoseidonHash::hash_no_pad(&e.0).elements;
                 (Value(h), EMPTY)
             })
             .collect();
         Self {
-            mt: MerkleTree::build(&kvs),
+            mt: MerkleTree::new(&kvs),
         }
     }
-}
-
-impl MerkleTreeTrait for Set {
-    fn root(&self) -> Hash {
+    pub fn commitment(&self) -> Hash {
         self.mt.root()
     }
-    fn get(&self, key: &Value) -> Result<Value> {
-        self.mt.get(key)
+    pub fn contains(&self, key: &Value) -> bool {
+        self.mt.contains(key)
     }
-    fn prove(&self, key: &Value) -> Result<MerkleProof> {
+    pub fn prove(&self, key: &Value) -> Result<MerkleProof> {
         self.mt.prove(key)
     }
-    fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
+    pub fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
         self.mt.prove_nonexistence(key)
     }
-    fn verify(root: Hash, proof: &MerkleProof, key: &Value, value: &Value) -> Result<()> {
+    pub 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<()> {
+    pub 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> {
+    pub fn iter(&self) -> std::collections::hash_map::Iter<Value, Value> {
         self.mt.iter()
     }
 }
@@ -143,42 +122,31 @@ pub struct Array {
     mt: MerkleTree,
 }
 
-impl Container for Array {
-    type Raw = Vec<Value>;
-
-    fn new(raw: &Self::Raw) -> Self {
-        let kvs: HashMap<Value, Value> = raw
+impl Array {
+    pub fn new(array: &Vec<Value>) -> Self {
+        let kvs: HashMap<Value, Value> = array
             .into_iter()
             .enumerate()
             .map(|(i, &e)| (Value::from(i as i64), e))
             .collect();
 
         Self {
-            mt: MerkleTree::build(&kvs),
+            mt: MerkleTree::new(&kvs),
         }
     }
-}
-
-impl MerkleTreeTrait for Array {
-    fn root(&self) -> Hash {
+    pub fn commitment(&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)
+    pub fn get(&self, i: usize) -> Result<Value> {
+        self.mt.get(&Value::from(i as i64))
     }
-    fn prove_nonexistence(&self, key: &Value) -> Result<MerkleProof> {
-        self.mt.prove_nonexistence(key)
+    pub fn prove(&self, i: usize) -> Result<MerkleProof> {
+        self.mt.prove(&Value::from(i as i64))
     }
-    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)
+    pub fn verify(root: Hash, proof: &MerkleProof, i: usize, value: &Value) -> Result<()> {
+        MerkleTree::verify(root, proof, &Value::from(i as i64), value)
     }
-    fn iter(&self) -> std::collections::hash_map::Iter<Value, Value> {
+    pub fn iter(&self) -> std::collections::hash_map::Iter<Value, Value> {
         self.mt.iter()
     }
 }