fix(l2): limit block to blob size

crates/blockchain/payload.rs

@@ -159,8 +159,9 @@ pub fn calc_gas_limit(parent_gas_limit: u64) -> u64 {
     limit
 }
 
-pub struct PayloadBuildContext<'a> {
-    pub payload: &'a mut Block,
+#[derive(Clone)]
+pub struct PayloadBuildContext {
+    pub payload: Block,
     pub remaining_gas: u64,
     pub receipts: Vec<Receipt>,
     pub requests: Vec<EncodedRequests>,
@@ -173,12 +174,8 @@ pub struct PayloadBuildContext<'a> {
     pub account_updates: Vec<AccountUpdate>,
 }
 
-impl<'a> PayloadBuildContext<'a> {
-    fn new(
-        payload: &'a mut Block,
-        evm_engine: EvmEngine,
-        storage: &Store,
-    ) -> Result<Self, EvmError> {
+impl PayloadBuildContext {
+    pub fn new(payload: Block, evm_engine: EvmEngine, storage: &Store) -> Result<Self, EvmError> {
         let config = storage.get_chain_config()?;
         let base_fee_per_blob_gas = calculate_base_fee_per_blob_gas(
             payload.header.excess_blob_gas.unwrap_or_default(),
@@ -205,12 +202,12 @@ impl<'a> PayloadBuildContext<'a> {
     }
 }
 
-impl<'a> PayloadBuildContext<'a> {
+impl PayloadBuildContext {
     fn parent_hash(&self) -> BlockHash {
         self.payload.header.parent_hash
     }
 
-    fn block_number(&self) -> BlockNumber {
+    pub fn block_number(&self) -> BlockNumber {
         self.payload.header.number
     }
 
@@ -229,16 +226,18 @@ pub struct PayloadBuildResult {
     pub receipts: Vec<Receipt>,
     pub requests: Vec<EncodedRequests>,
     pub account_updates: Vec<AccountUpdate>,
+    pub payload: Block,
 }
 
-impl<'a> From<PayloadBuildContext<'a>> for PayloadBuildResult {
+impl From<PayloadBuildContext> for PayloadBuildResult {
     fn from(value: PayloadBuildContext) -> Self {
         let PayloadBuildContext {
             blobs_bundle,
             block_value,
             requests,
             receipts,
             account_updates,
+            payload,
             ..
         } = value;
 
@@ -248,13 +247,14 @@ impl<'a> From<PayloadBuildContext<'a>> for PayloadBuildResult {
             requests,
             receipts,
             account_updates,
+            payload,
         }
     }
 }
 
 impl Blockchain {
     /// Completes the payload building process, return the block value
-    pub fn build_payload(&self, payload: &mut 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;
 
@@ -284,7 +284,7 @@ impl Blockchain {
         Ok(context.into())
     }
 
-    fn apply_withdrawals(&self, context: &mut PayloadBuildContext) -> Result<(), EvmError> {
+    pub fn apply_withdrawals(&self, context: &mut PayloadBuildContext) -> Result<(), EvmError> {
         let binding = Vec::new();
         let withdrawals = context
             .payload
@@ -310,7 +310,7 @@ impl Blockchain {
 
     /// Fetches suitable transactions from the mempool
     /// Returns two transaction queues, one for plain and one for blob txs
-    fn fetch_mempool_transactions(
+    pub fn fetch_mempool_transactions(
         &self,
         context: &mut PayloadBuildContext,
     ) -> Result<(TransactionQueue, TransactionQueue), ChainError> {
@@ -445,7 +445,7 @@ impl Blockchain {
 
     /// Executes the transaction, updates gas-related context values & return the receipt
     /// The payload build context should have enough remaining gas to cover the transaction's gas_limit
-    fn apply_transaction(
+    pub fn apply_transaction(
         &self,
         head: &HeadTransaction,
         context: &mut PayloadBuildContext,
@@ -523,7 +523,7 @@ impl Blockchain {
         Ok(())
     }
 
-    fn finalize_payload(&self, context: &mut PayloadBuildContext) -> Result<(), ChainError> {
+    pub fn finalize_payload(&self, context: &mut PayloadBuildContext) -> Result<(), ChainError> {
         let parent_hash = context.payload.header.parent_hash;
         let account_updates = context.vm.get_state_transitions(parent_hash)?;
 
@@ -543,7 +543,7 @@ impl Blockchain {
 
 /// A struct representing suitable mempool transactions waiting to be included in a block
 // TODO: Consider using VecDequeue instead of Vec
-struct TransactionQueue {
+pub struct TransactionQueue {
     // The first transaction for each account along with its tip, sorted by highest tip
     heads: Vec<HeadTransaction>,
     // The remaining txs grouped by account and sorted by nonce
@@ -553,8 +553,8 @@ struct TransactionQueue {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
-struct HeadTransaction {
-    tx: MempoolTransaction,
+pub struct HeadTransaction {
+    pub tx: MempoolTransaction,
     tip: u64,
 }
 
@@ -603,24 +603,24 @@ impl TransactionQueue {
     }
 
     /// Remove all transactions from the queue
-    fn clear(&mut self) {
+    pub fn clear(&mut self) {
         self.heads.clear();
         self.txs.clear();
     }
 
     /// Returns true if there are no more transactions in the queue
-    fn is_empty(&self) -> bool {
+    pub fn is_empty(&self) -> bool {
         self.heads.is_empty()
     }
 
     /// Returns the head transaction with the highest tip
     /// If there is more than one transaction with the highest tip, return the one with the lowest timestamp
-    fn peek(&self) -> Option<HeadTransaction> {
+    pub fn peek(&self) -> Option<HeadTransaction> {
         self.heads.first().cloned()
     }
 
     /// Removes current head transaction and all transactions from the given sender
-    fn pop(&mut self) {
+    pub fn pop(&mut self) {
         if !self.is_empty() {
             let sender = self.heads.remove(0).tx.sender();
             self.txs.remove(&sender);
@@ -629,7 +629,7 @@ impl TransactionQueue {
 
     /// Remove the top transaction
     /// Add a tx from the same sender to the head transactions
-    fn shift(&mut self) -> Result<(), ChainError> {
+    pub fn shift(&mut self) -> Result<(), ChainError> {
         let tx = self.heads.remove(0);
         if let Some(txs) = self.txs.get_mut(&tx.tx.sender()) {
             // Fetch next head

crates/blockchain/smoke_test.rs

@@ -277,9 +277,9 @@ mod blockchain_integration_test {
         // Create blockchain
         let blockchain = Blockchain::default_with_store(store.clone().clone());
 
-        let mut block = create_payload(&args, store).unwrap();
-        blockchain.build_payload(&mut block).unwrap();
-        block
+        let block = create_payload(&args, store).unwrap();
+        let result = blockchain.build_payload(block).unwrap();
+        result.payload
     }
 
     fn test_store() -> Store {

crates/l2/sequencer/block_producer.rs

@@ -1,3 +1,4 @@
+mod payload_builder;
 use std::{
     sync::Arc,
     time::{Duration, SystemTime, UNIX_EPOCH},
@@ -12,6 +13,7 @@ use ethrex_common::Address;
 use ethrex_storage::Store;
 use ethrex_vm::backends::BlockExecutionResult;
 use keccak_hash::H256;
+use payload_builder::build_payload;
 use tokio::time::sleep;
 use tracing::{debug, error, info};
 
@@ -99,14 +101,17 @@ impl BlockProducer {
             beacon_root: Some(head_beacon_block_root),
             version,
         };
-        let mut payload = create_payload(&args, &store)?;
+        let payload = create_payload(&args, &store)?;
 
         // Blockchain builds the payload from mempool txs and executes them
-        let payload_build_result = blockchain.build_payload(&mut payload)?;
-        info!("Built payload for new block {}", payload.header.number);
+        let payload_build_result = build_payload(blockchain.clone(), payload, &store)?;
+        info!(
+            "Built payload for new block {}",
+            payload_build_result.payload.header.number
+        );
 
         // Blockchain stores block
-        let block = payload;
+        let block = payload_build_result.payload;
         let chain_config = store.get_chain_config()?;
         validate_block(&block, &head_header, &chain_config)?;