diff --git a/src/merkle/mmr/tests.rs b/src/merkle/mmr/tests.rs index 1973aa5..cb367fc 100644 --- a/src/merkle/mmr/tests.rs +++ b/src/merkle/mmr/tests.rs @@ -1,5 +1,5 @@ use super::{ - super::{InnerNodeInfo, Vec, WORD_SIZE}, + super::{InnerNodeInfo, Vec}, bit::TrueBitPositionIterator, full::{high_bitmask, leaf_to_corresponding_tree, nodes_in_forest}, Mmr, MmrPeaks, Rpo256, @@ -118,38 +118,14 @@ fn test_mmr_simple() { let mut postorder = Vec::new(); postorder.push(LEAVES[0]); postorder.push(LEAVES[1]); - postorder.push(Rpo256::hash_elements( - &[LEAVES[0], LEAVES[1]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - )); + postorder.push(Rpo256::merge(&[LEAVES[0], LEAVES[1]])); postorder.push(LEAVES[2]); postorder.push(LEAVES[3]); - postorder.push(Rpo256::hash_elements( - &[LEAVES[2], LEAVES[3]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - )); - postorder.push(Rpo256::hash_elements( - &[postorder[2], postorder[5]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - )); + postorder.push(Rpo256::merge(&[LEAVES[2], LEAVES[3]])); + postorder.push(Rpo256::merge(&[postorder[2], postorder[5]])); postorder.push(LEAVES[4]); postorder.push(LEAVES[5]); - postorder.push(Rpo256::hash_elements( - &[LEAVES[4], LEAVES[5]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - )); + postorder.push(Rpo256::merge(&[LEAVES[4], LEAVES[5]])); postorder.push(LEAVES[6]); let mut mmr = Mmr::new(); @@ -223,20 +199,8 @@ fn test_mmr_simple() { #[test] fn test_mmr_open() { let mmr: Mmr = LEAVES.into(); - let h01: RpoDigest = Rpo256::hash_elements( - &LEAVES[0..2] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); - let h23: RpoDigest = Rpo256::hash_elements( - &LEAVES[2..4] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); + let h01 = Rpo256::merge(&[LEAVES[0], LEAVES[1]]); + let h23 = Rpo256::merge(&[LEAVES[2], LEAVES[3]]); // node at pos 7 is the root assert!(mmr.open(7).is_err(), "Element 7 is not in the tree, result should be None"); @@ -401,34 +365,10 @@ fn test_mmr_inner_nodes() { let mmr: Mmr = LEAVES.into(); let nodes: Vec = mmr.inner_nodes().collect(); - let h01 = Rpo256::hash_elements( - &[LEAVES[0], LEAVES[1]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); - let h23 = Rpo256::hash_elements( - &[LEAVES[2], LEAVES[3]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); - let h0123 = Rpo256::hash_elements( - &[h01, h23] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); - let h45 = Rpo256::hash_elements( - &[LEAVES[4], LEAVES[5]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); + let h01 = Rpo256::merge(&[LEAVES[0], LEAVES[1]]); + let h23 = Rpo256::merge(&[LEAVES[2], LEAVES[3]]); + let h0123 = Rpo256::merge(&[h01, h23]); + let h45 = Rpo256::merge(&[LEAVES[4], LEAVES[5]]); let postorder = vec![ InnerNodeInfo { value: h01, @@ -461,28 +401,10 @@ fn test_mmr_hash_peaks() { let peaks = mmr.accumulator(); let first_peak = Rpo256::merge(&[ - Rpo256::hash_elements( - &[LEAVES[0], LEAVES[1]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ), - Rpo256::hash_elements( - &[LEAVES[2], LEAVES[3]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ), + Rpo256::merge(&[LEAVES[0], LEAVES[1]]), + Rpo256::merge(&[LEAVES[2], LEAVES[3]]), ]); - let second_peak = Rpo256::hash_elements( - &[LEAVES[4], LEAVES[5]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); + let second_peak = Rpo256::merge(&[LEAVES[4], LEAVES[5]]); let third_peak = LEAVES[6]; // minimum length is 16 @@ -490,14 +412,7 @@ fn test_mmr_hash_peaks() { expected_peaks.resize(16, RpoDigest::default()); assert_eq!( peaks.hash_peaks(), - *Rpo256::hash_elements( - &expected_peaks - .as_slice() - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat() - ) + *Rpo256::hash_elements(&digests_to_elements(&expected_peaks)) ); } @@ -517,14 +432,7 @@ fn test_mmr_peaks_hash_less_than_16() { expected_peaks.resize(16, RpoDigest::default()); assert_eq!( accumulator.hash_peaks(), - *Rpo256::hash_elements( - &expected_peaks - .as_slice() - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat() - ) + *Rpo256::hash_elements(&digests_to_elements(&expected_peaks)) ); } } @@ -543,14 +451,7 @@ fn test_mmr_peaks_hash_odd() { expected_peaks.resize(18, RpoDigest::default()); assert_eq!( accumulator.hash_peaks(), - *Rpo256::hash_elements( - &expected_peaks - .as_slice() - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat() - ) + *Rpo256::hash_elements(&digests_to_elements(&expected_peaks)) ); } @@ -582,3 +483,10 @@ mod property_tests { } } } + +// HELPER FUNCTIONS +// ================================================================================================ + +fn digests_to_elements(digests: &[RpoDigest]) -> Vec { + digests.iter().flat_map(|v| Word::from(v)).collect() +} diff --git a/src/merkle/mod.rs b/src/merkle/mod.rs index 61dad43..8601b60 100644 --- a/src/merkle/mod.rs +++ b/src/merkle/mod.rs @@ -103,6 +103,7 @@ const fn int_to_leaf(value: u64) -> Word { [Felt::new(value), ZERO, ZERO, ZERO] } -pub fn digests_to_words(digests: &[RpoDigest]) -> Vec { +#[cfg(test)] +fn digests_to_words(digests: &[RpoDigest]) -> Vec { digests.iter().map(|d| d.into()).collect() } diff --git a/src/merkle/simple_smt/tests.rs b/src/merkle/simple_smt/tests.rs index 11c9261..ce6b8f3 100644 --- a/src/merkle/simple_smt/tests.rs +++ b/src/merkle/simple_smt/tests.rs @@ -36,7 +36,7 @@ fn build_empty_tree() { // tree of depth 3 let smt = SimpleSmt::new(3).unwrap(); let mt = MerkleTree::new(ZERO_VALUES8.to_vec()).unwrap(); - assert_eq!(mt.root(), smt.root().into()); + assert_eq!(mt.root(), smt.root()); } #[test] @@ -47,10 +47,10 @@ fn build_sparse_tree() { // insert single value let key = 6; let new_node = int_to_leaf(7); - values[key as usize] = new_node.into(); + values[key as usize] = new_node; let old_value = smt.update_leaf(key, new_node).expect("Failed to update leaf"); let mt2 = MerkleTree::new(values.clone()).unwrap(); - assert_eq!(mt2.root(), smt.root().into()); + assert_eq!(mt2.root(), smt.root()); assert_eq!( mt2.get_path(NodeIndex::make(3, 6)).unwrap(), smt.get_path(NodeIndex::make(3, 6)).unwrap() @@ -63,7 +63,7 @@ fn build_sparse_tree() { values[key as usize] = new_node; let old_value = smt.update_leaf(key, new_node).expect("Failed to update leaf"); let mt3 = MerkleTree::new(values).unwrap(); - assert_eq!(mt3.root(), smt.root().into()); + assert_eq!(mt3.root(), smt.root()); assert_eq!( mt3.get_path(NodeIndex::make(3, 2)).unwrap(), smt.get_path(NodeIndex::make(3, 2)).unwrap() @@ -90,10 +90,10 @@ fn test_depth2_tree() { assert_eq!(VALUES4[3], tree.get_node(NodeIndex::make(2, 3)).unwrap()); // check get_path(): depth 2 - assert_eq!(vec![VALUES4[1].into(), node3], *tree.get_path(NodeIndex::make(2, 0)).unwrap()); - assert_eq!(vec![VALUES4[0].into(), node3], *tree.get_path(NodeIndex::make(2, 1)).unwrap()); - assert_eq!(vec![VALUES4[3].into(), node2], *tree.get_path(NodeIndex::make(2, 2)).unwrap()); - assert_eq!(vec![VALUES4[2].into(), node2], *tree.get_path(NodeIndex::make(2, 3)).unwrap()); + assert_eq!(vec![VALUES4[1], node3], *tree.get_path(NodeIndex::make(2, 0)).unwrap()); + assert_eq!(vec![VALUES4[0], node3], *tree.get_path(NodeIndex::make(2, 1)).unwrap()); + assert_eq!(vec![VALUES4[3], node2], *tree.get_path(NodeIndex::make(2, 2)).unwrap()); + assert_eq!(vec![VALUES4[2], node2], *tree.get_path(NodeIndex::make(2, 3)).unwrap()); // check get_path(): depth 1 assert_eq!(vec![node3], *tree.get_path(NodeIndex::make(1, 0)).unwrap()); @@ -189,15 +189,15 @@ fn small_tree_opening_is_consistent() { let c = Word::from(Rpo256::merge(&[b.into(); 2])); let d = Word::from(Rpo256::merge(&[c.into(); 2])); - let e = RpoDigest::from(Rpo256::merge(&[a.into(), b.into()])); - let f = RpoDigest::from(Rpo256::merge(&[z.into(), z.into()])); - let g = RpoDigest::from(Rpo256::merge(&[c.into(), z.into()])); - let h = RpoDigest::from(Rpo256::merge(&[z.into(), d.into()])); + let e = Rpo256::merge(&[a.into(), b.into()]); + let f = Rpo256::merge(&[z.into(), z.into()]); + let g = Rpo256::merge(&[c.into(), z.into()]); + let h = Rpo256::merge(&[z.into(), d.into()]); - let i = RpoDigest::from(Rpo256::merge(&[e.into(), f.into()])); - let j = RpoDigest::from(Rpo256::merge(&[g.into(), h.into()])); + let i = Rpo256::merge(&[e, f]); + let j = Rpo256::merge(&[g, h]); - let k = RpoDigest::from(Rpo256::merge(&[i.into(), j.into()])); + let k = Rpo256::merge(&[i, j]); let depth = 3; let entries = vec![(0, a), (1, b), (4, c), (7, d)]; @@ -255,21 +255,9 @@ fn with_no_duplicates_empty_node() { // -------------------------------------------------------------------------------------------- fn compute_internal_nodes() -> (RpoDigest, RpoDigest, RpoDigest) { - let node2 = Rpo256::hash_elements( - &[VALUES4[0], VALUES4[1]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); - let node3 = Rpo256::hash_elements( - &[VALUES4[2], VALUES4[3]] - .iter() - .map(|digest| digest.into()) - .collect::>() - .concat(), - ); + let node2 = Rpo256::merge(&[VALUES4[0], VALUES4[1]]); + let node3 = Rpo256::merge(&[VALUES4[2], VALUES4[3]]); let root = Rpo256::merge(&[node2, node3]); - (root.into(), node2.into(), node3.into()) + (root, node2, node3) } diff --git a/src/merkle/store/tests.rs b/src/merkle/store/tests.rs index 9101f1b..1bc5db9 100644 --- a/src/merkle/store/tests.rs +++ b/src/merkle/store/tests.rs @@ -485,7 +485,6 @@ fn wont_open_to_different_depth_root() { for depth in (1..=63).rev() { root = Rpo256::merge(&[root, empty[depth]]); } - let root = RpoDigest::from(root); // 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 @@ -513,16 +512,16 @@ fn store_path_opens_from_leaf() { let k = Rpo256::merge(&[e.into(), f.into()]); let l = Rpo256::merge(&[g.into(), h.into()]); - let m = Rpo256::merge(&[i.into(), j.into()]); - let n = Rpo256::merge(&[k.into(), l.into()]); + let m = Rpo256::merge(&[i, j]); + let n = Rpo256::merge(&[k, l]); - let root = Rpo256::merge(&[m.into(), n.into()]); + let root = Rpo256::merge(&[m, n]); let mtree = MerkleTree::new(vec![a, b, c, d, e, f, g, h]).unwrap(); let store = MerkleStore::from(&mtree); let path = store.get_path(root, NodeIndex::make(3, 1)).unwrap().path; - let expected = MerklePath::new([a.into(), j.into(), n.into()].to_vec()); + let expected = MerklePath::new([a.into(), j, n].to_vec()); assert_eq!(path, expected); } diff --git a/src/merkle/tiered_smt/tests.rs b/src/merkle/tiered_smt/tests.rs index b4fbd77..894c628 100644 --- a/src/merkle/tiered_smt/tests.rs +++ b/src/merkle/tiered_smt/tests.rs @@ -21,7 +21,7 @@ fn tsmt_insert_one() { smt.insert(key, value); - assert_eq!(smt.root(), tree_root.into()); + assert_eq!(smt.root(), tree_root); // make sure the value was inserted, and the node is at the expected index assert_eq!(smt.get_value(key), value); @@ -74,16 +74,16 @@ fn tsmt_insert_two_16() { // --- verify that data is consistent between store and tree -------------- - assert_eq!(smt.root(), tree_root.into()); + assert_eq!(smt.root(), tree_root); assert_eq!(smt.get_value(key_a), val_a); assert_eq!(smt.get_node(index_a).unwrap(), leaf_node_a); - let expected_path = store.get_path(tree_root.into(), index_a).unwrap().path; + let expected_path = store.get_path(tree_root, index_a).unwrap().path; assert_eq!(smt.get_path(index_a).unwrap(), expected_path); assert_eq!(smt.get_value(key_b), val_b); assert_eq!(smt.get_node(index_b).unwrap(), leaf_node_b); - let expected_path = store.get_path(tree_root.into(), index_b).unwrap().path; + let expected_path = store.get_path(tree_root, index_b).unwrap().path; assert_eq!(smt.get_path(index_b).unwrap(), expected_path); // make sure inner nodes match - the store contains more entries because it keeps track of @@ -130,16 +130,16 @@ fn tsmt_insert_two_32() { // --- verify that data is consistent between store and tree -------------- - assert_eq!(smt.root(), tree_root.into()); + assert_eq!(smt.root(), tree_root); assert_eq!(smt.get_value(key_a), val_a); assert_eq!(smt.get_node(index_a).unwrap(), leaf_node_a); - let expected_path = store.get_path(tree_root.into(), index_a).unwrap().path; + let expected_path = store.get_path(tree_root, index_a).unwrap().path; assert_eq!(smt.get_path(index_a).unwrap(), expected_path); assert_eq!(smt.get_value(key_b), val_b); assert_eq!(smt.get_node(index_b).unwrap(), leaf_node_b); - let expected_path = store.get_path(tree_root.into(), index_b).unwrap().path; + let expected_path = store.get_path(tree_root, index_b).unwrap().path; assert_eq!(smt.get_path(index_b).unwrap(), expected_path); // make sure inner nodes match - the store contains more entries because it keeps track of @@ -193,21 +193,21 @@ fn tsmt_insert_three() { // --- verify that data is consistent between store and tree -------------- - assert_eq!(smt.root(), tree_root.into()); + assert_eq!(smt.root(), tree_root); assert_eq!(smt.get_value(key_a), val_a); assert_eq!(smt.get_node(index_a).unwrap(), leaf_node_a); - let expected_path = store.get_path(tree_root.into(), index_a).unwrap().path; + let expected_path = store.get_path(tree_root, index_a).unwrap().path; assert_eq!(smt.get_path(index_a).unwrap(), expected_path); assert_eq!(smt.get_value(key_b), val_b); assert_eq!(smt.get_node(index_b).unwrap(), leaf_node_b); - let expected_path = store.get_path(tree_root.into(), index_b).unwrap().path; + let expected_path = store.get_path(tree_root, index_b).unwrap().path; assert_eq!(smt.get_path(index_b).unwrap(), expected_path); assert_eq!(smt.get_value(key_c), val_c); assert_eq!(smt.get_node(index_c).unwrap(), leaf_node_c); - let expected_path = store.get_path(tree_root.into(), index_c).unwrap().path; + let expected_path = store.get_path(tree_root, index_c).unwrap().path; assert_eq!(smt.get_path(index_c).unwrap(), expected_path); // make sure inner nodes match - the store contains more entries because it keeps track of @@ -238,11 +238,11 @@ fn tsmt_update() { let leaf_node = build_leaf_node(key, value_b, 16); tree_root = store.set_node(tree_root, index, leaf_node).unwrap().root; - assert_eq!(smt.root(), tree_root.into()); + assert_eq!(smt.root(), tree_root); assert_eq!(smt.get_value(key), value_b); assert_eq!(smt.get_node(index).unwrap(), leaf_node); - let expected_path = store.get_path(tree_root.into(), index).unwrap().path; + let expected_path = store.get_path(tree_root, index).unwrap().path; assert_eq!(smt.get_path(index).unwrap(), expected_path); // make sure inner nodes match - the store contains more entries because it keeps track of @@ -285,13 +285,13 @@ fn tsmt_bottom_tier() { // --- verify that data is consistent between store and tree -------------- - assert_eq!(smt.root(), tree_root.into()); + assert_eq!(smt.root(), tree_root); assert_eq!(smt.get_value(key_a), val_a); assert_eq!(smt.get_value(key_b), val_b); assert_eq!(smt.get_node(index).unwrap(), leaf_node); - let expected_path = store.get_path(tree_root.into(), index).unwrap().path; + let expected_path = store.get_path(tree_root, index).unwrap().path; assert_eq!(smt.get_path(index).unwrap(), expected_path); // make sure inner nodes match - the store contains more entries because it keeps track of @@ -337,16 +337,16 @@ fn tsmt_bottom_tier_two() { // --- verify that data is consistent between store and tree -------------- - assert_eq!(smt.root(), tree_root.into()); + assert_eq!(smt.root(), tree_root); assert_eq!(smt.get_value(key_a), val_a); assert_eq!(smt.get_node(index_a).unwrap(), leaf_node_a); - let expected_path = store.get_path(tree_root.into(), index_a).unwrap().path; + let expected_path = store.get_path(tree_root, index_a).unwrap().path; assert_eq!(smt.get_path(index_a).unwrap(), expected_path); assert_eq!(smt.get_value(key_b), val_b); assert_eq!(smt.get_node(index_b).unwrap(), leaf_node_b); - let expected_path = store.get_path(tree_root.into(), index_b).unwrap().path; + let expected_path = store.get_path(tree_root, index_b).unwrap().path; assert_eq!(smt.get_path(index_b).unwrap(), expected_path); // make sure inner nodes match - the store contains more entries because it keeps track of