feat: implement EIP-7685

bin/reth/src/commands/db/diff.rs

@@ -6,7 +6,7 @@ use crate::{
 use clap::Parser;
 use reth_db::{
     cursor::DbCursorRO, database::Database, open_db_read_only, table::Table, transaction::DbTx,
-    AccountChangeSets, AccountsHistory, AccountsTrie, BlockBodyIndices, BlockOmmers,
+    AccountChangeSets, AccountsHistory, AccountsTrie, BlockBodyIndices, BlockOmmers, BlockRequests,
     BlockWithdrawals, Bytecodes, CanonicalHeaders, DatabaseEnv, HashedAccounts, HashedStorages,
     HeaderNumbers, HeaderTerminalDifficulties, Headers, PlainAccountState, PlainStorageState,
     PruneCheckpoints, Receipts, StageCheckpointProgresses, StageCheckpoints, StorageChangeSets,
@@ -98,6 +98,9 @@ impl Command {
                 Tables::BlockWithdrawals => {
                     find_diffs::<BlockWithdrawals>(primary_tx, secondary_tx, output_dir)?
                 }
+                Tables::BlockRequests => {
+                    find_diffs::<BlockRequests>(primary_tx, secondary_tx, output_dir)?
+                }
                 Tables::TransactionBlocks => {
                     find_diffs::<TransactionBlocks>(primary_tx, secondary_tx, output_dir)?
                 }

bin/reth/src/commands/db/stats.rs

@@ -8,12 +8,12 @@ use human_bytes::human_bytes;
 use itertools::Itertools;
 use reth_db::{
     database::Database, mdbx, static_file::iter_static_files, AccountChangeSets, AccountsHistory,
-    AccountsTrie, BlockBodyIndices, BlockOmmers, BlockWithdrawals, Bytecodes, CanonicalHeaders,
-    DatabaseEnv, HashedAccounts, HashedStorages, HeaderNumbers, HeaderTerminalDifficulties,
-    Headers, PlainAccountState, PlainStorageState, PruneCheckpoints, Receipts,
-    StageCheckpointProgresses, StageCheckpoints, StorageChangeSets, StoragesHistory, StoragesTrie,
-    Tables, TransactionBlocks, TransactionHashNumbers, TransactionSenders, Transactions,
-    VersionHistory,
+    AccountsTrie, BlockBodyIndices, BlockOmmers, BlockRequests, BlockWithdrawals, Bytecodes,
+    CanonicalHeaders, DatabaseEnv, HashedAccounts, HashedStorages, HeaderNumbers,
+    HeaderTerminalDifficulties, Headers, PlainAccountState, PlainStorageState, PruneCheckpoints,
+    Receipts, StageCheckpointProgresses, StageCheckpoints, StorageChangeSets, StoragesHistory,
+    StoragesTrie, Tables, TransactionBlocks, TransactionHashNumbers, TransactionSenders,
+    Transactions, VersionHistory,
 };
 use reth_fs_util as fs;
 use reth_node_core::dirs::{ChainPath, DataDirPath};
@@ -333,6 +333,7 @@ impl Command {
                 Tables::BlockBodyIndices => viewer.get_checksum::<BlockBodyIndices>().unwrap(),
                 Tables::BlockOmmers => viewer.get_checksum::<BlockOmmers>().unwrap(),
                 Tables::BlockWithdrawals => viewer.get_checksum::<BlockWithdrawals>().unwrap(),
+                Tables::BlockRequests => viewer.get_checksum::<BlockRequests>().unwrap(),
                 Tables::Bytecodes => viewer.get_checksum::<Bytecodes>().unwrap(),
                 Tables::CanonicalHeaders => viewer.get_checksum::<CanonicalHeaders>().unwrap(),
                 Tables::HashedAccounts => viewer.get_checksum::<HashedAccounts>().unwrap(),

bin/reth/src/commands/debug_cmd/execution.rs

@@ -187,7 +187,7 @@ impl Command {
             match get_single_header(&client, BlockHashOrNumber::Number(block)).await {
                 Ok(tip_header) => {
                     info!(target: "reth::cli", ?block, "Successfully fetched block");
-                    return Ok(tip_header.hash());
+                    return Ok(tip_header.hash())
                 }
                 Err(error) => {
                     error!(target: "reth::cli", ?block, %error, "Failed to fetch the block. Retrying...");
@@ -255,7 +255,7 @@ impl Command {
             provider.get_stage_checkpoint(StageId::Finish)?.map(|ch| ch.block_number);
         if latest_block_number.unwrap_or_default() >= self.to {
             info!(target: "reth::cli", latest = latest_block_number, "Nothing to run");
-            return Ok(());
+            return Ok(())
         }
 
         let pipeline_events = pipeline.events();

bin/reth/src/commands/debug_cmd/merkle.rs

@@ -198,7 +198,8 @@ impl Command {
                 PruneModes::none(),
             );
             executor.execute_and_verify_one((&sealed_block.clone().unseal(), td).into())?;
-            let BatchBlockExecutionOutput { bundle, receipts, first_block } = executor.finalize();
+            let BatchBlockExecutionOutput { bundle, receipts, requests: _, first_block } =
+                executor.finalize();
             BundleStateWithReceipts::new(bundle, receipts, first_block).write_to_storage(
                 provider_rw.tx_ref(),
                 None,

bin/reth/src/commands/stage/drop.rs

@@ -110,6 +110,7 @@ impl Command {
                 tx.clear::<tables::TransactionBlocks>()?;
                 tx.clear::<tables::BlockOmmers>()?;
                 tx.clear::<tables::BlockWithdrawals>()?;
+                tx.clear::<tables::BlockRequests>()?;
                 tx.put::<tables::StageCheckpoints>(
                     StageId::Bodies.to_string(),
                     Default::default(),

crates/blockchain-tree/src/blockchain_tree.rs

@@ -1631,6 +1631,7 @@ mod tests {
                     body: body.clone().into_iter().map(|tx| tx.into_signed()).collect(),
                     ommers: Vec::new(),
                     withdrawals: Some(Withdrawals::default()),
+                    requests: None,
                 },
                 body.iter().map(|tx| tx.signer()).collect(),
             )

crates/blockchain-tree/src/chain.rs

@@ -9,7 +9,7 @@ use reth_blockchain_tree_api::{
     error::{BlockchainTreeError, InsertBlockErrorKind},
     BlockAttachment, BlockValidationKind,
 };
-use reth_consensus::{Consensus, ConsensusError};
+use reth_consensus::{Consensus, ConsensusError, PostExecutionInput};
 use reth_db::database::Database;
 use reth_evm::execute::{BlockExecutionOutput, BlockExecutorProvider, Executor};
 use reth_execution_errors::BlockExecutionError;
@@ -210,8 +210,10 @@ impl AppendableChain {
         let block = block.unseal();
 
         let state = executor.execute((&block, U256::MAX).into())?;
-        let BlockExecutionOutput { state, receipts, .. } = state;
-        externals.consensus.validate_block_post_execution(&block, &receipts)?;
+        let BlockExecutionOutput { state, receipts, requests, .. } = state;
+        externals
+            .consensus
+            .validate_block_post_execution(&block, PostExecutionInput::new(&receipts, &requests))?;
 
         let bundle_state = BundleStateWithReceipts::new(
             state,

crates/consensus/auto-seal/src/lib.rs

@@ -16,14 +16,14 @@
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
 use reth_beacon_consensus::BeaconEngineMessage;
-use reth_consensus::{Consensus, ConsensusError};
+use reth_consensus::{Consensus, ConsensusError, PostExecutionInput};
 use reth_engine_primitives::EngineTypes;
 use reth_interfaces::executor::{BlockExecutionError, BlockValidationError};
 use reth_primitives::{
     constants::{EMPTY_TRANSACTIONS, ETHEREUM_BLOCK_GAS_LIMIT},
     eip4844::calculate_excess_blob_gas,
     proofs, Block, BlockBody, BlockHash, BlockHashOrNumber, BlockNumber, BlockWithSenders,
-    ChainSpec, Header, Receipt, Receipts, SealedBlock, SealedHeader, TransactionSigned,
+    ChainSpec, Header, Receipts, Requests, SealedBlock, SealedHeader, TransactionSigned,
     Withdrawals, B256, U256,
 };
 use reth_provider::{
@@ -92,7 +92,7 @@ impl Consensus for AutoSealConsensus {
     fn validate_block_post_execution(
         &self,
         _block: &BlockWithSenders,
-        _receipts: &[Receipt],
+        _input: PostExecutionInput<'_>,
     ) -> Result<(), ConsensusError> {
         Ok(())
     }
@@ -277,6 +277,7 @@ impl StorageInner {
         transactions: &[TransactionSigned],
         ommers: &[Header],
         withdrawals: Option<&Withdrawals>,
+        requests: Option<&Requests>,
         chain_spec: Arc<ChainSpec>,
     ) -> Header {
         let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs();
@@ -319,6 +320,7 @@ impl StorageInner {
             excess_blob_gas: None,
             extra_data: Default::default(),
             parent_beacon_block_root: None,
+            requests_root: requests.map(|r| proofs::calculate_requests_root(&r.0)),
         };
 
         if chain_spec.is_cancun_active_at_timestamp(timestamp) {
@@ -354,11 +356,13 @@ impl StorageInner {
     /// Builds and executes a new block with the given transactions, on the provided executor.
     ///
     /// This returns the header of the executed block, as well as the poststate from execution.
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn build_and_execute<Provider, Executor>(
         &mut self,
         transactions: Vec<TransactionSigned>,
         ommers: Vec<Header>,
         withdrawals: Option<Withdrawals>,
+        requests: Option<Requests>,
         provider: &Provider,
         chain_spec: Arc<ChainSpec>,
         executor: &Executor,
@@ -367,14 +371,20 @@ impl StorageInner {
         Executor: BlockExecutorProvider,
         Provider: StateProviderFactory,
     {
-        let header =
-            self.build_header_template(&transactions, &ommers, withdrawals.as_ref(), chain_spec);
+        let header = self.build_header_template(
+            &transactions,
+            &ommers,
+            withdrawals.as_ref(),
+            requests.as_ref(),
+            chain_spec,
+        );
 
         let block = Block {
             header,
             body: transactions,
             ommers: ommers.clone(),
             withdrawals: withdrawals.clone(),
+            requests: requests.clone(),
         }
         .with_recovered_senders()
         .ok_or(BlockExecutionError::Validation(BlockValidationError::SenderRecoveryError))?;
@@ -394,8 +404,12 @@ impl StorageInner {
             block.number,
         );
 
+        // todo(onbjerg): we should not pass requests around as this is building a block, which
+        // means we need to extract the requests from the execution output and compute the requests
+        // root here
+
         let Block { mut header, body, .. } = block.block;
-        let body = BlockBody { transactions: body, ommers, withdrawals };
+        let body = BlockBody { transactions: body, ommers, withdrawals, requests };
 
         trace!(target: "consensus::auto", ?bundle_state, ?header, ?body, "executed block, calculating state root and completing header");
 

crates/consensus/auto-seal/src/task.rs

@@ -4,7 +4,7 @@ use reth_beacon_consensus::{BeaconEngineMessage, ForkchoiceStatus};
 use reth_engine_primitives::EngineTypes;
 use reth_evm::execute::BlockExecutorProvider;
 use reth_primitives::{
-    Block, ChainSpec, IntoRecoveredTransaction, SealedBlockWithSenders, Withdrawals,
+    Block, ChainSpec, IntoRecoveredTransaction, Requests, SealedBlockWithSenders, Withdrawals,
 };
 use reth_provider::{CanonChainTracker, CanonStateNotificationSender, Chain, StateProviderFactory};
 use reth_rpc_types::engine::ForkchoiceState;
@@ -137,12 +137,15 @@ where
                         })
                         .unzip();
                     let ommers = vec![];
+                    // todo(onbjerg): these two dont respect chainspec
                     let withdrawals = Some(Withdrawals::default());
+                    let requests = Some(Requests::default());
 
                     match storage.build_and_execute(
                         transactions.clone(),
                         ommers.clone(),
                         withdrawals.clone(),
+                        requests.clone(),
                         &client,
                         chain_spec,
                         &executor,
@@ -201,6 +204,7 @@ where
                                 body: transactions,
                                 ommers,
                                 withdrawals,
+                                requests,
                             };
                             let sealed_block = block.seal_slow();