refactor(levm,l1,l2): split block execution and update generation (#2519)

**Motivation**

Currently during batch processing, the state transitions are calculated
for every block and then merged, when it would be more performant to
calculate them once at the end.

**Description**

This PR removes the account updates from the execution result and makes
every consumer manually request them.

<!-- Link to issues: Resolves #111, Resolves #222 -->

Closes #2504

Author: iovoid

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### 2025-04-22
 
+- Avoid calculating state transitions after every block in bulk mode [2519](https://github.com/lambdaclass/ethrex/pull/2519)
+
 - Transform the inlined variant of NodeHash to a constant sized array [2516](https://github.com/lambdaclass/ethrex/pull/2516)
 
 ### 2025-04-11

crates/blockchain/blockchain.rs

@@ -10,15 +10,15 @@ use error::MempoolError;
 use error::{ChainError, InvalidBlockError};
 use ethrex_common::constants::{GAS_PER_BLOB, MIN_BASE_FEE_PER_BLOB_GAS};
 use ethrex_common::types::requests::{compute_requests_hash, EncodedRequests, Requests};
-use ethrex_common::types::BlobsBundle;
 use ethrex_common::types::MempoolTransaction;
 use ethrex_common::types::{
     compute_receipts_root, validate_block_header, validate_cancun_header_fields,
     validate_prague_header_fields, validate_pre_cancun_header_fields, Block, BlockHash,
     BlockHeader, BlockNumber, ChainConfig, EIP4844Transaction, Receipt, Transaction,
 };
+use ethrex_common::types::{BlobsBundle, Fork};
 
-use ethrex_common::{Address, H160, H256};
+use ethrex_common::{Address, H256};
 use mempool::Mempool;
 use std::collections::HashMap;
 use std::{ops::Div, time::Instant};
@@ -62,14 +62,18 @@ impl Blockchain {
     }
 
     /// Executes a block withing a new vm instance and state
-    async fn execute_block(&self, block: &Block) -> Result<BlockExecutionResult, ChainError> {
+    async fn execute_block(
+        &self,
+        block: &Block,
+    ) -> Result<(BlockExecutionResult, Vec<AccountUpdate>), ChainError> {
         // Validate if it can be the new head and find the parent
         let Ok(parent_header) = find_parent_header(&block.header, &self.storage) else {
             // If the parent is not present, we store it as pending.
             self.storage.add_pending_block(block.clone()).await?;
             return Err(ChainError::ParentNotFound);
         };
         let chain_config = self.storage.get_chain_config()?;
+        let fork = chain_config.fork(block.header.timestamp);
 
         // Validate the block pre-execution
         validate_block(block, &parent_header, &chain_config)?;
@@ -80,13 +84,14 @@ impl Blockchain {
             block.header.parent_hash,
         );
         let execution_result = vm.execute_block(block)?;
+        let account_updates = vm.get_state_transitions(fork)?;
 
         // Validate execution went alright
         validate_gas_used(&execution_result.receipts, &block.header)?;
         validate_receipts_root(&block.header, &execution_result.receipts)?;
         validate_requests_hash(&block.header, &chain_config, &execution_result.requests)?;
 
-        Ok(execution_result)
+        Ok((execution_result, account_updates))
     }
 
     /// Executes a block from a given vm instance an does not clear its state
@@ -114,11 +119,12 @@ impl Blockchain {
         &self,
         block: &Block,
         execution_result: BlockExecutionResult,
+        account_updates: &[AccountUpdate],
     ) -> Result<(), ChainError> {
         // Apply the account updates over the last block's state and compute the new state root
         let new_state_root = self
             .storage
-            .apply_account_updates(block.header.parent_hash, &execution_result.account_updates)
+            .apply_account_updates(block.header.parent_hash, account_updates)
             .await?
             .ok_or(ChainError::ParentStateNotFound)?;
 
@@ -137,9 +143,9 @@ impl Blockchain {
 
     pub async fn add_block(&self, block: &Block) -> Result<(), ChainError> {
         let since = Instant::now();
-        let res = self.execute_block(block).await?;
+        let (res, updates) = self.execute_block(block).await?;
         let executed = Instant::now();
-        let result = self.store_block(block, res).await;
+        let result = self.store_block(block, res, &updates).await;
         let stored = Instant::now();
         Self::print_add_block_logs(block, since, executed, stored);
         result
@@ -197,6 +203,8 @@ impl Blockchain {
             .storage
             .get_chain_config()
             .map_err(|e| (e.into(), None))?;
+        let fork = chain_config.fork(first_block_header.timestamp);
+
         let mut vm = Evm::new(
             self.evm_engine,
             self.storage.clone(),
@@ -205,12 +213,20 @@ impl Blockchain {
 
         let blocks_len = blocks.len();
         let mut all_receipts: HashMap<BlockHash, Vec<Receipt>> = HashMap::new();
-        let mut all_account_updates: HashMap<H160, AccountUpdate> = HashMap::new();
         let mut total_gas_used = 0;
         let mut transactions_count = 0;
 
         let interval = Instant::now();
         for (i, block) in blocks.iter().enumerate() {
+            if is_crossing_spuriousdragon(fork, chain_config.fork(block.header.timestamp)) {
+                return Err((
+                    ChainError::Custom("Crossing fork boundary in bulk mode".into()),
+                    Some(BatchBlockProcessingFailure {
+                        last_valid_hash,
+                        failed_block_hash: block.hash(),
+                    }),
+                ));
+            }
             // for the first block, we need to query the store
             let parent_header = if i == 0 {
                 let Ok(parent_header) = find_parent_header(&block.header, &self.storage) else {
@@ -228,11 +244,12 @@ impl Blockchain {
                 blocks[i - 1].header.clone()
             };
 
-            let BlockExecutionResult {
-                receipts,
-                account_updates,
-                ..
-            } = match self.execute_block_from_state(&parent_header, block, &chain_config, &mut vm) {
+            let BlockExecutionResult { receipts, .. } = match self.execute_block_from_state(
+                &parent_header,
+                block,
+                &chain_config,
+                &mut vm,
+            ) {
                 Ok(result) => result,
                 Err(err) => {
                     return Err((
@@ -245,44 +262,24 @@ impl Blockchain {
                 }
             };
 
-            // Merge account updates
-            for account_update in account_updates {
-                let Some(cache) = all_account_updates.get_mut(&account_update.address) else {
-                    all_account_updates.insert(account_update.address, account_update);
-                    continue;
-                };
-
-                cache.removed = account_update.removed;
-                if let Some(code) = account_update.code {
-                    cache.code = Some(code);
-                };
-
-                if let Some(info) = account_update.info {
-                    cache.info = Some(info);
-                }
-
-                for (k, v) in account_update.added_storage.into_iter() {
-                    cache.added_storage.insert(k, v);
-                }
-            }
-
             last_valid_hash = block.hash();
             total_gas_used += block.header.gas_used;
             transactions_count += block.body.transactions.len();
             all_receipts.insert(block.hash(), receipts);
         }
 
+        let account_updates = vm
+            .get_state_transitions(fork)
+            .map_err(|err| (ChainError::EvmError(err), None))?;
+
         let Some(last_block) = blocks.last() else {
             return Err((ChainError::Custom("Last block not found".into()), None));
         };
 
         // Apply the account updates over all blocks and compute the new state root
         let new_state_root = self
             .storage
-            .apply_account_updates(
-                first_block_header.parent_hash,
-                &all_account_updates.into_values().collect::<Vec<_>>(),
-            )
+            .apply_account_updates(first_block_header.parent_hash, &account_updates)
             .await
             .map_err(|e| (e.into(), None))?
             .ok_or((ChainError::ParentStateNotFound, None))?;
@@ -653,5 +650,15 @@ fn get_total_blob_gas(tx: &EIP4844Transaction) -> u64 {
     GAS_PER_BLOB * tx.blob_versioned_hashes.len() as u64
 }
 
+fn is_crossing_spuriousdragon(from: Fork, to: Fork) -> bool {
+    if from >= Fork::SpuriousDragon {
+        return false;
+    }
+    if to < Fork::SpuriousDragon {
+        return false;
+    }
+    from != to
+}
+
 #[cfg(test)]
 mod tests {}

crates/l2/prover/src/backends/exec.rs

@@ -1,4 +1,4 @@
-use ethrex_blockchain::{validate_block, validate_gas_used};
+use ethrex_blockchain::validate_block;
 use ethrex_l2::utils::prover::proving_systems::{ProofCalldata, ProverType};
 use ethrex_l2_sdk::calldata::Value;
 use ethrex_vm::Evm;
@@ -54,11 +54,12 @@ fn execution_program(input: ProgramInput) -> Result<ProgramOutput, Box<dyn std::
     if !verify_db(&db, &state_trie, &storage_tries)? {
         return Err("invalid database".to_string().into());
     };
+    let fork = db.chain_config.fork(block.header.timestamp);
 
     let mut vm = Evm::from_execution_db(db.clone());
-    let result = vm.execute_block(&block)?;
-    let receipts = result.receipts;
-    let account_updates = result.account_updates;
+    let _result = vm.execute_block(&block)?;
+    // let receipts = result.receipts;
+    let account_updates = vm.get_state_transitions(fork)?;
     // validate_gas_used(&receipts, &block.header)?;
 
     // Update state trie

crates/l2/prover/zkvm/interface/pico/src/main.rs

@@ -41,7 +41,7 @@ pub fn main() {
 
     let result = REVM::execute_block(&block, &mut state).expect("failed to execute block");
     let receipts = result.receipts;
-    let account_updates = result.account_updates;
+    let account_updates = REVM::get_state_transitions(&mut state);
     validate_gas_used(&receipts, &block.header).expect("invalid gas used");
 
     // Output gas for measurement purposes

crates/l2/prover/zkvm/interface/risc0/src/main.rs

@@ -31,10 +31,11 @@ fn main() {
         panic!("invalid database")
     };
 
+    let fork = db.chain_config.fork(block.header.timestamp);
     let mut evm = Evm::from_execution_db(db.clone());
     let result = evm.execute_block(&block).expect("failed to execute block");
     let receipts = result.receipts;
-    let account_updates = result.account_updates;
+    let account_updates = evm.get_state_transitions(fork).expect("failed to get state transitions");
     validate_gas_used(&receipts, &block.header).expect("invalid gas used");
 
     // Output gas for measurement purposes

crates/l2/prover/zkvm/interface/sp1/src/main.rs

@@ -31,11 +31,12 @@ pub fn main() {
     if !verify_db(&db, &state_trie, &storage_tries).expect("failed to validate database") {
         panic!("invalid database")
     };
+    let fork = db.chain_config.fork(block.header.timestamp);
 
     let mut evm = Evm::from_execution_db(db.clone());
     let result = evm.execute_block(&block).expect("failed to execute block");
     let receipts = result.receipts;
-    let account_updates = result.account_updates;
+    let account_updates = evm.get_state_transitions(fork).expect("failed to get state transitions");
     // validate_gas_used(&receipts, &block.header).expect("invalid gas used");
 
     // Output gas for measurement purposes

crates/l2/sequencer/block_producer.rs

@@ -116,20 +116,21 @@ impl BlockProducer {
         let chain_config = store.get_chain_config()?;
         validate_block(&block, &head_header, &chain_config)?;
 
+        let account_updates = payload_build_result.account_updates;
+
         let execution_result = BlockExecutionResult {
-            account_updates: payload_build_result.account_updates,
             receipts: payload_build_result.receipts,
             requests: Vec::new(),
         };
 
         blockchain
-            .store_block(&block, execution_result.clone())
+            .store_block(&block, execution_result.clone(), &account_updates)
             .await?;
         info!("Stored new block {:x}", block.hash());
         // WARN: We're not storing the payload into the Store because there's no use to it by the L2 for now.
 
         // Cache execution result
-        execution_cache.push(block.hash(), execution_result.account_updates)?;
+        execution_cache.push(block.hash(), account_updates)?;
 
         // Make the new head be part of the canonical chain
         apply_fork_choice(&store, block.hash(), block.hash(), block.hash()).await?;

crates/l2/sequencer/l1_committer.rs

@@ -150,9 +150,13 @@ impl Committer {
                 warn!(
                             "Could not find execution cache result for block {block_number}, falling back to re-execution"
                         );
-                Evm::default(self.store.clone(), block_to_commit.header.parent_hash)
-                    .execute_block(&block_to_commit)
-                    .map(|result| result.account_updates)?
+                let mut vm = Evm::default(self.store.clone(), block_to_commit.header.parent_hash);
+                vm.execute_block(&block_to_commit)?;
+                let fork = self
+                    .store
+                    .get_chain_config()?
+                    .fork(block_to_commit.header.timestamp);
+                vm.get_state_transitions(fork)?
             }
         };
 

crates/l2/utils/prover/save_state.rs

@@ -454,9 +454,9 @@ mod tests {
                 block_hash: block.hash(),
             };
             let mut db = GeneralizedDatabase::new(Arc::new(store.clone()), CacheDB::new());
-            let account_updates = LEVM::execute_block(blocks.last().unwrap(), &mut db)
-                .unwrap()
-                .account_updates;
+            LEVM::execute_block(blocks.last().unwrap(), &mut db)?;
+            let fork = db.store.get_chain_config().fork(block.header.timestamp);
+            let account_updates = LEVM::get_state_transitions(&mut db, fork)?;
 
             account_updates_vec.push(account_updates.clone());
 

crates/vm/backends/levm/mod.rs

@@ -44,11 +44,11 @@ impl LEVM {
         block: &Block,
         db: &mut GeneralizedDatabase,
     ) -> Result<BlockExecutionResult, EvmError> {
-        let chain_config = db.store.get_chain_config();
-        let block_header = &block.header;
-        let fork = chain_config.fork(block_header.timestamp);
         cfg_if::cfg_if! {
             if #[cfg(not(feature = "l2"))] {
+                let chain_config = db.store.get_chain_config();
+                let block_header = &block.header;
+                let fork = chain_config.fork(block_header.timestamp);
                 if block_header.parent_beacon_block_root.is_some() && fork >= Fork::Cancun {
                     Self::beacon_root_contract_call(block_header, db)?;
                 }
@@ -90,13 +90,7 @@ impl LEVM {
             }
         }
 
-        let account_updates = Self::get_state_transitions(db, fork)?;
-
-        Ok(BlockExecutionResult {
-            receipts,
-            requests,
-            account_updates,
-        })
+        Ok(BlockExecutionResult { receipts, requests })
     }
 
     pub fn execute_tx(
@@ -391,6 +385,7 @@ impl LEVM {
     ) -> Result<ExecutionDB, ExecutionDBError> {
         let parent_hash = block.header.parent_hash;
         let chain_config = store.get_chain_config()?;
+        let fork = chain_config.fork(block.header.timestamp);
 
         let logger = Arc::new(DatabaseLogger::new(Arc::new(StoreWrapper {
             store: store.clone(),
@@ -400,9 +395,8 @@ impl LEVM {
         let mut db = GeneralizedDatabase::new(logger, CacheDB::new());
 
         // pre-execute and get all state changes
-        let execution_updates = Self::execute_block(block, &mut db)
-            .map_err(Box::new)?
-            .account_updates;
+        let _ = Self::execute_block(block, &mut db);
+        let execution_updates = Self::get_state_transitions(&mut db, fork).map_err(Box::new)?;
 
         // index accessed account addresses and storage keys
         let state_accessed = logger_ref