Implement Containers (Dictionary,Set,Array) on top of MerkleTree. And restructure the code.

- Reorganize the code grouping backends, middleware, frontend, (crypto) primitives.
- Add containers (Dictionary,Set,Array) at the middleware layer, so that
  it can be used both by the backend and frontend. The Dictionary, Set,
  Array use the merkletree differently as specified at
https://github.com/0xPARC/pod2/blob/f2575d1524c9e15a5b688eb444ee3c39df242c81/book/src/values.md#dictionary-array-set
	- The containers introduce the trait Container, which has the
	  method 'cm()'. At the current version this uses a merkletree
	  under the hood, and the method 'cm' returns the merkle root.
- Ideally neither frontend nor backend use the MerkleTree type, and they
  use the wrappers {Dictionary,Set,Array}. Note that the current commit
  the MerkleTree is used at the mock-backend to check internal values, but
  not at the struct types.
- updated the spec's merkletree section updating the defined interface

Author: arnaucube

book/src/merkletree.md

@@ -149,12 +149,15 @@ impl MerkleTree {
     fn new(kvs: HashMap<Value, Value>) -> Self;
 
     /// returns the root of the tree
-    fn root(&self) -> Result<Hash>;
+    fn root(&self) -> Hash;
+    
+    /// returns the value at the given key
+    pub fn get(&self, key: &Value) -> Value;
 
     /// returns a proof of existence, which proves that the given key exists in
     /// the tree. It returns the `value` of the leaf at the given `key`, and
     /// the `MerkleProof`.
-    fn prove(&self, key: &Value) -> Result<(Value, 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

book/src/values.md

@@ -59,7 +59,6 @@ The array, set and dictionary types are similar types. While all of them use [a
 
 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.
 
-
 <br><br>
 
 ---

src/backends/mock_main.rs

@@ -9,7 +9,6 @@ use plonky2::hash::poseidon::PoseidonHash;
 use plonky2::plonk::config::Hasher;
 use std::any::Any;
 use std::fmt;
-use std::io::{self, Write};
 
 pub struct MockProver {}
 

src/backends/mock_signed.rs

@@ -1,7 +1,8 @@
-use crate::merkletree::MerkleTree;
 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 anyhow::Result;
 use std::any::Any;
 use std::collections::HashMap;
@@ -17,41 +18,46 @@ impl PodSigner for MockSigner {
         kvs.insert(hash_str(&KEY_SIGNER), Value(pk_hash.0));
         kvs.insert(hash_str(&KEY_TYPE), Value::from(PodType::MockSigned));
 
-        let mt = MerkleTree::new(&kvs);
-        let id = PodId(mt.root()?);
+        let dict = Dictionary::new(&kvs);
+        let id = PodId(dict.cm());
         let signature = format!("{}_signed_by_{}", id, pk_hash);
-        Ok(Box::new(MockSignedPod { mt, id, signature }))
+        Ok(Box::new(MockSignedPod {
+            dict,
+            id,
+            signature,
+        }))
     }
 }
 
 #[derive(Clone, Debug)]
 pub struct MockSignedPod {
     id: PodId,
     signature: String,
-    mt: MerkleTree,
+    dict: Dictionary,
 }
 
 impl SignedPod for MockSignedPod {
     fn verify(&self) -> bool {
         // Verify type
-        if Some(&Value::from(PodType::MockSigned)) != self.mt.kvs().get(&hash_str(&KEY_TYPE)) {
+        let value_at_type = match self.dict.mt.get(&hash_str(&KEY_TYPE).into()) {
+            Ok(v) => v,
+            Err(_) => return false,
+        };
+        if Value::from(PodType::MockSigned) != value_at_type {
             return false;
         }
 
         // Verify id
-        let mt = MerkleTree::new(&self.mt.kvs());
-        let id = match mt.root() {
-            Ok(id) => PodId(id),
-            Err(_) => return false,
-        };
+        let mt = MerkleTree::new(&self.dict.mt.kvs);
+        let id = PodId(mt.root());
         if id != self.id {
             return false;
         }
 
         // Verify signature
-        let pk_hash = match self.mt.kvs().get(&hash_str(&KEY_SIGNER)) {
-            Some(v) => v,
-            None => return false,
+        let pk_hash = match self.dict.mt.get(&hash_str(&KEY_SIGNER).into()) {
+            Ok(v) => v,
+            Err(_) => return false,
         };
         let signature = format!("{}_signed_by_{}", id, pk_hash);
         if signature != self.signature {
@@ -66,7 +72,11 @@ impl SignedPod for MockSignedPod {
     }
 
     fn kvs(&self) -> HashMap<Hash, Value> {
-        self.mt.kvs().clone()
+        self.dict
+            .mt
+            .into_iter()
+            .map(|(&k, &v)| (Hash(k.0), v))
+            .collect()
     }
 
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
@@ -108,15 +118,23 @@ pub mod tests {
         let mut bad_pod = pod.clone();
         let mut bad_kvs = bad_pod.kvs();
         bad_kvs.insert(hash_str(KEY_SIGNER), Value(PodId(NULL).0 .0));
-        let bad_mt = MerkleTree::new(&bad_kvs);
-        bad_pod.mt = bad_mt;
+        let bad_kvs_mt = &bad_kvs
+            .into_iter()
+            .map(|(k, v)| (Value(k.0), v))
+            .collect::<HashMap<Value, Value>>();
+        let bad_mt = MerkleTree::new(&bad_kvs_mt);
+        bad_pod.dict.mt = bad_mt;
         assert_eq!(bad_pod.verify(), false);
 
         let mut bad_pod = pod.clone();
         let mut bad_kvs = bad_pod.kvs();
         bad_kvs.insert(hash_str(KEY_TYPE), Value::from(0));
-        let bad_mt = MerkleTree::new(&bad_kvs);
-        bad_pod.mt = bad_mt;
+        let bad_kvs_mt = &bad_kvs
+            .into_iter()
+            .map(|(k, v)| (Value(k.0), v))
+            .collect::<HashMap<Value, Value>>();
+        let bad_mt = MerkleTree::new(&bad_kvs_mt);
+        bad_pod.dict.mt = bad_mt;
         assert_eq!(bad_pod.verify(), false);
     }
 }

src/backends.rs src/backends/mod.rssrc/backends.rs renamed to src/backends/mod.rs

@@ -1,5 +1,10 @@
-use crate::frontend::{MainPodBuilder, MerkleTree, SignedPod, SignedPodBuilder, Value};
-use crate::middleware::{Params, PodType, KEY_SIGNER, KEY_TYPE};
+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::op;
 
 // ZuKYC
@@ -22,7 +27,7 @@ pub fn zu_kyc_pod_builder(
     gov_id: &SignedPod,
     pay_stub: &SignedPod,
 ) -> MainPodBuilder {
-    let sanction_list = Value::MerkleTree(MerkleTree { root: 1 });
+    let sanction_list = Value::Dictionary(Dictionary::new(&HashMap::new())); // empty dictionary
     let now_minus_18y: i64 = 1169909388;
     let now_minus_1y: i64 = 1706367566;
 
@@ -178,7 +183,7 @@ pub fn great_boy_pod_full_flow() -> MainPodBuilder {
     alice_friend_pods.push(friend.sign(&mut bob_signer).unwrap());
     alice_friend_pods.push(friend.sign(&mut charlie_signer).unwrap());
 
-    let good_boy_issuers_mt = Value::MerkleTree(MerkleTree { root: 33 });
+    let good_boy_issuers_dict = Value::Dictionary(Dictionary::new(&HashMap::new())); // empty
     great_boy_pod_builder(
         &params,
         [
@@ -188,7 +193,7 @@ pub fn great_boy_pod_full_flow() -> MainPodBuilder {
             &charlie_good_boys[1],
         ],
         [&alice_friend_pods[0], &alice_friend_pods[1]],
-        &good_boy_issuers_mt,
+        &good_boy_issuers_dict,
         alice,
     )
 }

src/examples.rs

@@ -3,14 +3,15 @@
 
 use anyhow::Result;
 use itertools::Itertools;
-use plonky2::field::types::Field;
 use std::collections::HashMap;
 use std::convert::From;
 use std::fmt;
 
 use crate::middleware::{
-    self, hash_str, Hash, MainPodInputs, NativeOperation, NativeStatement, Params, PodId,
-    PodProver, PodSigner, F, SELF,
+    self,
+    containers::{Array, Container, Dictionary, Set},
+    hash_str, Hash, MainPodInputs, NativeOperation, NativeStatement, Params, PodId, PodProver,
+    PodSigner, SELF,
 };
 
 /// This type is just for presentation purposes.
@@ -25,16 +26,13 @@ pub enum PodClass {
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Default)]
 pub struct Origin(pub PodClass, pub PodId);
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct MerkleTree {
-    pub root: u8, // TODO
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Value {
     String(String),
     Int(i64),
-    MerkleTree(MerkleTree),
+    Dictionary(Dictionary),
+    Set(Set),
+    Array(Array),
 }
 
 impl From<&str> for Value {
@@ -54,13 +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),
-            // TODO
-            Value::MerkleTree(mt) => middleware::Value([
-                F::from_canonical_u64(mt.root as u64),
-                F::ZERO,
-                F::ZERO,
-                F::ZERO,
-            ]),
+            Value::Dictionary(d) => middleware::Value(d.cm().0),
+            Value::Set(s) => middleware::Value(s.cm().0),
+            Value::Array(a) => middleware::Value(a.cm().0),
         }
     }
 }
@@ -70,7 +64,9 @@ impl fmt::Display for Value {
         match self {
             Value::String(s) => write!(f, "\"{}\"", s),
             Value::Int(v) => write!(f, "{}", v),
-            Value::MerkleTree(mt) => write!(f, "mt:{}", mt.root),
+            Value::Dictionary(d) => write!(f, "dict:{}", d.cm()),
+            Value::Set(s) => write!(f, "set:{}", s.cm()),
+            Value::Array(a) => write!(f, "arr:{}", a.cm()),
         }
     }
 }

src/frontend.rs

@@ -1,7 +1,7 @@
 pub mod backends;
 pub mod frontend;
-pub mod merkletree;
 pub mod middleware;
+pub mod primitives;
 
 #[cfg(test)]
 pub mod examples;

src/lib.rs

@@ -0,0 +1,120 @@
+/// This file implements the types defined at
+/// https://0xparc.github.io/pod2/values.html#dictionary-array-set .
+use plonky2::hash::poseidon::PoseidonHash;
+use plonky2::plonk::config::Hasher;
+use std::collections::HashMap;
+
+use super::{Hash, Value, EMPTY};
+use crate::primitives::merkletree::MerkleTree;
+
+/// Contaiter is a wrapper of a MerkleTree, used to achieve Dictionary, Set, Array frontend types.
+pub trait Container {
+    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,
+}
+
+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();
+        Self {
+            mt: MerkleTree::new(&kvs),
+        }
+    }
+
+    fn cm(&self) -> Hash {
+        self.mt.root()
+    }
+}
+
+impl PartialEq for Dictionary {
+    fn eq(&self, other: &Self) -> bool {
+        self.mt.root() == other.mt.root() && self.mt.root() == other.mt.root()
+    }
+}
+impl Eq for Dictionary {}
+
+/// 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
+#[derive(Clone, Debug)]
+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
+            .into_iter()
+            .map(|e| {
+                let h = PoseidonHash::hash_no_pad(&e.0).elements;
+                (Value(h), EMPTY)
+            })
+            .collect();
+        Self {
+            mt: MerkleTree::new(&kvs),
+        }
+    }
+
+    fn cm(&self) -> Hash {
+        self.mt.root()
+    }
+}
+
+impl PartialEq for Set {
+    fn eq(&self, other: &Self) -> bool {
+        self.mt.root() == other.mt.root() && self.mt.root() == other.mt.root()
+    }
+}
+impl Eq for Set {}
+
+/// Array: the elements are placed at the value field of each leaf, and the key field is just the
+/// array index (integer).
+///    leaf.key=i
+///    leaf.value=original_value
+#[derive(Clone, Debug)]
+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
+            .into_iter()
+            .enumerate()
+            .map(|(i, &e)| (Value::from(i as i64), e))
+            .collect();
+
+        Self {
+            mt: MerkleTree::new(&kvs),
+        }
+    }
+
+    fn cm(&self) -> Hash {
+        self.mt.root()
+    }
+}
+
+impl PartialEq for Array {
+    fn eq(&self, other: &Self) -> bool {
+        self.mt.root() == other.mt.root() && self.mt.root() == other.mt.root()
+    }
+}
+impl Eq for Array {}