Merge next

Author: Mirko-von-Leipzig

Cargo.lock

@@ -41,7 +41,7 @@ mod tests;
 // ================================================================================================
 
 #[derive(Debug, Error)]
-pub enum InnerForestError {
+pub enum AccountStateForestError {
     #[error(transparent)]
     Asset(#[from] AssetError),
     #[error(transparent)]
@@ -60,17 +60,17 @@ pub enum WitnessError {
     AssetError(#[from] AssetError),
 }
 
-// INNER FOREST
+// ACCOUNT STATE FOREST
 // ================================================================================================
 
 /// Container for forest-related state that needs to be updated atomically.
-pub(crate) struct InnerForest {
+pub(crate) struct AccountStateForest {
     /// `LargeSmtForest` for efficient account storage reconstruction.
     /// Populated during block import with storage and vault SMTs.
     forest: LargeSmtForest<ForestInMemoryBackend>,
 }
 
-impl InnerForest {
+impl AccountStateForest {
     pub(crate) fn new() -> Self {
         Self { forest: Self::create_forest() }
     }
@@ -311,7 +311,7 @@ impl InnerForest {
         &mut self,
         block_num: BlockNumber,
         account_updates: impl IntoIterator<Item = AccountDelta>,
-    ) -> Result<(), InnerForestError> {
+    ) -> Result<(), AccountStateForestError> {
         for delta in account_updates {
             self.update_account(block_num, &delta)?;
 
@@ -345,7 +345,7 @@ impl InnerForest {
         &mut self,
         block_num: BlockNumber,
         delta: &AccountDelta,
-    ) -> Result<(), InnerForestError> {
+    ) -> Result<(), AccountStateForestError> {
         let account_id = delta.id();
         let is_full_state = delta.is_full_state();
 
@@ -383,7 +383,7 @@ impl InnerForest {
         block_num: BlockNumber,
         account_id: AccountId,
         vault_delta: &AccountVaultDelta,
-    ) -> Result<(), InnerForestError> {
+    ) -> Result<(), AccountStateForestError> {
         let prev_root = self.get_latest_vault_root(account_id);
         let lineage = Self::vault_lineage_id(account_id);
         assert_eq!(prev_root, Self::empty_smt_root(), "account should not be in the forest");
@@ -523,7 +523,7 @@ impl InnerForest {
         block_num: BlockNumber,
         account_id: AccountId,
         vault_delta: &AccountVaultDelta,
-    ) -> Result<(), InnerForestError> {
+    ) -> Result<(), AccountStateForestError> {
         assert!(!vault_delta.is_empty(), "expected the delta not to be empty");
 
         // get the previous vault root; the root could be for an empty or non-empty SMT

crates/store/src/inner_forest/mod.rs …es/store/src/account_state_forest/mod.rscrates/store/src/inner_forest/mod.rs renamed to crates/store/src/account_state_forest/mod.rs crates/store/src/inner_forest/mod.rs renamed to crates/store/src/account_state_forest/mod.rs

@@ -58,21 +58,21 @@ fn dummy_full_state_delta(account_id: AccountId, assets: &[Asset]) -> AccountDel
 fn empty_smt_root_is_recognized() {
     use miden_crypto::merkle::smt::Smt;
 
-    let empty_root = InnerForest::empty_smt_root();
+    let empty_root = AccountStateForest::empty_smt_root();
 
     assert_eq!(Smt::default().root(), empty_root);
 }
 
 #[test]
-fn inner_forest_basic_initialization() {
-    let forest = InnerForest::new();
+fn account_state_forest_basic_initialization() {
+    let forest = AccountStateForest::new();
     assert_eq!(forest.forest.lineage_count(), 0);
     assert_eq!(forest.forest.tree_count(), 0);
 }
 
 #[test]
 fn update_account_with_empty_deltas() {
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let block_num = BlockNumber::GENESIS.child();
 
@@ -99,15 +99,15 @@ fn vault_partial_vs_full_state_produces_same_root() {
     let asset = dummy_fungible_asset(faucet_id, 100);
 
     // Partial delta (block application)
-    let mut forest_partial = InnerForest::new();
+    let mut forest_partial = AccountStateForest::new();
     let mut vault_delta = AccountVaultDelta::default();
     vault_delta.add_asset(asset).unwrap();
     let partial_delta =
         dummy_partial_delta(account_id, vault_delta, AccountStorageDelta::default());
     forest_partial.update_account(block_num, &partial_delta).unwrap();
 
     // Full-state delta (DB reconstruction)
-    let mut forest_full = InnerForest::new();
+    let mut forest_full = AccountStateForest::new();
     let full_delta = dummy_full_state_delta(account_id, &[asset]);
     forest_full.update_account(block_num, &full_delta).unwrap();
 
@@ -120,7 +120,7 @@ fn vault_partial_vs_full_state_produces_same_root() {
 
 #[test]
 fn vault_incremental_updates_with_add_and_remove() {
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let faucet_id = dummy_faucet();
 
@@ -153,7 +153,7 @@ fn vault_incremental_updates_with_add_and_remove() {
     assert_ne!(root_after_150, root_after_120);
 
     // Verify by comparing to full-state delta
-    let mut fresh_forest = InnerForest::new();
+    let mut fresh_forest = AccountStateForest::new();
     let full_delta = dummy_full_state_delta(account_id, &[dummy_fungible_asset(faucet_id, 120)]);
     fresh_forest.update_account(block_3, &full_delta).unwrap();
     let root_full_state_120 = fresh_forest.get_vault_root(account_id, block_3).unwrap();
@@ -168,7 +168,7 @@ fn forest_versions_are_continuous_for_sequential_updates() {
     use assert_matches::assert_matches;
     use miden_protocol::account::delta::{StorageMapDelta, StorageSlotDelta};
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let faucet_id = dummy_faucet();
     let slot_name = StorageSlotName::mock(9);
@@ -201,7 +201,7 @@ fn forest_versions_are_continuous_for_sequential_updates() {
 
 #[test]
 fn vault_state_is_not_available_for_block_gaps() {
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let faucet_id = dummy_faucet();
 
@@ -229,7 +229,7 @@ fn witness_queries_work_with_sparse_lineage_updates() {
     use assert_matches::assert_matches;
     use miden_protocol::account::delta::{StorageMapDelta, StorageSlotDelta};
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let faucet_id = dummy_faucet();
     let slot_name = StorageSlotName::mock(6);
@@ -282,14 +282,14 @@ fn witness_queries_work_with_sparse_lineage_updates() {
             .open(forest.tree_id_for_vault_root(account_id, block_3), asset_key.into()),
         Ok(_)
     );
-    assert_ne!(vault_root_at_3, InnerForest::empty_smt_root());
+    assert_ne!(vault_root_at_3, AccountStateForest::empty_smt_root());
 }
 
 #[test]
 fn vault_full_state_with_empty_vault_records_root() {
     use miden_protocol::account::{Account, AccountStorage};
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let block_num = BlockNumber::GENESIS.child();
 
@@ -306,7 +306,7 @@ fn vault_full_state_with_empty_vault_records_root() {
     forest.update_account(block_num, &full_delta).unwrap();
 
     let recorded_root = forest.get_vault_root(account_id, block_num);
-    assert_eq!(recorded_root, Some(InnerForest::empty_smt_root()));
+    assert_eq!(recorded_root, Some(AccountStateForest::empty_smt_root()));
 
     let witnesses = forest
         .get_vault_asset_witnesses(account_id, block_num, std::collections::BTreeSet::new())
@@ -316,7 +316,7 @@ fn vault_full_state_with_empty_vault_records_root() {
 
 #[test]
 fn vault_shared_root_retained_when_one_entry_pruned() {
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account1 = AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE).unwrap();
     let account2 = AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE_2).unwrap();
     let faucet_id = dummy_faucet();
@@ -376,7 +376,7 @@ fn storage_map_incremental_updates() {
 
     use miden_protocol::account::delta::{StorageMapDelta, StorageSlotDelta};
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
 
     let slot_name = StorageSlotName::mock(3);
@@ -431,7 +431,7 @@ fn test_storage_map_removals() {
     const VALUE_1: [u32; 4] = [10, 0, 0, 0];
     const VALUE_2: [u32; 4] = [20, 0, 0, 0];
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let slot_name = StorageSlotName::mock(SLOT_INDEX);
     let key_1 = StorageMapKey::from_index(1);
@@ -481,7 +481,7 @@ fn storage_map_state_is_not_available_for_block_gaps() {
     const VALUE_FIRST: u32 = 10;
     const VALUE_SECOND: u32 = 20;
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let slot_name = StorageSlotName::mock(4);
     let raw_key = StorageMapKey::from_index(KEY_VALUE);
@@ -532,7 +532,7 @@ fn storage_map_empty_entries_query() {
     use miden_standards::account::auth::AuthSingleSig;
     use miden_standards::code_builder::CodeBuilder;
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let block_num = BlockNumber::GENESIS.child();
     let slot_name = StorageSlotName::mock(0);
 
@@ -567,7 +567,7 @@ fn storage_map_empty_entries_query() {
     forest.update_account(block_num, &full_delta).unwrap();
 
     let root = forest.get_storage_map_root(account_id, &slot_name, block_num);
-    assert_eq!(root, Some(InnerForest::empty_smt_root()));
+    assert_eq!(root, Some(AccountStateForest::empty_smt_root()));
 }
 
 #[test]
@@ -577,7 +577,7 @@ fn storage_map_open_returns_proofs() {
     use assert_matches::assert_matches;
     use miden_protocol::account::delta::{StorageMapDelta, StorageSlotDelta};
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let slot_name = StorageSlotName::mock(3);
     let block_num = BlockNumber::GENESIS.child();
@@ -613,7 +613,7 @@ fn storage_map_key_hashing_and_raw_entries_are_consistent() {
     const KEY_VALUE: u32 = 11;
     const VALUE_VALUE: u32 = 22;
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let slot_name = StorageSlotName::mock(SLOT_INDEX);
     let block_num = BlockNumber::GENESIS.child();
@@ -650,7 +650,7 @@ const TEST_PRUNE_CHAIN_TIP: u32 = HISTORICAL_BLOCK_RETENTION + 5;
 
 #[test]
 fn prune_handles_empty_forest() {
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
 
     let total_roots_removed = forest.prune(BlockNumber::GENESIS);
 
@@ -661,7 +661,7 @@ fn prune_handles_empty_forest() {
 fn prune_removes_smt_roots_from_forest() {
     use miden_protocol::account::delta::StorageMapDelta;
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let faucet_id = dummy_faucet();
     let slot_name = StorageSlotName::mock(7);
@@ -712,7 +712,7 @@ fn prune_removes_smt_roots_from_forest() {
 
 #[test]
 fn prune_respects_retention_boundary() {
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let faucet_id = dummy_faucet();
 
@@ -736,7 +736,7 @@ fn prune_respects_retention_boundary() {
 fn prune_roots_removes_old_entries() {
     use miden_protocol::account::delta::StorageMapDelta;
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
 
     let faucet_id = dummy_faucet();
@@ -770,7 +770,7 @@ fn prune_roots_removes_old_entries() {
 
 #[test]
 fn prune_handles_multiple_accounts() {
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account1 = dummy_account();
     let account2 = AccountId::try_from(ACCOUNT_ID_PUBLIC_FUNGIBLE_FAUCET).unwrap();
     let faucet_id = dummy_faucet();
@@ -807,7 +807,7 @@ fn prune_handles_multiple_slots() {
 
     use miden_protocol::account::delta::{StorageMapDelta, StorageSlotDelta};
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let slot_a = StorageSlotName::mock(1);
     let slot_b = StorageSlotName::mock(2);
@@ -843,7 +843,7 @@ fn prune_preserves_most_recent_state_per_entity() {
 
     use miden_protocol::account::delta::{StorageMapDelta, StorageSlotDelta};
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let faucet_id = dummy_faucet();
     let slot_map_a = StorageSlotName::mock(1);
@@ -900,7 +900,7 @@ fn prune_preserves_entries_within_retention_window() {
 
     use miden_protocol::account::delta::{StorageMapDelta, StorageSlotDelta};
 
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account_id = dummy_account();
     let faucet_id = dummy_faucet();
     let slot_map = StorageSlotName::mock(1);
@@ -944,7 +944,7 @@ fn prune_preserves_entries_within_retention_window() {
 /// witness generation.
 #[test]
 fn shared_vault_root_retained_when_one_account_changes() {
-    let mut forest = InnerForest::new();
+    let mut forest = AccountStateForest::new();
     let account1 = AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE).unwrap();
     let account2 = AccountId::try_from(ACCOUNT_ID_REGULAR_PUBLIC_ACCOUNT_IMMUTABLE_CODE_2).unwrap();
     let faucet_id = dummy_faucet();

crates/store/src/inner_forest/tests.rs …/store/src/account_state_forest/tests.rscrates/store/src/inner_forest/tests.rs renamed to crates/store/src/account_state_forest/tests.rs crates/store/src/inner_forest/tests.rs renamed to crates/store/src/account_state_forest/tests.rs

@@ -616,7 +616,7 @@ impl Db {
 
     /// Reconstructs storage map details from the database for a specific slot at a block.
     ///
-    /// Used as fallback when `InnerForest` cache misses (historical or evicted queries).
+    /// Used as fallback when `AccountStateForest` cache misses (historical or evicted queries).
     /// Rebuilds all entries by querying the DB and filtering to the specific slot.
     ///
     /// Returns: