M benches/store.rs → benches/store.rs

@@ -34,7 +34,7 @@
     // both SMT and the store are pre-populated with empty hashes, accessing these values is what is
     // being benchmarked here, so no values are inserted into the backends
     let smt = SimpleSmt::new(depth).unwrap();
-    let store = MerkleStore::new();
+    let store: MerkleStore = smt.clone().into();
     let root = smt.root();
 
     group.bench_function(BenchmarkId::new("SimpleSmt", depth), |b| {
@@ -66,8 +66,7 @@ let leaves = &random_data[..size];
 
         let mtree_leaves: Vec<Word> = leaves.iter().map(|v| v.into()).collect();
         let mtree = MerkleTree::new(mtree_leaves.clone()).unwrap();
-        let mut store = MerkleStore::new();
-        store.extend(mtree.inner_nodes());
+        let store: MerkleStore = mtree.clone().into();
         let depth = mtree.depth();
         let root = mtree.root();
         let size_u64 = size as u64;
@@ -109,8 +108,7 @@ let smt = SimpleSmt::new(SimpleSmt::MAX_DEPTH)
             .unwrap()
             .with_leaves(smt_leaves.clone())
             .unwrap();
-        let mut store = MerkleStore::new();
-        store.extend(smt.inner_nodes());
+        let store: MerkleStore = smt.clone().into();
         let depth = smt.depth();
         let root = smt.root();
         let size_u64 = size as u64;
@@ -143,7 +141,7 @@ // both SMT and the store are pre-populated with the empty hashes, accessing the internal nodes
     // of these values is what is being benchmarked here, so no values are inserted into the
     // backends.
     let smt = SimpleSmt::new(depth).unwrap();
-    let store = MerkleStore::new();
+    let store: MerkleStore = smt.clone().into();
     let root = smt.root();
     let half_depth = depth / 2;
     let half_size = 2_u64.pow(half_depth as u32);
@@ -178,8 +176,7 @@ let leaves = &random_data[..size];
 
         let mtree_leaves: Vec<Word> = leaves.iter().map(|v| v.into()).collect();
         let mtree = MerkleTree::new(mtree_leaves.clone()).unwrap();
-        let mut store = MerkleStore::new();
-        store.extend(mtree.inner_nodes());
+        let store: MerkleStore = mtree.clone().into();
         let root = mtree.root();
         let half_depth = mtree.depth() / 2;
         let half_size = 2_u64.pow(half_depth as u32);
@@ -222,8 +219,7 @@ let smt = SimpleSmt::new(SimpleSmt::MAX_DEPTH)
             .unwrap()
             .with_leaves(smt_leaves.clone())
             .unwrap();
-        let mut store = MerkleStore::new();
-        store.extend(smt.inner_nodes());
+        let store: MerkleStore = smt.clone().into();
         let root = smt.root();
         let half_depth = smt.depth() / 2;
         let half_size = 2_u64.pow(half_depth as u32);
@@ -258,8 +254,7 @@ let leaves = &random_data[..size];
 
         let mtree_leaves: Vec<Word> = leaves.iter().map(|v| v.into()).collect();
         let mtree = MerkleTree::new(mtree_leaves.clone()).unwrap();
-        let mut store = MerkleStore::new();
-        store.extend(mtree.inner_nodes());
+        let store: MerkleStore = mtree.clone().into();
         let depth = mtree.depth();
         let root = mtree.root();
         let size_u64 = size as u64;
@@ -301,8 +296,7 @@ let smt = SimpleSmt::new(SimpleSmt::MAX_DEPTH)
             .unwrap()
             .with_leaves(smt_leaves.clone())
             .unwrap();
-        let mut store = MerkleStore::new();
-        store.extend(smt.inner_nodes());
+        let store: MerkleStore = smt.clone().into();
         let depth = smt.depth();
         let root = smt.root();
         let size_u64 = size as u64;
@@ -352,7 +346,7 @@ b.iter_batched(
                 || leaves.iter().map(|v| v.into()).collect::<Vec<Word>>(),
                 |l| {
                     let mtree = MerkleTree::new(l).unwrap();
-                    black_box(MerkleStore::new().extend(mtree.inner_nodes()));
+                    black_box(MerkleStore::from(mtree));
                 },
                 BatchSize::SmallInput,
             )
@@ -383,7 +377,7 @@ .collect::<Vec<(u64, Word)>>()
                 },
                 |l| {
                     let smt = SimpleSmt::new(SimpleSmt::MAX_DEPTH).unwrap().with_leaves(l).unwrap();
-                    black_box(MerkleStore::new().extend(smt.inner_nodes()));
+                    black_box(MerkleStore::from(smt));
                 },
                 BatchSize::SmallInput,
             )
@@ -403,8 +397,7 @@ let leaves = &random_data[..size];
 
         let mtree_leaves: Vec<Word> = leaves.iter().map(|v| v.into()).collect();
         let mut mtree = MerkleTree::new(mtree_leaves.clone()).unwrap();
-        let mut store = MerkleStore::new();
-        store.extend(mtree.inner_nodes());
+        let mut store: MerkleStore = mtree.clone().into();
         let depth = mtree.depth();
         let root = mtree.root();
         let size_u64 = size as u64;
@@ -453,8 +446,7 @@ let mut smt = SimpleSmt::new(SimpleSmt::MAX_DEPTH)
             .unwrap()
             .with_leaves(smt_leaves.clone())
             .unwrap();
-        let mut store = MerkleStore::new();
-        store.extend(smt.inner_nodes());
+        let mut store: MerkleStore = smt.clone().into();
         let depth = smt.depth();
         let root = smt.root();
         let size_u64 = size as u64;

M src/merkle/store/mod.rs → src/merkle/store/mod.rs

@@ -1,7 +1,7 @@
 use super::mmr::Mmr;
 use super::{
-    BTreeMap, EmptySubtreeRoots, InnerNodeInfo, MerkleError, MerklePath, MerklePathSet, NodeIndex,
-    RootPath, Rpo256, RpoDigest, ValuePath, Vec, Word,
+    BTreeMap, EmptySubtreeRoots, InnerNodeInfo, MerkleError, MerklePath, MerklePathSet, MerkleTree,
+    NodeIndex, RootPath, Rpo256, RpoDigest, SimpleSmt, ValuePath, Vec, Word,
 };
 use crate::utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
 
@@ -390,6 +390,33 @@ let parent = Rpo256::merge(&[left, right]);
         self.nodes.insert(parent, Node { left, right });
 
         Ok(parent.into())
+    }
+}
+
+// CONVERTIONS
+// ================================================================================================
+
+impl From<MerkleTree> for MerkleStore {
+    fn from(value: MerkleTree) -> Self {
+        let mut store = MerkleStore::new();
+        store.extend(value.inner_nodes());
+        store
+    }
+}
+
+impl From<SimpleSmt> for MerkleStore {
+    fn from(value: SimpleSmt) -> Self {
+        let mut store = MerkleStore::new();
+        store.extend(value.inner_nodes());
+        store
+    }
+}
+
+impl From<Mmr> for MerkleStore {
+    fn from(value: Mmr) -> Self {
+        let mut store = MerkleStore::new();
+        store.extend(value.inner_nodes());
+        store
     }
 }
 

M src/merkle/store/tests.rs → src/merkle/store/tests.rs

@@ -15,8 +15,7 @@
 #[test]
 fn test_root_not_in_store() -> Result<(), MerkleError> {
     let mtree = MerkleTree::new(LEAVES4.to_vec())?;
-    let mut store = MerkleStore::new();
-    store.extend(mtree.inner_nodes());
+    let store: MerkleStore = mtree.clone().into();
     assert_eq!(
         store.get_node(LEAVES4[0], NodeIndex::make(mtree.depth(), 0)),
         Err(MerkleError::RootNotInStore(LEAVES4[0])),
@@ -34,8 +33,7 @@
 #[test]
 fn test_merkle_tree() -> Result<(), MerkleError> {
     let mtree = MerkleTree::new(LEAVES4.to_vec())?;
-    let mut store = MerkleStore::default();
-    store.extend(mtree.inner_nodes());
+    let store: MerkleStore = mtree.clone().into();
 
     // STORE LEAVES ARE CORRECT ==============================================================
     // checks the leaves in the store corresponds to the expected values
@@ -177,8 +175,7 @@
 #[test]
 fn test_get_invalid_node() {
     let mtree = MerkleTree::new(LEAVES4.to_vec()).expect("creating a merkle tree must work");
-    let mut store = MerkleStore::default();
-    store.extend(mtree.inner_nodes());
+    let store: MerkleStore = mtree.clone().into();
     let _ = store.get_node(mtree.root(), NodeIndex::make(mtree.depth(), 3));
 }
 
@@ -190,8 +187,7 @@ let smt = SimpleSmt::new(1)
         .unwrap()
         .with_leaves(keys2.into_iter().zip(leaves2.into_iter()))
         .unwrap();
-    let mut store = MerkleStore::default();
-    store.extend(smt.inner_nodes());
+    let store: MerkleStore = smt.clone().into();
 
     let idx = NodeIndex::make(1, 0);
     assert_eq!(smt.get_node(idx).unwrap(), leaves2[0]);
@@ -211,8 +207,7 @@ .unwrap()
         .with_leaves(KEYS4.into_iter().zip(LEAVES4.into_iter()))
         .unwrap();
 
-    let mut store = MerkleStore::default();
-    store.extend(smt.inner_nodes());
+    let store: MerkleStore = smt.clone().into();
 
     // STORE LEAVES ARE CORRECT ==============================================================
     // checks the leaves in the store corresponds to the expected values
@@ -470,8 +465,7 @@ // For this example, the depth of the Merkle tree is 1, as we have only two leaves. Here we
     // attempt to fetch a node on the maximum depth, and it should fail because the root shouldn't
     // exist for the set.
     let mtree = MerkleTree::new(vec![a, b]).unwrap();
-    let mut store = MerkleStore::new();
-    store.extend(mtree.inner_nodes());
+    let store: MerkleStore = mtree.clone().into();
     let index = NodeIndex::root();
     let err = store.get_node(root, index).err().unwrap();
     assert_eq!(err, MerkleError::RootNotInStore(root));
@@ -499,8 +493,7 @@
     let root = Rpo256::merge(&[m.into(), n.into()]);
 
     let mtree = MerkleTree::new(vec![a, b, c, d, e, f, g, h]).unwrap();
-    let mut store = MerkleStore::new();
-    store.extend(mtree.inner_nodes());
+    let store: MerkleStore = mtree.clone().into();
     let path = store.get_path(root.into(), NodeIndex::make(3, 1)).unwrap().path;
 
     let expected = MerklePath::new([a.into(), j.into(), n.into()].to_vec());
@@ -510,8 +503,7 @@
 #[test]
 fn test_set_node() -> Result<(), MerkleError> {
     let mtree = MerkleTree::new(LEAVES4.to_vec())?;
-    let mut store = MerkleStore::new();
-    store.extend(mtree.inner_nodes());
+    let mut store: MerkleStore = mtree.clone().into();
     let value = int_to_node(42);
     let index = NodeIndex::make(mtree.depth(), 0);
     let new_root = store.set_node(mtree.root(), index, value)?.root;
@@ -523,8 +515,7 @@
 #[test]
 fn test_constructors() -> Result<(), MerkleError> {
     let mtree = MerkleTree::new(LEAVES4.to_vec())?;
-    let mut store = MerkleStore::new();
-    store.extend(mtree.inner_nodes());
+    let store: MerkleStore = mtree.clone().into();
 
     let depth = mtree.depth();
     let leaves = 2u64.pow(depth.into());
@@ -539,8 +530,7 @@ let smt = SimpleSmt::new(depth)
         .unwrap()
         .with_leaves(KEYS4.into_iter().zip(LEAVES4.into_iter()))
         .unwrap();
-    let mut store = MerkleStore::new();
-    store.extend(smt.inner_nodes());
+    let store: MerkleStore = smt.clone().into();
     let depth = smt.depth();
 
     for key in KEYS4 {
@@ -730,8 +720,7 @@ #[cfg(std)]
 #[test]
 fn test_serialization() -> Result<(), Box<dyn Error>> {
     let mtree = MerkleTree::new(LEAVES4.to_vec())?;
-    let mut store = MerkleStore::new();
-    store.extend(mtree.inner_nodes());
+    let store: MerkleStore = mtree.clone().into();
     let decoded = MerkleStore::read_from_bytes(&original.to_bytes())?;
     assert_eq!(original, decoded);
     Ok(())