perf(l1, l2): move post-execution trie updates to the background

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Perf
 
+### 2025-10-23
+
+- Move trie updates post block execution to a background thread. [#4989](https://github.com/lambdaclass/ethrex/pull/4989).
+
 ### 2025-10-21
 
 - Instead of lazy computation of blocklist, do greedy computation of allowlist and store the result, fetch it with the DB. [#4961](https://github.com/lambdaclass/ethrex/pull/4961)

crates/networking/p2p/snap.rs

@@ -180,6 +180,7 @@ mod tests {
     use ethrex_common::{BigEndianHash, H256, types::AccountState};
     use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode};
     use ethrex_storage::EngineType;
+    use ethrex_trie::EMPTY_TRIE_HASH;
 
     use crate::rlpx::snap::AccountStateSlim;
 
@@ -996,7 +997,7 @@ mod tests {
 
         // Create a store and load it up with the accounts
         let store = Store::new("null", EngineType::InMemory).unwrap();
-        let mut state_trie = store.new_state_trie_for_test()?;
+        let mut state_trie = store.open_direct_state_trie(*EMPTY_TRIE_HASH)?;
         for (address, account) in accounts {
             let hashed_address = H256::from_str(address).unwrap().as_bytes().to_vec();
             let account = AccountState::from(AccountStateSlim::decode(&account).unwrap());

crates/storage/store.rs

@@ -1503,7 +1503,7 @@ mod tests {
             })
             .collect();
         accounts.sort_by_key(|a| a.0);
-        let mut trie = store.open_state_trie(*EMPTY_TRIE_HASH).unwrap();
+        let mut trie = store.open_direct_state_trie(*EMPTY_TRIE_HASH).unwrap();
         for (address, state) in &accounts {
             trie.insert(address.0.to_vec(), state.encode_to_vec())
                 .unwrap();
@@ -1529,13 +1529,13 @@ mod tests {
             .collect();
         slots.sort_by_key(|a| a.0);
         let mut trie = store
-            .open_storage_trie(address, *EMPTY_TRIE_HASH, *EMPTY_TRIE_HASH)
+            .open_direct_storage_trie(address, *EMPTY_TRIE_HASH)
             .unwrap();
         for (slot, value) in &slots {
             trie.insert(slot.0.to_vec(), value.encode_to_vec()).unwrap();
         }
         let storage_root = trie.hash().unwrap();
-        let mut trie = store.open_state_trie(*EMPTY_TRIE_HASH).unwrap();
+        let mut trie = store.open_direct_state_trie(*EMPTY_TRIE_HASH).unwrap();
         trie.insert(
             address.0.to_vec(),
             AccountState {

crates/storage/store_db/in_memory.rs

@@ -14,7 +14,7 @@ use ethrex_trie::{InMemoryTrieDB, Nibbles, Trie, db::NodeMap};
 use std::{
     collections::HashMap,
     fmt::Debug,
-    sync::{Arc, Mutex, MutexGuard, RwLock},
+    sync::{Arc, Mutex, MutexGuard},
 };
 
 // NOTE: we use a different commit threshold than rocksdb since tests
@@ -38,7 +38,7 @@ pub struct StoreInner {
     // Maps transaction hashes to their blocks (height+hash) and index within the blocks.
     transaction_locations: HashMap<H256, Vec<(BlockNumber, BlockHash, Index)>>,
     receipts: HashMap<BlockHash, HashMap<Index, Receipt>>,
-    trie_cache: Arc<RwLock<TrieLayerCache>>,
+    trie_cache: Arc<TrieLayerCache>,
     // Contains account trie nodes
     state_trie_nodes: NodeMap,
     pending_blocks: HashMap<BlockHash, Block>,
@@ -91,10 +91,7 @@ impl StoreEngine for Store {
 
         // Store trie updates
         {
-            let mut trie = store
-                .trie_cache
-                .write()
-                .map_err(|_| StoreError::LockError)?;
+            let mut trie = TrieLayerCache::clone(&store.trie_cache);
             let parent = update_batch
                 .blocks
                 .first()
@@ -115,21 +112,24 @@ impl StoreEngine for Store {
                 .header
                 .state_root;
 
-            let mut state_trie = store
-                .state_trie_nodes
-                .lock()
-                .map_err(|_| StoreError::LockError)?;
-
-            if let Some(root) = trie.get_commitable(pre_state_root, COMMIT_THRESHOLD) {
-                let nodes = trie.commit(root).unwrap_or_default();
-                for (key, value) in nodes {
-                    if value.is_empty() {
-                        state_trie.remove(&key);
-                    } else {
-                        state_trie.insert(key, value);
+            {
+                let mut state_trie = store
+                    .state_trie_nodes
+                    .lock()
+                    .map_err(|_| StoreError::LockError)?;
+
+                if let Some(root) = trie.get_commitable(pre_state_root, COMMIT_THRESHOLD) {
+                    let nodes = trie.commit(root).unwrap_or_default();
+                    for (key, value) in nodes {
+                        if value.is_empty() {
+                            state_trie.remove(&key);
+                        } else {
+                            state_trie.insert(key, value);
+                        }
                     }
                 }
             }
+
             let key_values = update_batch
                 .storage_updates
                 .into_iter()
@@ -141,6 +141,7 @@ impl StoreEngine for Store {
                 .chain(update_batch.account_updates)
                 .collect();
             trie.put_batch(pre_state_root, last_state_root, key_values);
+            store.trie_cache = Arc::new(trie);
         }
 
         for block in update_batch.blocks {