@@ -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::<Vec<[Felt; WORD_SIZE]>>()
-            .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::<Vec<[Felt; WORD_SIZE]>>()
-            .concat(),
-    ));
-    postorder.push(Rpo256::hash_elements(
-        &[postorder[2], postorder[5]]
-            .iter()
-            .map(|digest| digest.into())
-            .collect::<Vec<[Felt; WORD_SIZE]>>()
-            .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::<Vec<[Felt; WORD_SIZE]>>()
-            .concat(),
-    ));
+    postorder.push(Rpo256::merge(&[LEAVES[4], LEAVES[5]]));
     postorder.push(LEAVES[6]);
 
     let mut mmr = Mmr::new();
@@ -223,20 +199,8 @@
 #[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::<Vec<[Felt; WORD_SIZE]>>()
-            .concat(),
-    );
-    let h23: RpoDigest = Rpo256::hash_elements(
-        &LEAVES[2..4]
-            .iter()
-            .map(|digest| digest.into())
-            .collect::<Vec<[Felt; WORD_SIZE]>>()
-            .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<InnerNodeInfo> = mmr.inner_nodes().collect();
 
-    let h01 = Rpo256::hash_elements(
-        &[LEAVES[0], LEAVES[1]]
-            .iter()
-            .map(|digest| digest.into())
-            .collect::<Vec<[Felt; WORD_SIZE]>>()
-            .concat(),
-    );
-    let h23 = Rpo256::hash_elements(
-        &[LEAVES[2], LEAVES[3]]
-            .iter()
-            .map(|digest| digest.into())
-            .collect::<Vec<[Felt; WORD_SIZE]>>()
-            .concat(),
-    );
-    let h0123 = Rpo256::hash_elements(
-        &[h01, h23]
-            .iter()
-            .map(|digest| digest.into())
-            .collect::<Vec<[Felt; WORD_SIZE]>>()
-            .concat(),
-    );
-    let h45 = Rpo256::hash_elements(
-        &[LEAVES[4], LEAVES[5]]
-            .iter()
-            .map(|digest| digest.into())
-            .collect::<Vec<[Felt; WORD_SIZE]>>()
-            .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 @@ let mmr: Mmr = LEAVES.into();
     let peaks = mmr.accumulator();
 
     let first_peak = Rpo256::merge(&[
-        Rpo256::hash_elements(
-            &[LEAVES[0], LEAVES[1]]
-                .iter()
-                .map(|digest| digest.into())
-                .collect::<Vec<Word>>()
-                .concat(),
-        ),
-        Rpo256::hash_elements(
-            &[LEAVES[2], LEAVES[3]]
-                .iter()
-                .map(|digest| digest.into())
-                .collect::<Vec<Word>>()
-                .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::<Vec<[Felt; WORD_SIZE]>>()
-            .concat(),
-    );
+    let second_peak = Rpo256::merge(&[LEAVES[4], LEAVES[5]]);
     let third_peak = LEAVES[6];
 
     // minimum length is 16
@@ -490,14 +412,7 @@ let mut expected_peaks = [first_peak, second_peak, third_peak].to_vec();
     expected_peaks.resize(16, RpoDigest::default());
     assert_eq!(
         peaks.hash_peaks(),
-        *Rpo256::hash_elements(
-            &expected_peaks
-                .as_slice()
-                .iter()
-                .map(|digest| digest.into())
-                .collect::<Vec<Word>>()
-                .concat()
-        )
+        *Rpo256::hash_elements(&digests_to_elements(&expected_peaks))
     );
 }
 
@@ -517,14 +432,7 @@ let mut expected_peaks = peaks.clone();
         expected_peaks.resize(16, RpoDigest::default());
         assert_eq!(
             accumulator.hash_peaks(),
-            *Rpo256::hash_elements(
-                &expected_peaks
-                    .as_slice()
-                    .iter()
-                    .map(|digest| digest.into())
-                    .collect::<Vec<Word>>()
-                    .concat()
-            )
+            *Rpo256::hash_elements(&digests_to_elements(&expected_peaks))
         );
     }
 }
@@ -543,14 +451,7 @@ let mut expected_peaks = peaks.clone();
     expected_peaks.resize(18, RpoDigest::default());
     assert_eq!(
         accumulator.hash_peaks(),
-        *Rpo256::hash_elements(
-            &expected_peaks
-                .as_slice()
-                .iter()
-                .map(|digest| digest.into())
-                .collect::<Vec<Word>>()
-                .concat()
-        )
+        *Rpo256::hash_elements(&digests_to_elements(&expected_peaks))
     );
 }
 
@@ -582,3 +483,10 @@ assert!(mask & leaves != 0, "the result should be a tree in leaves");
         }
     }
 }
+
+// HELPER FUNCTIONS
+// ================================================================================================
+
+fn digests_to_elements(digests: &[RpoDigest]) -> Vec<Felt> {
+    digests.iter().flat_map(|v| Word::from(v)).collect()
+}

@@ -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<Word> {
+#[cfg(test)]
+fn digests_to_words(digests: &[RpoDigest]) -> Vec<Word> {
     digests.iter().map(|d| d.into()).collect()
 }

@@ -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 @@
     // 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 @@ let new_node = int_to_leaf(3);
     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 @@ assert_eq!(VALUES4[2], tree.get_node(NodeIndex::make(2, 2)).unwrap());
     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 @@ let b = Word::from(Rpo256::merge(&[a.into(); 2]));
     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 @@ // HELPER FUNCTIONS
 // --------------------------------------------------------------------------------------------
 
 fn compute_internal_nodes() -> (RpoDigest, RpoDigest, RpoDigest) {
-    let node2 = Rpo256::hash_elements(
-        &[VALUES4[0], VALUES4[1]]
-            .iter()
-            .map(|digest| digest.into())
-            .collect::<Vec<Word>>()
-            .concat(),
-    );
-    let node3 = Rpo256::hash_elements(
-        &[VALUES4[2], VALUES4[3]]
-            .iter()
-            .map(|digest| digest.into())
-            .collect::<Vec<Word>>()
-            .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)
 }

@@ -485,7 +485,6 @@ let mut root = Rpo256::merge(&[a.into(), b.into()]);
     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 @@ let j = Rpo256::merge(&[c.into(), d.into()]);
     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);
 }
 

@@ -21,7 +21,7 @@ let tree_root = store.set_node(smt.root(), index, leaf_node).unwrap().root;
 
     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 @@ tree_root = store.set_node(tree_root, index_b, leaf_node_b).unwrap().root;
 
     // --- 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 @@ tree_root = store.set_node(tree_root, index_b, leaf_node_b).unwrap().root;
 
     // --- 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 @@ tree_root = store.set_node(tree_root, index_c, leaf_node_c).unwrap().root;
 
     // --- 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 @@ let index = NodeIndex::make(16, raw >> 48);
     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 @@ tree_root = store.set_node(tree_root, index, leaf_node).unwrap().root;
 
     // --- 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 @@ tree_root = store.set_node(tree_root, index_b, leaf_node_b).unwrap().root;
 
     // --- 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