diff --git a/crates/optimism/trie/src/api.rs b/crates/optimism/trie/src/api.rs index ce92eb52503..066930b354f 100644 --- a/crates/optimism/trie/src/api.rs +++ b/crates/optimism/trie/src/api.rs @@ -106,23 +106,20 @@ pub trait OpProofsStorage: Send + Sync + Debug { /// capture, use [store_trie_updates](OpProofsStorage::store_trie_updates). fn store_account_branches( &self, - block_number: u64, - updates: Vec<(Nibbles, Option)>, + account_nodes: Vec<(Nibbles, Option)>, ) -> impl Future> + Send; /// Store a batch of storage trie branches. Used for saving existing state. fn store_storage_branches( &self, - block_number: u64, hashed_address: B256, - items: Vec<(Nibbles, Option)>, + storage_nodes: Vec<(Nibbles, Option)>, ) -> impl Future> + Send; /// Store a batch of account trie leaf nodes. Used for saving existing state. fn store_hashed_accounts( &self, accounts: Vec<(B256, Option)>, - block_number: u64, ) -> impl Future> + Send; /// Store a batch of storage trie leaf nodes. Used for saving existing state. @@ -130,7 +127,6 @@ pub trait OpProofsStorage: Send + Sync + Debug { &self, hashed_address: B256, storages: Vec<(B256, U256)>, - block_number: u64, ) -> impl Future> + Send; /// Get the earliest block number and hash that has been stored diff --git a/crates/optimism/trie/src/backfill.rs b/crates/optimism/trie/src/backfill.rs index dfc58c2fefc..d1b5dc1cdf4 100644 --- a/crates/optimism/trie/src/backfill.rs +++ b/crates/optimism/trie/src/backfill.rs @@ -214,7 +214,6 @@ impl<'a, Tx: DbTx, S: OpProofsStorage + Send> BackfillJob<'a, Tx, S> { .into_iter() .map(|(address, account)| (address, Some(account))) .collect(), - 0, ) .await?; Ok(()) @@ -247,7 +246,7 @@ impl<'a, Tx: DbTx, S: OpProofsStorage + Send> BackfillJob<'a, Tx, S> { // Store each address's storage entries for (address, storages) in by_address { - self.storage.store_hashed_storages(address, storages, 0).await?; + self.storage.store_hashed_storages(address, storages).await?; } Ok(()) }; @@ -272,7 +271,6 @@ impl<'a, Tx: DbTx, S: OpProofsStorage + Send> BackfillJob<'a, Tx, S> { let save_fn = async |entries: Vec<(StoredNibbles, BranchNodeCompact)>| -> eyre::Result<()> { self.storage .store_account_branches( - 0, entries.into_iter().map(|(path, branch)| (path.0, Some(branch))).collect(), ) .await?; @@ -309,7 +307,7 @@ impl<'a, Tx: DbTx, S: OpProofsStorage + Send> BackfillJob<'a, Tx, S> { // Store each address's storage trie branches for (address, branches) in by_address { - self.storage.store_storage_branches(0, address, branches).await?; + self.storage.store_storage_branches(address, branches).await?; } Ok(()) }; diff --git a/crates/optimism/trie/src/db/store.rs b/crates/optimism/trie/src/db/store.rs index c37e314acc2..69f009aa165 100644 --- a/crates/optimism/trie/src/db/store.rs +++ b/crates/optimism/trie/src/db/store.rs @@ -41,20 +41,19 @@ impl OpProofsStorage for MdbxProofsStorage { async fn store_account_branches( &self, - block_number: u64, - updates: Vec<(Nibbles, Option)>, + account_nodes: Vec<(Nibbles, Option)>, ) -> OpProofsStorageResult<()> { - let mut updates = updates; - if updates.is_empty() { + let mut account_nodes = account_nodes; + if account_nodes.is_empty() { return Ok(()); } - updates.sort_by_key(|(key, _)| *key); + account_nodes.sort_by_key(|(key, _)| *key); self.env.update(|tx| { let mut cursor = tx.new_cursor::()?; - for (nibble, branch_node) in updates { - let vv = VersionedValue { block_number, value: MaybeDeleted(branch_node) }; + for (nibble, branch_node) in account_nodes { + let vv = VersionedValue { block_number: 0, value: MaybeDeleted(branch_node) }; cursor.append_dup(StoredNibbles::from(nibble), vv)?; } Ok(()) @@ -63,22 +62,21 @@ impl OpProofsStorage for MdbxProofsStorage { async fn store_storage_branches( &self, - block_number: u64, hashed_address: B256, - items: Vec<(Nibbles, Option)>, + storage_nodes: Vec<(Nibbles, Option)>, ) -> OpProofsStorageResult<()> { - let mut items = items; - if items.is_empty() { + let mut storage_nodes = storage_nodes; + if storage_nodes.is_empty() { return Ok(()); } - items.sort_by_key(|(key, _)| *key); + storage_nodes.sort_by_key(|(key, _)| *key); self.env.update(|tx| { let mut cursor = tx.new_cursor::()?; - for (nibble, branch_node) in items { + for (nibble, branch_node) in storage_nodes { let key = StorageTrieKey::new(hashed_address, StoredNibbles::from(nibble)); - let vv = VersionedValue { block_number, value: MaybeDeleted(branch_node) }; + let vv = VersionedValue { block_number: 0, value: MaybeDeleted(branch_node) }; cursor.append_dup(key, vv)?; } Ok(()) @@ -88,7 +86,6 @@ impl OpProofsStorage for MdbxProofsStorage { async fn store_hashed_accounts( &self, accounts: Vec<(B256, Option)>, - block_number: u64, ) -> OpProofsStorageResult<()> { let mut accounts = accounts; if accounts.is_empty() { @@ -101,7 +98,7 @@ impl OpProofsStorage for MdbxProofsStorage { self.env.update(|tx| { let mut cursor = tx.new_cursor::()?; for (key, account) in accounts { - let vv = VersionedValue { block_number, value: MaybeDeleted(account) }; + let vv = VersionedValue { block_number: 0, value: MaybeDeleted(account) }; cursor.append_dup(key, vv)?; } Ok(()) @@ -112,7 +109,6 @@ impl OpProofsStorage for MdbxProofsStorage { &self, hashed_address: B256, storages: Vec<(B256, U256)>, - block_number: u64, ) -> OpProofsStorageResult<()> { let mut storages = storages; if storages.is_empty() { @@ -125,8 +121,10 @@ impl OpProofsStorage for MdbxProofsStorage { self.env.update(|tx| { let mut cursor = tx.new_cursor::()?; for (key, value) in storages { - let vv = - VersionedValue { block_number, value: MaybeDeleted(Some(StorageValue(value))) }; + let vv = VersionedValue { + block_number: 0, + value: MaybeDeleted(Some(StorageValue(value))), + }; let storage_key = HashedStorageKey::new(hashed_address, key); cursor.append_dup(storage_key, vv)?; } @@ -233,7 +231,7 @@ mod tests { let addr = B256::from([0xAA; 32]); let account = Account::default(); - store.store_hashed_accounts(vec![(addr, Some(account))], B0).await.expect("write accounts"); + store.store_hashed_accounts(vec![(addr, Some(account))]).await.expect("write accounts"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.new_cursor::().expect("cursor"); @@ -257,7 +255,7 @@ mod tests { let acc3 = Account { nonce: 1, balance: U256::from(10000u64), ..Default::default() }; store - .store_hashed_accounts(vec![(a2, None), (a1, Some(acc1)), (a3, Some(acc3))], B0) + .store_hashed_accounts(vec![(a2, None), (a1, Some(acc1)), (a3, Some(acc3))]) .await .expect("write"); @@ -295,7 +293,7 @@ mod tests { { store - .store_hashed_accounts(vec![(a2, None), (a1, Some(acc1)), (a4, Some(acc4))], B0) + .store_hashed_accounts(vec![(a2, None), (a1, Some(acc1)), (a4, Some(acc4))]) .await .expect("write"); @@ -318,7 +316,7 @@ mod tests { { // Second call store - .store_hashed_accounts(vec![(a5, Some(acc5)), (a3, Some(acc3))], B0) + .store_hashed_accounts(vec![(a5, Some(acc5)), (a3, Some(acc3))]) .await .expect("write"); @@ -344,7 +342,7 @@ mod tests { let slot = B256::from([0x22; 32]); let val = U256::from(0x1234u64); - store.store_hashed_storages(addr, vec![(slot, val)], B0).await.expect("write storage"); + store.store_hashed_storages(addr, vec![(slot, val)]).await.expect("write storage"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.new_cursor::().expect("cursor"); @@ -370,10 +368,7 @@ mod tests { let s3 = B256::from([0x03; 32]); let v3 = U256::from(3u64); - store - .store_hashed_storages(addr, vec![(s2, v2), (s1, v1), (s3, v3)], B0) - .await - .expect("write"); + store.store_hashed_storages(addr, vec![(s2, v2), (s1, v1), (s3, v3)]).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.new_cursor::().expect("cursor"); @@ -406,7 +401,7 @@ mod tests { { store - .store_hashed_storages(addr, vec![(s2, v2), (s1, v1), (s5, v5)], B0) + .store_hashed_storages(addr, vec![(s2, v2), (s1, v1), (s5, v5)]) .await .expect("write"); @@ -424,7 +419,7 @@ mod tests { { // Second call - store.store_hashed_storages(addr, vec![(s4, v4), (s3, v3)], B0).await.expect("write"); + store.store_hashed_storages(addr, vec![(s4, v4), (s3, v3)]).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.new_cursor::().expect("cursor"); @@ -448,7 +443,7 @@ mod tests { let branch_node = BranchNodeCompact::new(0b1, 0, 0, vec![], Some(B256::random())); let updates = vec![(nibble, Some(branch_node.clone()))]; - store.store_account_branches(B0, updates).await.expect("write"); + store.store_account_branches(updates).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.cursor_dup_read::().expect("cursor"); @@ -474,7 +469,7 @@ mod tests { let b3 = BranchNodeCompact::new(0b1, 0, 0, vec![], Some(B256::random())); let updates = vec![(n2, None), (n1, Some(b1.clone())), (n3, Some(b3.clone()))]; - store.store_account_branches(B0, updates.clone()).await.expect("write"); + store.store_account_branches(updates.clone()).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.cursor_dup_read::().expect("cursor"); @@ -506,7 +501,7 @@ mod tests { { let updates1 = vec![(n2, None), (n1, Some(b1.clone())), (n4, Some(b4.clone()))]; - store.store_account_branches(B0, updates1.clone()).await.expect("write"); + store.store_account_branches(updates1.clone()).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.cursor_dup_read::().expect("cursor"); @@ -524,7 +519,7 @@ mod tests { { // Second call let updates2 = vec![(n5, Some(b5.clone())), (n3, Some(b3.clone()))]; - store.store_account_branches(B0, updates2.clone()).await.expect("write"); + store.store_account_branches(updates2.clone()).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.cursor_dup_read::().expect("cursor"); @@ -550,7 +545,7 @@ mod tests { let branch_node = BranchNodeCompact::new(0b1, 0, 0, vec![], Some(B256::random())); let items = vec![(nibble, Some(branch_node.clone()))]; - store.store_storage_branches(B0, hashed_address, items).await.expect("write"); + store.store_storage_branches(hashed_address, items).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.cursor_dup_read::().expect("cursor"); @@ -575,7 +570,7 @@ mod tests { let b3 = BranchNodeCompact::new(0b1, 0, 0, vec![], Some(B256::random())); let items = vec![(n2, None), (n1, Some(b1.clone())), (n3, Some(b3.clone()))]; - store.store_storage_branches(B0, hashed_address, items.clone()).await.expect("write"); + store.store_storage_branches(hashed_address, items.clone()).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.cursor_dup_read::().expect("cursor"); @@ -606,7 +601,7 @@ mod tests { { let items1 = vec![(n2, None), (n1, Some(b1.clone())), (n5, Some(b5.clone()))]; - store.store_storage_branches(B0, hashed_address, items1.clone()).await.expect("write"); + store.store_storage_branches(hashed_address, items1.clone()).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.cursor_dup_read::().expect("cursor"); @@ -622,7 +617,7 @@ mod tests { { // Second call let items2 = vec![(n4, Some(b4.clone())), (n3, Some(b3.clone()))]; - store.store_storage_branches(B0, hashed_address, items2.clone()).await.expect("write"); + store.store_storage_branches(hashed_address, items2.clone()).await.expect("write"); let tx = store.env.tx().expect("ro tx"); let mut cur = tx.cursor_dup_read::().expect("cursor"); diff --git a/crates/optimism/trie/src/in_memory.rs b/crates/optimism/trie/src/in_memory.rs index 13b22b19fe6..6075e071268 100644 --- a/crates/optimism/trie/src/in_memory.rs +++ b/crates/optimism/trie/src/in_memory.rs @@ -387,13 +387,12 @@ impl OpProofsStorage for InMemoryProofsStorage { async fn store_account_branches( &self, - block_number: u64, updates: Vec<(Nibbles, Option)>, ) -> OpProofsStorageResult<()> { let mut inner = self.inner.write().await; for (path, branch) in updates { - inner.account_branches.insert((block_number, path), branch); + inner.account_branches.insert((0, path), branch); } Ok(()) @@ -401,14 +400,13 @@ impl OpProofsStorage for InMemoryProofsStorage { async fn store_storage_branches( &self, - block_number: u64, hashed_address: B256, items: Vec<(Nibbles, Option)>, ) -> OpProofsStorageResult<()> { let mut inner = self.inner.write().await; for (path, branch) in items { - inner.storage_branches.insert((block_number, hashed_address, path), branch); + inner.storage_branches.insert((0, hashed_address, path), branch); } Ok(()) @@ -417,12 +415,11 @@ impl OpProofsStorage for InMemoryProofsStorage { async fn store_hashed_accounts( &self, accounts: Vec<(B256, Option)>, - block_number: u64, ) -> OpProofsStorageResult<()> { let mut inner = self.inner.write().await; for (address, account) in accounts { - inner.hashed_accounts.insert((block_number, address), account); + inner.hashed_accounts.insert((0, address), account); } Ok(()) @@ -432,12 +429,11 @@ impl OpProofsStorage for InMemoryProofsStorage { &self, hashed_address: B256, storages: Vec<(B256, U256)>, - block_number: u64, ) -> OpProofsStorageResult<()> { let mut inner = self.inner.write().await; for (slot, value) in storages { - inner.hashed_storages.insert((block_number, hashed_address, slot), value); + inner.hashed_storages.insert((0, hashed_address, slot), value); } Ok(()) @@ -648,7 +644,7 @@ mod tests { let account = Account { nonce: 1, balance: U256::from(100), bytecode_hash: None }; let hashed_address = B256::random(); - storage.store_hashed_accounts(vec![(hashed_address, Some(account))], 2).await?; + storage.store_hashed_accounts(vec![(hashed_address, Some(account))]).await?; let _cursor = storage.account_hashed_cursor(10)?; // Note: cursor testing would require more complex setup with proper seek/next operations diff --git a/crates/optimism/trie/src/metrics.rs b/crates/optimism/trie/src/metrics.rs index 7b7f5eafbc2..7ef86f3efc2 100644 --- a/crates/optimism/trie/src/metrics.rs +++ b/crates/optimism/trie/src/metrics.rs @@ -301,12 +301,11 @@ where async fn store_account_branches( &self, - block_number: u64, - updates: Vec<(Nibbles, Option)>, + account_nodes: Vec<(Nibbles, Option)>, ) -> OpProofsStorageResult<()> { - let count = updates.len(); + let count = account_nodes.len(); let start = Instant::now(); - let result = self.storage.store_account_branches(block_number, updates).await; + let result = self.storage.store_account_branches(account_nodes).await; let duration = start.elapsed(); // Record per-item duration @@ -323,13 +322,12 @@ where async fn store_storage_branches( &self, - block_number: u64, hashed_address: B256, - items: Vec<(Nibbles, Option)>, + storage_nodes: Vec<(Nibbles, Option)>, ) -> OpProofsStorageResult<()> { - let count = items.len(); + let count = storage_nodes.len(); let start = Instant::now(); - let result = self.storage.store_storage_branches(block_number, hashed_address, items).await; + let result = self.storage.store_storage_branches(hashed_address, storage_nodes).await; let duration = start.elapsed(); // Record per-item duration @@ -347,11 +345,10 @@ where async fn store_hashed_accounts( &self, accounts: Vec<(B256, Option)>, - block_number: u64, ) -> OpProofsStorageResult<()> { let count = accounts.len(); let start = Instant::now(); - let result = self.storage.store_hashed_accounts(accounts, block_number).await; + let result = self.storage.store_hashed_accounts(accounts).await; let duration = start.elapsed(); // Record per-item duration @@ -370,12 +367,10 @@ where &self, hashed_address: B256, storages: Vec<(B256, U256)>, - block_number: u64, ) -> OpProofsStorageResult<()> { let count = storages.len(); let start = Instant::now(); - let result = - self.storage.store_hashed_storages(hashed_address, storages, block_number).await; + let result = self.storage.store_hashed_storages(hashed_address, storages).await; let duration = start.elapsed(); // Record per-item duration diff --git a/crates/optimism/trie/tests/lib.rs b/crates/optimism/trie/tests/lib.rs index 6140ed50556..23ad43fedf0 100644 --- a/crates/optimism/trie/tests/lib.rs +++ b/crates/optimism/trie/tests/lib.rs @@ -138,7 +138,7 @@ async fn test_cursor_single_entry( let branch = create_test_branch(); // Store single entry - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; @@ -171,7 +171,7 @@ async fn test_cursor_multiple_entries( // Store multiple entries for path in &paths { - storage.store_account_branches(50, vec![(*path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(*path, Some(branch.clone()))]).await?; } let mut cursor = storage.account_trie_cursor(100)?; @@ -204,7 +204,7 @@ async fn test_seek_exact_existing_path( let path = nibbles_from(vec![1, 2, 3]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; let result = cursor.seek_exact(path)?.unwrap(); @@ -222,7 +222,7 @@ async fn test_seek_exact_non_existing_path( let path = nibbles_from(vec![1, 2, 3]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; let non_existing = nibbles_from(vec![4, 5, 6]); @@ -240,7 +240,7 @@ async fn test_seek_exact_empty_path( let path = nibbles_from(vec![]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; let result = cursor.seek_exact(Nibbles::default())?.unwrap(); @@ -258,7 +258,7 @@ async fn test_seek_to_existing_path( let path = nibbles_from(vec![1, 2, 3]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; let result = cursor.seek(path)?.unwrap(); @@ -277,8 +277,8 @@ async fn test_seek_between_existing_nodes( let path2 = nibbles_from(vec![3]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path1, Some(branch.clone()))]).await?; - storage.store_account_branches(50, vec![(path2, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path1, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path2, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; // Seek to path between 1 and 3, should return path 3 @@ -298,7 +298,7 @@ async fn test_seek_after_all_nodes( let path = nibbles_from(vec![1]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; // Seek to path after all nodes @@ -317,7 +317,7 @@ async fn test_seek_before_all_nodes( let path = nibbles_from(vec![5]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; // Seek to path before all nodes, should return first node @@ -341,7 +341,7 @@ async fn test_next_without_prior_seek( let path = nibbles_from(vec![1, 2]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; // next() without prior seek should start from beginning @@ -359,8 +359,8 @@ async fn test_next_after_seek(storage: S) -> Result<(), OpPr let path2 = nibbles_from(vec![2]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path1, Some(branch.clone()))]).await?; - storage.store_account_branches(50, vec![(path2, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path1, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path2, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; cursor.seek(path1)?; @@ -381,7 +381,7 @@ async fn test_next_at_end_of_trie( let path = nibbles_from(vec![1]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; cursor.seek(path)?; @@ -402,7 +402,7 @@ async fn test_multiple_consecutive_next( let branch = create_test_branch(); for path in &paths { - storage.store_account_branches(50, vec![(*path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(*path, Some(branch.clone()))]).await?; } let mut cursor = storage.account_trie_cursor(100)?; @@ -429,8 +429,8 @@ async fn test_current_after_operations( let path2 = nibbles_from(vec![2]); let branch = create_test_branch(); - storage.store_account_branches(50, vec![(path1, Some(branch.clone()))]).await?; - storage.store_account_branches(50, vec![(path2, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path1, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path2, Some(branch.clone()))]).await?; let mut cursor = storage.account_trie_cursor(100)?; @@ -477,8 +477,8 @@ async fn test_same_path_different_blocks( let branch2 = create_test_branch_variant(); // Store same path at different blocks - storage.store_account_branches(50, vec![(path, Some(branch1.clone()))]).await?; - storage.store_account_branches(100, vec![(path, Some(branch2.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch1.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch2.clone()))]).await?; // Cursor with max_block_number=75 should see only block 50 data let mut cursor75 = storage.account_trie_cursor(75)?; @@ -503,13 +503,14 @@ async fn test_deleted_branch_nodes( let branch = create_test_branch(); // Store branch node, then delete it (store None) - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; - storage.store_account_branches(100, vec![(path, None)]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; // Cursor before deletion should see the node let mut cursor75 = storage.account_trie_cursor(75)?; assert!(cursor75.seek_exact(path)?.is_some()); + // set the node to None + storage.store_account_branches(vec![(path, None)]).await?; // Cursor after deletion should not see the node let mut cursor150 = storage.account_trie_cursor(150)?; assert!(cursor150.seek_exact(path)?.is_none()); @@ -533,8 +534,8 @@ async fn test_account_specific_cursor( let branch = create_test_branch(); // Store same path for different accounts (using storage branches) - storage.store_storage_branches(50, addr1, vec![(path, Some(branch.clone()))]).await?; - storage.store_storage_branches(50, addr2, vec![(path, Some(branch.clone()))]).await?; + storage.store_storage_branches(addr1, vec![(path, Some(branch.clone()))]).await?; + storage.store_storage_branches(addr2, vec![(path, Some(branch.clone()))]).await?; // Cursor for addr1 should only see addr1 data let mut cursor1 = storage.storage_trie_cursor(addr1, 100)?; @@ -568,8 +569,8 @@ async fn test_state_trie_cursor( let branch = create_test_branch(); // Store data for account trie and state trie - storage.store_storage_branches(50, addr, vec![(path, Some(branch.clone()))]).await?; - storage.store_account_branches(50, vec![(path, Some(branch.clone()))]).await?; + storage.store_storage_branches(addr, vec![(path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path, Some(branch.clone()))]).await?; // State trie cursor (None address) should only see state trie data let mut state_cursor = storage.account_trie_cursor(100)?; @@ -600,8 +601,8 @@ async fn test_mixed_account_state_data( let branch = create_test_branch(); // Store mixed account and state trie data - storage.store_storage_branches(50, addr, vec![(path1, Some(branch.clone()))]).await?; - storage.store_account_branches(50, vec![(path2, Some(branch.clone()))]).await?; + storage.store_storage_branches(addr, vec![(path1, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(path2, Some(branch.clone()))]).await?; // Account cursor should only see account data let mut account_cursor = storage.storage_trie_cursor(addr, 100)?; @@ -644,7 +645,7 @@ async fn test_lexicographic_ordering( // Store paths in random order for path in &paths { - storage.store_account_branches(50, vec![(*path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(*path, Some(branch.clone()))]).await?; } let mut cursor = storage.account_trie_cursor(100)?; @@ -680,7 +681,7 @@ async fn test_path_prefix_scenarios( let branch = create_test_branch(); for path in &paths { - storage.store_account_branches(50, vec![(*path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(*path, Some(branch.clone()))]).await?; } let mut cursor = storage.account_trie_cursor(100)?; @@ -716,7 +717,7 @@ async fn test_complex_nibble_combinations( let branch = create_test_branch(); for path in &paths { - storage.store_account_branches(50, vec![(*path, Some(branch.clone()))]).await?; + storage.store_account_branches(vec![(*path, Some(branch.clone()))]).await?; } let mut cursor = storage.account_trie_cursor(100)?; @@ -750,7 +751,7 @@ async fn test_store_and_retrieve_single_account( let account = create_test_account(); // Store account - storage.store_hashed_accounts(vec![(account_key, Some(account))], 50).await?; + storage.store_hashed_accounts(vec![(account_key, Some(account))]).await?; // Retrieve via cursor let mut cursor = storage.account_hashed_cursor(100)?; @@ -778,7 +779,7 @@ async fn test_account_cursor_navigation( // Store accounts let accounts_to_store: Vec<_> = accounts.iter().map(|(k, v)| (*k, Some(*v))).collect(); - storage.store_hashed_accounts(accounts_to_store, 50).await?; + storage.store_hashed_accounts(accounts_to_store).await?; let mut cursor = storage.account_hashed_cursor(100)?; @@ -812,8 +813,7 @@ async fn test_account_block_versioning( let account_v2 = create_test_account_with_values(2, 200, 0xDD); // Store account at different blocks - storage.store_hashed_accounts(vec![(account_key, Some(account_v1))], 50).await?; - storage.store_hashed_accounts(vec![(account_key, Some(account_v2))], 100).await?; + storage.store_hashed_accounts(vec![(account_key, Some(account_v1))]).await?; // Cursor with max_block_number=75 should see v1 let mut cursor75 = storage.account_hashed_cursor(75)?; @@ -821,7 +821,9 @@ async fn test_account_block_versioning( assert_eq!(result75.1.nonce, account_v1.nonce); assert_eq!(result75.1.balance, account_v1.balance); - // Cursor with max_block_number=150 should see v2 + storage.store_hashed_accounts(vec![(account_key, Some(account_v2))]).await?; + + // After update, Cursor with max_block_number=150 should see v2 let mut cursor150 = storage.account_hashed_cursor(150)?; let result150 = cursor150.seek(account_key)?.unwrap(); assert_eq!(result150.1.nonce, account_v2.nonce); @@ -844,7 +846,7 @@ async fn test_store_and_retrieve_storage( ]; // Store storage slots - storage.store_hashed_storages(hashed_address, storage_slots.clone(), 50).await?; + storage.store_hashed_storages(hashed_address, storage_slots.clone()).await?; // Retrieve via cursor let mut cursor = storage.storage_hashed_cursor(hashed_address, 100)?; @@ -872,7 +874,7 @@ async fn test_storage_cursor_navigation( (B256::repeat_byte(0x50), U256::from(500)), ]; - storage.store_hashed_storages(hashed_address, storage_slots.clone(), 50).await?; + storage.store_hashed_storages(hashed_address, storage_slots.clone()).await?; let mut cursor = storage.storage_hashed_cursor(hashed_address, 100)?; @@ -901,8 +903,8 @@ async fn test_storage_account_isolation( let storage_key = B256::repeat_byte(0x10); // Store same storage key for different accounts - storage.store_hashed_storages(address1, vec![(storage_key, U256::from(100))], 50).await?; - storage.store_hashed_storages(address2, vec![(storage_key, U256::from(200))], 50).await?; + storage.store_hashed_storages(address1, vec![(storage_key, U256::from(100))]).await?; + storage.store_hashed_storages(address2, vec![(storage_key, U256::from(200))]).await?; // Verify each account sees only its own storage let mut cursor1 = storage.storage_hashed_cursor(address1, 100)?; @@ -934,16 +936,14 @@ async fn test_storage_block_versioning( let storage_key = B256::repeat_byte(0x10); // Store storage at different blocks - storage.store_hashed_storages(hashed_address, vec![(storage_key, U256::from(100))], 50).await?; - storage - .store_hashed_storages(hashed_address, vec![(storage_key, U256::from(200))], 100) - .await?; + storage.store_hashed_storages(hashed_address, vec![(storage_key, U256::from(100))]).await?; // Cursor with max_block_number=75 should see old value let mut cursor75 = storage.storage_hashed_cursor(hashed_address, 75)?; let result75 = cursor75.seek(storage_key)?.unwrap(); assert_eq!(result75.1, U256::from(100)); + storage.store_hashed_storages(hashed_address, vec![(storage_key, U256::from(200))]).await?; // Cursor with max_block_number=150 should see new value let mut cursor150 = storage.storage_hashed_cursor(hashed_address, 150)?; let result150 = cursor150.seek(storage_key)?.unwrap(); @@ -962,16 +962,16 @@ async fn test_storage_zero_value_deletion( let storage_key = B256::repeat_byte(0x10); // Store non-zero value - storage.store_hashed_storages(hashed_address, vec![(storage_key, U256::from(100))], 50).await?; - - // "Delete" by storing zero value - storage.store_hashed_storages(hashed_address, vec![(storage_key, U256::ZERO)], 100).await?; + storage.store_hashed_storages(hashed_address, vec![(storage_key, U256::from(100))]).await?; // Cursor before deletion should see the value let mut cursor75 = storage.storage_hashed_cursor(hashed_address, 75)?; let result75 = cursor75.seek(storage_key)?.unwrap(); assert_eq!(result75.1, U256::from(100)); + // "Delete" by storing zero value + storage.store_hashed_storages(hashed_address, vec![(storage_key, U256::ZERO)]).await?; + // Cursor after deletion should NOT see the entry (zero values are skipped) let mut cursor150 = storage.storage_hashed_cursor(hashed_address, 150)?; let result150 = cursor150.seek(storage_key)?; @@ -998,7 +998,7 @@ async fn test_storage_cursor_skips_zero_values( ]; // Store all slots - storage.store_hashed_storages(hashed_address, storage_slots.clone(), 50).await?; + storage.store_hashed_storages(hashed_address, storage_slots.clone()).await?; // Create cursor and iterate through all entries let mut cursor = storage.storage_hashed_cursor(hashed_address, 100)?; @@ -1054,7 +1054,7 @@ async fn test_cursor_boundary_conditions( let account_key = B256::repeat_byte(0x80); // Middle value let account = create_test_account(); - storage.store_hashed_accounts(vec![(account_key, Some(account))], 50).await?; + storage.store_hashed_accounts(vec![(account_key, Some(account))]).await?; let mut cursor = storage.account_hashed_cursor(100)?; @@ -1088,7 +1088,7 @@ async fn test_large_batch_operations( } // Store in batch - storage.store_hashed_accounts(accounts.clone(), 50).await?; + storage.store_hashed_accounts(accounts.clone()).await?; // Verify all accounts can be retrieved let mut cursor = storage.account_hashed_cursor(100)?; @@ -1128,7 +1128,7 @@ async fn test_store_trie_updates_with_wiped_storage( (B256::repeat_byte(0x40), U256::from(400)), ]; - storage.store_hashed_storages(hashed_address, storage_slots.clone(), 50).await?; + storage.store_hashed_storages(hashed_address, storage_slots.clone()).await?; // Verify all values are present at block 75 let mut cursor75 = storage.storage_hashed_cursor(hashed_address, 75)?;