feat(l1): block size limit in building (#4397)

**Motivation**

Finish implementing [EIP-7934](https://eips.ethereum.org/EIPS/eip-7934)
for the case of payload building.

**Description**

This pr includes a check of block size during building so it finishes
when surpassing the 10MiB cap introduced in EIP-7934 for Osaka.

Also, it updates the test runner to include the new exception.

To test if the cap is respected I launched a local net with the dora
service activated running `make localnet` and I used Dora to check the
proposed blocks by ethrex.

First I did this setting `MAX_RLP_BLOCK_SIZE = 1200`
And I could verify the blocks proposed by ethrex were all really small,
they only had three transactions.
Here an example with some logs I added:

Block 27 with its 3 transactions:
<img width="564" height="255" alt="Screenshot 2025-10-30 at 17 57 50"
src="https://github.com/user-attachments/assets/ecd7791b-7ffd-45ac-a81b-f21ca5afeb86"
/>
<img width="339" height="309" alt="Screenshot 2025-10-30 at 17 58 03"
src="https://github.com/user-attachments/assets/afd5648b-cdaf-4e39-b368-779d67fac195"
/>
Here in the logs we can see when these transactions were added and how
there was a forth one that didn't make it because it surpassed the rlp
size limit:
<img width="1029" height="516" alt="Screenshot 2025-10-30 at 18 31 05"
src="https://github.com/user-attachments/assets/97bb979c-8fb5-489d-aec8-6d82365ab7c5"
/>

I also dropped the cap to 800 bytes and in that case all block proposed
by ethrex were empty.

This pr also adds support for the local ef tests runner.

---------

Co-authored-by: cdiielsi <[email protected]>
Co-authored-by: Camila Di Ielsi <[email protected]>

Author: SDartayet

crates/blockchain/payload.rs

@@ -8,7 +8,7 @@ use std::{
 
 use ethrex_common::{
     Address, Bloom, Bytes, H256, U256,
-    constants::{DEFAULT_OMMERS_HASH, DEFAULT_REQUESTS_HASH, GAS_PER_BLOB},
+    constants::{DEFAULT_OMMERS_HASH, DEFAULT_REQUESTS_HASH, GAS_PER_BLOB, MAX_RLP_BLOCK_SIZE},
     types::{
         AccountUpdate, BlobsBundle, Block, BlockBody, BlockHash, BlockHeader, BlockNumber,
         ChainConfig, MempoolTransaction, Receipt, Transaction, TxType, Withdrawal, bloom_from_logs,
@@ -217,6 +217,7 @@ pub struct PayloadBuildContext {
     pub store: Store,
     pub vm: Evm,
     pub account_updates: Vec<AccountUpdate>,
+    pub payload_size: u64,
 }
 
 impl PayloadBuildContext {
@@ -237,6 +238,7 @@ impl PayloadBuildContext {
         let vm_db = StoreVmDatabase::new(storage.clone(), payload.header.parent_hash);
         let vm = new_evm(blockchain_type, vm_db)?;
 
+        let payload_size = payload.encode_to_vec().len() as u64;
         Ok(PayloadBuildContext {
             remaining_gas: payload.header.gas_limit,
             receipts: vec![],
@@ -250,6 +252,7 @@ impl PayloadBuildContext {
             store: storage.clone(),
             vm,
             account_updates: Vec::new(),
+            payload_size,
         })
     }
 
@@ -529,6 +532,20 @@ impl Blockchain {
                 continue;
             }
 
+            // Check adding a transaction wouldn't exceed the Osaka block size limit of 10 MiB
+            // if inclusion of the transaction puts the block size over the size limit
+            // we don't add any more txs to the payload.
+            let potential_rlp_block_size =
+                context.payload_size + head_tx.encode_canonical_to_vec().len() as u64;
+            if context
+                .chain_config()
+                .is_osaka_activated(context.payload.header.timestamp)
+                && potential_rlp_block_size > MAX_RLP_BLOCK_SIZE
+            {
+                break;
+            }
+            context.payload_size = potential_rlp_block_size;
+
             // TODO: maybe fetch hash too when filtering mempool so we don't have to compute it here (we can do this in the same refactor as adding timestamp)
             let tx_hash = head_tx.tx.hash();
 

tooling/ef_tests/blockchain/Makefile

@@ -51,6 +51,6 @@ test-sp1: $(VECTORS_TARGETS)
 test-stateless: $(VECTORS_TARGETS)
 	cargo test --profile release-with-debug --features stateless
 
-test: ## 🧪 Run blockchain tests with both VMs, and also stateless with LEVM
+test: ## 🧪 Run blockchain tests with LEVM both with state and stateless 
 	$(MAKE) test-levm
 	$(MAKE) test-stateless

tooling/ef_tests/blockchain/deserialize.rs

@@ -120,6 +120,9 @@ where
                         BlockExpectedException::SystemContractCallFailed,
                     )
                 }
+                "BlockException.RLP_BLOCK_LIMIT_EXCEEDED" => BlockChainExpectedException::BlockException(
+                    BlockExpectedException::RlpBlockLimitExceeded,
+                ),
                 _ => BlockChainExpectedException::Other,
             })
             .collect();

tooling/ef_tests/blockchain/test_runner.rs

@@ -196,6 +196,11 @@ fn exception_is_expected(
                     BlockExpectedException::SystemContractCallFailed
                 ),
                 ChainError::EvmError(EvmError::SystemContractCallFailed(_))
+            ) | (
+                BlockChainExpectedException::BlockException(
+                    BlockExpectedException::RlpBlockLimitExceeded
+                ),
+                ChainError::InvalidBlock(InvalidBlockError::MaximumRlpSizeExceeded(_, _))
             ) | (
                 BlockChainExpectedException::Other,
                 _ //TODO: Decide whether to support more specific errors.

tooling/ef_tests/blockchain/types.rs

@@ -605,5 +605,6 @@ pub enum BlockExpectedException {
     IncorrectBlockFormat,
     InvalidRequest,
     SystemContractCallFailed,
+    RlpBlockLimitExceeded,
     Other, //TODO: Implement exceptions
 }