fix(l1): stop block building preemptively

cmd/ethrex/l2/command.rs

@@ -432,7 +432,6 @@ impl Command {
 
                     let account_updates_list = store
                         .apply_account_updates_from_trie_batch(trie, account_updates.values())
-                        .await
                         .map_err(|e| format!("Error applying account updates: {e}"))
                         .unwrap();
 

crates/blockchain/blockchain.rs

@@ -429,8 +429,7 @@ impl Blockchain {
         // Apply the account updates over the last block's state and compute the new state root
         let account_updates_list = self
             .storage
-            .apply_account_updates_batch(block.header.parent_hash, &updates)
-            .await?
+            .apply_account_updates_batch(block.header.parent_hash, &updates)?
             .ok_or(ChainError::ParentStateNotFound)?;
 
         let (gas_used, gas_limit, block_number, transactions_count) = (
@@ -606,7 +605,6 @@ impl Blockchain {
         let account_updates_list = self
             .storage
             .apply_account_updates_batch(first_block_header.parent_hash, &account_updates)
-            .await
             .map_err(|e| (e.into(), None))?
             .ok_or((ChainError::ParentStateNotFound, None))?;
 

crates/blockchain/payload.rs

@@ -42,7 +42,7 @@ use crate::{
 };
 
 use thiserror::Error;
-use tracing::{debug, error};
+use tracing::{debug, error, warn};
 
 #[derive(Debug)]
 pub struct PayloadBuildTask {
@@ -370,22 +370,29 @@ impl Blockchain {
         let self_clone = self.clone();
         const SECONDS_PER_SLOT: Duration = Duration::from_secs(12);
         // Attempt to rebuild the payload as many times within the given timeframe to maximize fee revenue
-        let mut res = self_clone.build_payload(payload.clone()).await?;
+        // TODO: start with an empty block
+        let mut res = self_clone.build_payload(payload.clone())?;
         while start.elapsed() < SECONDS_PER_SLOT && !cancel_token.is_cancelled() {
             let payload = payload.clone();
+            let self_clone = self.clone();
+            let building_task =
+                tokio::task::spawn_blocking(move || self_clone.build_payload(payload));
             // Cancel the current build process and return the previous payload if it is requested earlier
-            if let Some(current_res) = cancel_token
-                .run_until_cancelled(self_clone.build_payload(payload))
-                .await
-            {
-                res = current_res?;
+            match cancel_token.run_until_cancelled(building_task).await {
+                Some(Ok(current_res)) => {
+                    res = current_res?;
+                }
+                Some(Err(err)) => {
+                    warn!(%err, "Payload-building task panicked");
+                }
+                None => {}
             }
         }
         Ok(res)
     }
 
     /// Completes the payload building process, return the block value
-    pub async fn build_payload(&self, payload: Block) -> Result<PayloadBuildResult, ChainError> {
+    pub fn build_payload(&self, payload: Block) -> Result<PayloadBuildResult, ChainError> {
         let since = Instant::now();
         let gas_limit = payload.header.gas_limit;
 
@@ -400,7 +407,7 @@ impl Blockchain {
         self.apply_withdrawals(&mut context)?;
         self.fill_transactions(&mut context)?;
         self.extract_requests(&mut context)?;
-        self.finalize_payload(&mut context).await?;
+        self.finalize_payload(&mut context)?;
 
         let interval = Instant::now().duration_since(since).as_millis();
 
@@ -628,16 +635,12 @@ impl Blockchain {
         Ok(())
     }
 
-    pub async fn finalize_payload(
-        &self,
-        context: &mut PayloadBuildContext,
-    ) -> Result<(), ChainError> {
+    pub fn finalize_payload(&self, context: &mut PayloadBuildContext) -> Result<(), ChainError> {
         let account_updates = context.vm.get_state_transitions()?;
 
         let ret_acount_updates_list = self
             .storage
-            .apply_account_updates_batch(context.parent_hash(), &account_updates)
-            .await?
+            .apply_account_updates_batch(context.parent_hash(), &account_updates)?
             .ok_or(ChainError::ParentStateNotFound)?;
 
         let state_root = ret_acount_updates_list.state_trie_hash;

crates/blockchain/smoke_test.rs

@@ -313,7 +313,7 @@ mod blockchain_integration_test {
         let blockchain = Blockchain::default_with_store(store.clone());
 
         let block = create_payload(&args, store, Bytes::new()).unwrap();
-        let result = blockchain.build_payload(block).await.unwrap();
+        let result = blockchain.build_payload(block).unwrap();
         result.payload
     }
 

crates/l2/sequencer/block_producer.rs

@@ -194,8 +194,7 @@ impl BlockProducer {
 
         let account_updates_list = self
             .store
-            .apply_account_updates_batch(block.header.parent_hash, &account_updates)
-            .await?
+            .apply_account_updates_batch(block.header.parent_hash, &account_updates)?
             .ok_or(ChainError::ParentStateNotFound)?;
 
         let transactions_count = block.body.transactions.len();

crates/l2/sequencer/block_producer/payload_builder.rs

@@ -55,7 +55,7 @@ pub async fn build_payload(
         block_gas_limit,
     )
     .await?;
-    blockchain.finalize_payload(&mut context).await?;
+    blockchain.finalize_payload(&mut context)?;
 
     let interval = Instant::now().duration_since(since).as_millis();
     // TODO: expose as a proper metric

crates/storage/store.rs

@@ -361,7 +361,7 @@ impl Store {
     /// Applies account updates based on the block's latest storage state
     /// and returns the new state root after the updates have been applied.
     #[instrument(level = "trace", name = "Trie update", skip_all)]
-    pub async fn apply_account_updates_batch(
+    pub fn apply_account_updates_batch(
         &self,
         block_hash: BlockHash,
         account_updates: &[AccountUpdate],
@@ -370,16 +370,16 @@ impl Store {
             return Ok(None);
         };
 
-        Ok(Some(
-            self.apply_account_updates_from_trie_batch(state_trie, account_updates)
-                .await?,
-        ))
+        Ok(Some(self.apply_account_updates_from_trie_batch(
+            state_trie,
+            account_updates,
+        )?))
     }
 
-    pub async fn apply_account_updates_from_trie_batch(
+    pub fn apply_account_updates_from_trie_batch<'a>(
         &self,
         mut state_trie: Trie,
-        account_updates: impl IntoIterator<Item = &AccountUpdate>,
+        account_updates: impl IntoIterator<Item = &'a AccountUpdate>,
     ) -> Result<AccountUpdatesList, StoreError> {
         let mut ret_storage_updates = Vec::new();
         let mut code_updates = Vec::new();

tooling/ef_tests/state_v2/src/modules/result_check.rs

@@ -106,7 +106,7 @@ pub async fn check_root(
 ) -> Result<(), RunnerError> {
     let account_updates = backends::levm::LEVM::get_state_transitions(&mut vm.db.clone())
         .map_err(|e| RunnerError::FailedToGetAccountsUpdates(e.to_string()))?;
-    let post_state_root = post_state_root(&account_updates, initial_block_hash, store).await;
+    let post_state_root = post_state_root(&account_updates, initial_block_hash, store);
     if post_state_root != test_case.post.hash {
         check_result.passed = false;
         check_result.root_diff = Some((test_case.post.hash, post_state_root));
@@ -116,14 +116,13 @@ pub async fn check_root(
 
 /// Calculates the post state root applying the changes (the account updates) that are a
 /// result of running the transaction to the storage.
-pub async fn post_state_root(
+pub fn post_state_root(
     account_updates: &[AccountUpdate],
     initial_block_hash: H256,
     store: Store,
 ) -> H256 {
     let ret_account_updates_batch = store
         .apply_account_updates_batch(initial_block_hash, account_updates)
-        .await
         .unwrap()
         .unwrap();
     ret_account_updates_batch.state_trie_hash