chore(trie): Revert redundant diff

crates/optimism/trie/src/db/store.rs

@@ -478,13 +478,13 @@ impl MdbxProofsStorage {
     ) -> OpProofsStorageResult<ChangeSet> {
         let BlockStateDiff { sorted_trie_updates, sorted_post_state } = block_state_diff;
 
-        let storage_trie_len = sorted_trie_updates.storage_tries.len();
+        let storage_trie_len = sorted_trie_updates.storage_tries_ref().len();
         let hashed_storage_len = sorted_post_state.storages.len();
 
         let account_trie_keys = self.persist_history_batch(
             tx,
             block_number,
-            sorted_trie_updates.account_nodes.into_iter(),
+            sorted_trie_updates.account_nodes_ref().iter().cloned(),
             append_mode,
         )?;
         let hashed_account_keys = self.persist_history_batch(
@@ -495,14 +495,14 @@ impl MdbxProofsStorage {
         )?;
 
         let mut storage_trie_keys = Vec::<StorageTrieKey>::with_capacity(storage_trie_len);
-        for (hashed_address, nodes) in sorted_trie_updates.storage_tries {
+        for (hashed_address, nodes) in sorted_trie_updates.storage_tries_ref() {
             // Handle wiped - mark all storage trie as deleted at the current block number
             if nodes.is_deleted && append_mode {
                 // Yet to have any update for the current block number - So just using up to
                 // previous block number
-                let mut ro = self.storage_trie_cursor(hashed_address, block_number - 1)?;
+                let mut ro = self.storage_trie_cursor(*hashed_address, block_number - 1)?;
                 let keys =
-                    self.wipe_storage(tx, block_number, hashed_address, || Ok(ro.next()?))?;
+                    self.wipe_storage(tx, block_number, *hashed_address, || Ok(ro.next()?))?;
 
                 storage_trie_keys.extend(keys);
 
@@ -513,7 +513,11 @@ impl MdbxProofsStorage {
             let keys = self.persist_history_batch(
                 tx,
                 block_number,
-                nodes.storage_nodes.into_iter().map(|(path, node)| (hashed_address, path, node)),
+                nodes
+                    .storage_nodes_ref()
+                    .iter()
+                    .cloned()
+                    .map(|(path, node)| (*hashed_address, path, node)),
                 append_mode,
             )?;
             storage_trie_keys.extend(keys);
@@ -1888,8 +1892,8 @@ mod tests {
 
         store.store_trie_updates(block, diff).await.expect("store");
         let got = store.fetch_trie_updates(1).await.expect("fetch");
-        assert!(got.sorted_trie_updates.account_nodes.is_empty());
-        assert!(got.sorted_trie_updates.storage_tries.is_empty());
+        assert!(got.sorted_trie_updates.account_nodes_ref().is_empty());
+        assert!(got.sorted_trie_updates.storage_tries_ref().is_empty());
         assert!(got.sorted_post_state.accounts.is_empty());
         assert!(got.sorted_post_state.storages.is_empty());
     }
@@ -2210,12 +2214,12 @@ mod tests {
 
         // verify trie updates
         assert_eq!(
-            got.sorted_trie_updates.account_nodes,
-            block_state_diff.sorted_trie_updates.account_nodes,
+            got.sorted_trie_updates.account_nodes_ref(),
+            block_state_diff.sorted_trie_updates.account_nodes_ref(),
         );
         assert_eq!(
-            got.sorted_trie_updates.storage_tries,
-            block_state_diff.sorted_trie_updates.storage_tries,
+            got.sorted_trie_updates.storage_tries_ref(),
+            block_state_diff.sorted_trie_updates.storage_tries_ref(),
         );
 
         // verify post state

crates/trie/common/src/updates.rs

@@ -550,9 +550,9 @@ pub struct TrieUpdatesSortedRef<'a> {
 pub struct TrieUpdatesSorted {
     /// Sorted collection of updated state nodes with corresponding paths. None indicates that a
     /// node was removed.
-    pub account_nodes: Vec<(Nibbles, Option<BranchNodeCompact>)>,
-    /// Map of hashed addresses to their storage tries stored by path.
-    pub storage_tries: B256Map<StorageTrieUpdatesSorted>,
+    account_nodes: Vec<(Nibbles, Option<BranchNodeCompact>)>,
+    /// Storage tries stored by hashed address of the account the trie belongs to.
+    storage_tries: B256Map<StorageTrieUpdatesSorted>,
 }
 
 impl TrieUpdatesSorted {