Remove TieredSmt (#277)

README.md

@@ -19,7 +19,7 @@ For performance benchmarks of these hash functions and their comparison to other
 * `PartialMerkleTree`: a partial view of a Merkle tree where some sub-trees may not be known. This is similar to a collection of Merkle paths all resolving to the same root. The length of the paths can be at most 64.
 * `PartialMmr`: a partial view of a Merkle mountain range structure.
 * `SimpleSmt`: a Sparse Merkle Tree (with no compaction), mapping 64-bit keys to 4-element values.
-* `TieredSmt`: a Sparse Merkle tree (with compaction), mapping 4-element keys to 4-element values.
+* `Smt`: a Sparse Merkle tree (with compaction at depth 64), mapping 4-element keys to 4-element values.
 
 The module also contains additional supporting components such as `NodeIndex`, `MerklePath`,  and `MerkleError`  to assist with tree indexation, opening proofs, and reporting inconsistent arguments/state.
 

src/main.rs

@@ -1,31 +1,26 @@
 use clap::Parser;
 use miden_crypto::{
     hash::rpo::{Rpo256, RpoDigest},
-    merkle::{MerkleError, TieredSmt},
+    merkle::{MerkleError, Smt},
     Felt, Word, ONE,
 };
 use rand_utils::rand_value;
 use std::time::Instant;
 
 #[derive(Parser, Debug)]
-#[clap(
-    name = "Benchmark",
-    about = "Tiered SMT benchmark",
-    version,
-    rename_all = "kebab-case"
-)]
+#[clap(name = "Benchmark", about = "SMT benchmark", version, rename_all = "kebab-case")]
 pub struct BenchmarkCmd {
     /// Size of the tree
     #[clap(short = 's', long = "size")]
     size: u64,
 }
 
 fn main() {
-    benchmark_tsmt();
+    benchmark_smt();
 }
 
-/// Run a benchmark for the Tiered SMT.
-pub fn benchmark_tsmt() {
+/// Run a benchmark for [`Smt`].
+pub fn benchmark_smt() {
     let args = BenchmarkCmd::parse();
     let tree_size = args.size;
 
@@ -42,38 +37,25 @@ pub fn benchmark_tsmt() {
     proof_generation(&mut tree, tree_size).unwrap();
 }
 
-/// Runs the construction benchmark for the Tiered SMT, returning the constructed tree.
-pub fn construction(entries: Vec<(RpoDigest, Word)>, size: u64) -> Result<TieredSmt, MerkleError> {
+/// Runs the construction benchmark for [`Smt`], returning the constructed tree.
+pub fn construction(entries: Vec<(RpoDigest, Word)>, size: u64) -> Result<Smt, MerkleError> {
     println!("Running a construction benchmark:");
     let now = Instant::now();
-    let tree = TieredSmt::with_entries(entries)?;
+    let tree = Smt::with_entries(entries)?;
     let elapsed = now.elapsed();
     println!(
-        "Constructed a TSMT with {} key-value pairs in {:.3} seconds",
+        "Constructed a SMT with {} key-value pairs in {:.3} seconds",
         size,
         elapsed.as_secs_f32(),
     );
 
-    // Count how many nodes end up at each tier
-    let mut nodes_num_16_32_48 = (0, 0, 0);
-
-    tree.upper_leaf_nodes().for_each(|(index, _)| match index.depth() {
-        16 => nodes_num_16_32_48.0 += 1,
-        32 => nodes_num_16_32_48.1 += 1,
-        48 => nodes_num_16_32_48.2 += 1,
-        _ => unreachable!(),
-    });
-
-    println!("Number of nodes on depth 16: {}", nodes_num_16_32_48.0);
-    println!("Number of nodes on depth 32: {}", nodes_num_16_32_48.1);
-    println!("Number of nodes on depth 48: {}", nodes_num_16_32_48.2);
-    println!("Number of nodes on depth 64: {}\n", tree.bottom_leaves().count());
+    println!("Number of leaf nodes: {}\n", tree.leaves().count());
 
     Ok(tree)
 }
 
-/// Runs the insertion benchmark for the Tiered SMT.
-pub fn insertion(tree: &mut TieredSmt, size: u64) -> Result<(), MerkleError> {
+/// Runs the insertion benchmark for the [`Smt`].
+pub fn insertion(tree: &mut Smt, size: u64) -> Result<(), MerkleError> {
     println!("Running an insertion benchmark:");
 
     let mut insertion_times = Vec::new();
@@ -89,7 +71,7 @@ pub fn insertion(tree: &mut TieredSmt, size: u64) -> Result<(), MerkleError> {
     }
 
     println!(
-        "An average insertion time measured by 20 inserts into a TSMT with {} key-value pairs is {:.3} milliseconds\n",
+        "An average insertion time measured by 20 inserts into a SMT with {} key-value pairs is {:.3} milliseconds\n",
         size,
         // calculate the average by dividing by 20 and convert to milliseconds by multiplying by 
         // 1000. As a result, we can only multiply by 50
@@ -99,8 +81,8 @@ pub fn insertion(tree: &mut TieredSmt, size: u64) -> Result<(), MerkleError> {
     Ok(())
 }
 
-/// Runs the proof generation benchmark for the Tiered SMT.
-pub fn proof_generation(tree: &mut TieredSmt, size: u64) -> Result<(), MerkleError> {
+/// Runs the proof generation benchmark for the [`Smt`].
+pub fn proof_generation(tree: &mut Smt, size: u64) -> Result<(), MerkleError> {
     println!("Running a proof generation benchmark:");
 
     let mut insertion_times = Vec::new();
@@ -111,13 +93,13 @@ pub fn proof_generation(tree: &mut TieredSmt, size: u64) -> Result<(), MerkleErr
         tree.insert(test_key, test_value);
 
         let now = Instant::now();
-        let _proof = tree.prove(test_key);
+        let _proof = tree.open(&test_key);
         let elapsed = now.elapsed();
         insertion_times.push(elapsed.as_secs_f32());
     }
 
     println!(
-        "An average proving time measured by 20 value proofs in a TSMT with {} key-value pairs in {:.3} microseconds",
+        "An average proving time measured by 20 value proofs in a SMT with {} key-value pairs in {:.3} microseconds",
         size,
         // calculate the average by dividing by 20 and convert to microseconds by multiplying by
         // 1000000. As a result, we can only multiply by 50000

src/merkle/mod.rs

@@ -27,9 +27,6 @@ pub use smt::{
     SMT_MAX_DEPTH, SMT_MIN_DEPTH,
 };
 
-mod tiered_smt;
-pub use tiered_smt::{TieredSmt, TieredSmtProof, TieredSmtProofError};
-
 mod mmr;
 pub use mmr::{InOrderIndex, Mmr, MmrDelta, MmrError, MmrPeaks, MmrProof, PartialMmr};
 

src/merkle/store/mod.rs

@@ -1,7 +1,7 @@
 use super::{
     mmr::Mmr, BTreeMap, EmptySubtreeRoots, InnerNodeInfo, KvMap, MerkleError, MerklePath,
     MerkleTree, NodeIndex, PartialMerkleTree, RecordingMap, RootPath, Rpo256, RpoDigest, SimpleSmt,
-    Smt, TieredSmt, ValuePath, Vec,
+    Smt, ValuePath, Vec,
 };
 use crate::utils::{ByteReader, ByteWriter, Deserializable, DeserializationError, Serializable};
 use core::borrow::Borrow;
@@ -361,9 +361,6 @@ impl<T: KvMap<RpoDigest, StoreNode>> MerkleStore<T> {
 
                 // if the node is not in the store assume it is a leaf
                 } else {
-                    // assert that if we have a leaf that is not at the max depth then it must be
-                    // at the depth of one of the tiers of an TSMT.
-                    debug_assert!(TieredSmt::TIER_DEPTHS[..3].contains(&index.depth()));
                     return Some((index, node_hash));
                 }
             }
@@ -511,13 +508,6 @@ impl<T: KvMap<RpoDigest, StoreNode>> From<&Mmr> for MerkleStore<T> {
     }
 }
 
-impl<T: KvMap<RpoDigest, StoreNode>> From<&TieredSmt> for MerkleStore<T> {
-    fn from(value: &TieredSmt) -> Self {
-        let nodes = combine_nodes_with_empty_hashes(value.inner_nodes()).collect();
-        Self { nodes }
-    }
-}
-
 impl<T: KvMap<RpoDigest, StoreNode>> From<&PartialMerkleTree> for MerkleStore<T> {
     fn from(value: &PartialMerkleTree) -> Self {
         let nodes = combine_nodes_with_empty_hashes(value.inner_nodes()).collect();