From 59595a2e0465ccf7de1893e986bb909176bc23d9 Mon Sep 17 00:00:00 2001 From: "Augusto F. Hack" Date: Fri, 21 Apr 2023 14:45:50 +0200 Subject: [PATCH] feat: added From convertions for the MerkleStore --- benches/store.rs | 32 ++++++++++++-------------------- src/merkle/store/mod.rs | 31 +++++++++++++++++++++++++++++-- src/merkle/store/tests.rs | 33 +++++++++++---------------------- 3 files changed, 52 insertions(+), 44 deletions(-) diff --git a/benches/store.rs b/benches/store.rs index 2ad2790..2319128 100644 --- a/benches/store.rs +++ b/benches/store.rs @@ -34,7 +34,7 @@ fn get_empty_leaf_simplesmt(c: &mut Criterion) { // 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 @@ fn get_leaf_merkletree(c: &mut Criterion) { let mtree_leaves: Vec = 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 @@ fn get_leaf_simplesmt(c: &mut Criterion) { .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 @@ fn get_node_of_empty_simplesmt(c: &mut Criterion) { // 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 @@ fn get_node_merkletree(c: &mut Criterion) { let mtree_leaves: Vec = 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 @@ fn get_node_simplesmt(c: &mut Criterion) { .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 @@ fn get_leaf_path_merkletree(c: &mut Criterion) { let mtree_leaves: Vec = 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 @@ fn get_leaf_path_simplesmt(c: &mut Criterion) { .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 @@ fn new(c: &mut Criterion) { || leaves.iter().map(|v| v.into()).collect::>(), |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 @@ fn new(c: &mut Criterion) { }, |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 @@ fn update_leaf_merkletree(c: &mut Criterion) { let mtree_leaves: Vec = 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 @@ fn update_leaf_simplesmt(c: &mut Criterion) { .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; diff --git a/src/merkle/store/mod.rs b/src/merkle/store/mod.rs index 776da47..8ed03e7 100644 --- a/src/merkle/store/mod.rs +++ b/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}; @@ -393,6 +393,33 @@ impl MerkleStore { } } +// CONVERTIONS +// ================================================================================================ + +impl From for MerkleStore { + fn from(value: MerkleTree) -> Self { + let mut store = MerkleStore::new(); + store.extend(value.inner_nodes()); + store + } +} + +impl From for MerkleStore { + fn from(value: SimpleSmt) -> Self { + let mut store = MerkleStore::new(); + store.extend(value.inner_nodes()); + store + } +} + +impl From for MerkleStore { + fn from(value: Mmr) -> Self { + let mut store = MerkleStore::new(); + store.extend(value.inner_nodes()); + store + } +} + // ITERATORS // ================================================================================================ diff --git a/src/merkle/store/tests.rs b/src/merkle/store/tests.rs index 3df4f21..4c5eeb4 100644 --- a/src/merkle/store/tests.rs +++ b/src/merkle/store/tests.rs @@ -15,8 +15,7 @@ const EMPTY: Word = [ZERO; WORD_SIZE]; #[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 @@ fn test_root_not_in_store() -> Result<(), MerkleError> { #[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 @@ fn test_leaf_paths_for_empty_trees() -> Result<(), MerkleError> { #[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 @@ fn test_add_sparse_merkle_tree_one_level() -> Result<(), MerkleError> { .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 @@ fn test_sparse_merkle_tree() -> Result<(), MerkleError> { .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 @@ fn wont_open_to_different_depth_root() { // 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 @@ fn store_path_opens_from_leaf() { 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 @@ fn store_path_opens_from_leaf() { #[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 @@ fn test_set_node() -> Result<(), MerkleError> { #[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 @@ fn test_constructors() -> Result<(), MerkleError> { .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 @@ fn get_leaf_depth_works_with_depth_8() { #[test] fn test_serialization() -> Result<(), Box> { 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(())