refactor(evm): generalize ethereum block executor types

Author: klkvr

crates/ethereum/evm/src/execution.rs

@@ -13,11 +13,11 @@ use alloc::{
     vec::Vec,
 };
 #[cfg(test)]
+use alloy_consensus::Transaction;
+#[cfg(test)]
 use alloy_consensus::TxType;
 use alloy_consensus::{
-    constants::ETH_TO_WEI,
-    transaction::{Recovered, Transaction},
-    BlockHeader, Header,
+    constants::ETH_TO_WEI, transaction::Recovered, BlockHeader, Header, TxReceipt,
 };
 use alloy_eips::{
     eip2718::Typed2718,
@@ -27,7 +27,7 @@ use alloy_eips::{
     eip7251::CONSOLIDATION_REQUEST_TYPE,
     eip7685::Requests,
 };
-use alloy_primitives::{map::AddressMap, Address, Bytes, B256, KECCAK256_EMPTY, U256};
+use alloy_primitives::{map::AddressMap, Address, Bytes, Log, B256, KECCAK256_EMPTY, U256};
 use alloy_sol_types::{sol, SolEvent};
 use core::{any::Any, convert::Infallible};
 #[cfg(test)]
@@ -36,7 +36,6 @@ use evm2::evm::Db;
 use evm2::Precompiles;
 use evm2::{
     bytecode::Bytecode as ExecutableBytecode,
-    ethereum::RecoveredTxEnvelope,
     evm::{
         AccountChange, AccountChangeRef, AccountInfo, BlockStateAccumulator, StateChangeSink,
         StateChangeSource, StateChanges, StorageChange, SystemTx, BEACON_ROOTS_ADDRESS,
@@ -49,20 +48,21 @@ use evm2::{
 #[cfg(test)]
 use evm2::{
     env::BlockEnv,
-    ethereum::ethereum_tx_registry,
+    ethereum::{ethereum_tx_registry, RecoveredTxEnvelope},
     evm::{precompile::PrecompileProvider, Database, DynDatabase},
     BaseEvmTypes, ExecutionConfig, Version,
 };
 use reth_ethereum_forks::EthereumHardforks;
+#[cfg(test)]
 use reth_ethereum_primitives::Receipt;
 #[cfg(test)]
 use reth_ethereum_primitives::TransactionSigned;
 use reth_evm::{BlockExecutionError, BlockValidationError, EvmError, InvalidTxError};
 #[cfg(test)]
 use reth_evm::{ReceiptBuilder, ReceiptBuilderCtx};
-#[cfg(test)]
-use reth_execution_types::BlockExecutionOutput;
 use reth_execution_types::HashedPostStateSink;
+#[cfg(test)]
+use reth_execution_types::{BlockExecutionOutput, BlockExecutionResult};
 use reth_trie_common::{HashedPostState, KeccakKeyHasher};
 
 const DEPOSIT_BYTES_SIZE: usize = 48 + 32 + 8 + 96 + 8;
@@ -459,16 +459,17 @@ where
             context.withdrawals,
         )?;
 
-        let mut output = <RethReceiptBuilder as ReceiptBuilder<
-            TxType,
-            TxResult<BaseEvmTypes>,
-        >>::build_block_output(&RethReceiptBuilder, receipts, block_state, blob_gas_used);
-        output.result.requests = requests;
+        let gas_used = receipts.last().map_or(0, TxReceipt::cumulative_gas_used);
+        let output = BlockExecutionOutput::new(
+            BlockExecutionResult { receipts, requests, gas_used, blob_gas_used },
+            block_state,
+        );
 
         Ok(output)
     }
 }
 
+#[cfg(test)]
 pub(crate) fn transaction_blob_gas_used(transaction: &RecoveredTxEnvelope) -> u64 {
     transaction.as_eip4844().map(|tx| tx.blob_gas_used().unwrap_or_default()).unwrap_or_default()
 }
@@ -828,11 +829,14 @@ pub(crate) fn pre_execution_system_call_state_changes<T: EvmTypes>(
     Ok(())
 }
 
-pub(crate) fn block_requests_from_receipts(
+pub(crate) fn block_requests_from_receipts<R>(
     spec_id: SpecId,
     context: BlockExecutionContext<'_>,
-    receipts: &[Receipt],
-) -> Result<Requests, EthExecutionError> {
+    receipts: &[R],
+) -> Result<Requests, EthExecutionError>
+where
+    R: TxReceipt<Log = Log>,
+{
     let mut requests = Requests::default();
     if context.system_calls.is_none() || !spec_id.enables(SpecId::PRAGUE) {
         return Ok(requests)
@@ -847,13 +851,16 @@ pub(crate) fn block_requests_from_receipts(
     Ok(requests)
 }
 
-fn parse_deposit_requests_from_receipts(
+fn parse_deposit_requests_from_receipts<R>(
     deposit_contract_address: Address,
-    receipts: &[Receipt],
-) -> Result<Vec<u8>, EthExecutionError> {
+    receipts: &[R],
+) -> Result<Vec<u8>, EthExecutionError>
+where
+    R: TxReceipt<Log = Log>,
+{
     let mut out = Vec::new();
     for receipt in receipts {
-        for log in &receipt.logs {
+        for log in receipt.logs() {
             if log.address != deposit_contract_address ||
                 log.topics().first() != Some(&DepositEvent::SIGNATURE_HASH)
             {

crates/ethereum/evm/src/executor.rs

@@ -5,47 +5,53 @@ use crate::{
         base_block_reward, block_requests_from_receipts, commit_detached_transaction,
         execute_transaction_without_commit, post_block_balance_state_changes,
         post_execution_system_call_state_changes, pre_execution_system_call_state_changes,
-        transaction_blob_gas_used, BlockExecutionContext, BlockSystemCalls, EthExecutionError,
+        BlockExecutionContext, BlockSystemCalls, EthExecutionError,
     },
     factory::{EthBlockExecutorFactory, EvmFactory},
     EthBlockExecutionCtx, EthEvmEnv, RethReceiptBuilder,
 };
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
-use alloy_consensus::{Header, Transaction, TxType};
+use alloy_consensus::{
+    transaction::{TransactionEnvelope, TxHashRef},
+    Header, Transaction, TxType as EthTxType,
+};
 use alloy_eip7928::{BlockAccessIndex, BlockAccessList};
 use alloy_eips::{eip2718::Typed2718, eip4895::Withdrawal, eip7685::Requests};
 use alloy_primitives::{Address, B256};
 use evm2::{
     ethereum::TxEnvelope,
     evm::{Bal, BlockStateAccumulator, StateChangeSource},
     interpreter::Host,
-    BaseEvmTypes, Evm, EvmTypes, TxResult, TxResultWithState,
+    BaseEvmTypes, Evm, EvmTypes, TxResultWithState,
 };
 use reth_ethereum_forks::EthereumHardforks;
 use reth_ethereum_primitives::{Receipt, TransactionSigned};
 use reth_evm::{
     BlockExecutionError, BlockExecutionOutput, BlockExecutor, BlockTransactionResult,
     BlockValidationError, ExecutorTx, GasOutput, ReceiptBuilder, ReceiptBuilderCtx, RecoveredTx,
 };
+use reth_execution_types::BlockExecutionResult;
 use reth_trie_common::HashedPostState;
 
 /// Configured Ethereum block executor backed by evm2.
 #[expect(missing_debug_implementations)]
-pub struct EthBlockExecutor<'a, T = BaseEvmTypes>
+pub struct EthBlockExecutor<'a, T = BaseEvmTypes, R = RethReceiptBuilder>
 where
-    T: EvmTypes<Tx = TxEnvelope>,
+    T: EvmTypes,
     T::Tx: Typed2718,
     T::TxResultExt: Send,
+    R: ReceiptBuilder,
 {
     evm: Evm<'a, T>,
     ctx: EthBlockExecutionCtx<'a>,
+    receipt_builder: R,
     spec_id: evm2::SpecId,
     base_block_reward: Option<u128>,
     deposit_contract_address: Option<Address>,
     block_state: BlockStateAccumulator,
     hashed_state_mode: HashedStateMode,
     hashed_state_update_hook: HashedStateUpdateHook,
-    receipts: Vec<Receipt>,
+    receipts: Vec<R::Receipt>,
     cumulative_gas_used: u64,
     block_regular_gas_used: u64,
     block_state_gas_used: u64,
@@ -56,7 +62,7 @@ where
 
 /// Detached Ethereum transaction result with the metadata needed for canonical receipt commit.
 #[derive(Debug)]
-pub struct EthTransactionResultWithState<T = BaseEvmTypes>
+pub struct EthTransactionResultWithState<T = BaseEvmTypes, TxType = EthTxType>
 where
     T: EvmTypes,
 {
@@ -65,7 +71,7 @@ where
     blob_gas_used: u64,
 }
 
-impl<T: EvmTypes> BlockTransactionResult<T> for EthTransactionResultWithState<T> {
+impl<T: EvmTypes, TxType> BlockTransactionResult<T> for EthTransactionResultWithState<T, TxType> {
     fn result(&self) -> &TxResultWithState<T> {
         &self.result
     }
@@ -89,11 +95,12 @@ impl HashedStateMode {
     }
 }
 
-impl<'a, T> EthBlockExecutor<'a, T>
+impl<'a, T, R> EthBlockExecutor<'a, T, R>
 where
-    T: EvmTypes<Tx = TxEnvelope>,
+    T: EvmTypes,
     T::Tx: Typed2718,
     T::TxResultExt: Send,
+    R: ReceiptBuilder,
 {
     /// Creates a configured Ethereum block executor.
     pub(crate) fn new<C>(
@@ -102,6 +109,7 @@ where
         chain_spec: &C,
         deposit_contract_address: Option<alloy_primitives::Address>,
         hashed_state_mode: HashedStateMode,
+        receipt_builder: R,
     ) -> Self
     where
         C: EthereumHardforks + ?Sized,
@@ -116,6 +124,7 @@ where
         Self {
             evm,
             ctx,
+            receipt_builder,
             spec_id,
             base_block_reward: base_block_reward(chain_spec, block_number),
             deposit_contract_address,
@@ -152,24 +161,29 @@ where
     }
 
     #[inline]
-    fn set_transaction_block_access_index(&mut self) {
+    const fn set_transaction_block_access_index(&mut self) {
         if self.block_access_list_builder_enabled() {
             let index = self.receipts.len() as u64 + 1 + self.bal_index_offset;
-            self.set_block_access_index(BlockAccessIndex::new(index));
+            self.evm.state_mut().set_bal_index(BlockAccessIndex::new(index));
         }
     }
 }
 
-impl<'a, T> BlockExecutor for EthBlockExecutor<'a, T>
+impl<'a, T, R> BlockExecutor for EthBlockExecutor<'a, T, R>
 where
-    T: EvmTypes<Tx = TxEnvelope>,
-    T::Tx: Typed2718,
+    T: EvmTypes,
+    T::Tx: Transaction + Typed2718,
     T::TxResultExt: Send,
+    R: ReceiptBuilder,
+    R::Transaction: TxHashRef,
+    R::Receipt: alloy_consensus::TxReceipt<Log = alloy_primitives::Log>,
+    <R::Transaction as TransactionEnvelope>::TxType: Send + 'static,
 {
-    type Transaction = TransactionSigned;
-    type Receipt = Receipt;
+    type Transaction = R::Transaction;
+    type Receipt = R::Receipt;
     type Evm = Evm<'a, T>;
-    type TransactionResultWithState = EthTransactionResultWithState<T>;
+    type TransactionResultWithState =
+        EthTransactionResultWithState<T, <R::Transaction as TransactionEnvelope>::TxType>;
     type BlockAccessList = Bal;
 
     fn evm(&self) -> &Self::Evm {
@@ -267,9 +281,8 @@ where
             }
             .into())
         }
-        let blob_gas_used = transaction_blob_gas_used(&transaction);
-        let tx_type =
-            TxType::try_from(transaction.ty()).expect("transaction envelope has valid type");
+        let blob_gas_used = tx.tx().blob_gas_used().unwrap_or_default();
+        let tx_type = tx.tx().tx_type();
         let result = execute_transaction_without_commit(&mut self.evm, &transaction)
             .map_err(|err| map_transaction_execution_error(err, tx_hash))?;
         Ok(EthTransactionResultWithState { result, tx_type, blob_gas_used })
@@ -294,21 +307,22 @@ where
         self.block_state_gas_used = self.block_state_gas_used.saturating_add(state_gas_used);
         self.cumulative_gas_used += tx_gas_used;
         self.blob_gas_used += blob_gas_used;
-        self.receipts.push(RethReceiptBuilder.build_receipt(ReceiptBuilderCtx {
+        self.receipts.push(self.receipt_builder.build_receipt(ReceiptBuilderCtx {
             tx_type,
             result: outcome,
             cumulative_gas_used: self.cumulative_gas_used,
         }));
         Ok(GasOutput::new_with_regular(tx_gas_used, regular_gas_used, state_gas_used))
     }
 
-    fn receipts(&self) -> &[Receipt] {
+    fn receipts(&self) -> &[Self::Receipt] {
         &self.receipts
     }
 
     fn finish_with_block_access_list(
         mut self,
-    ) -> Result<(BlockExecutionOutput<Receipt>, Option<BlockAccessList>), BlockExecutionError> {
+    ) -> Result<(BlockExecutionOutput<Self::Receipt>, Option<BlockAccessList>), BlockExecutionError>
+    {
         self.set_transaction_block_access_index();
         let context = Self::block_context(
             self.deposit_contract_address,
@@ -359,15 +373,15 @@ where
             self.block_regular_gas_used,
             self.block_state_gas_used,
         );
-        let mut output =
-            <RethReceiptBuilder as ReceiptBuilder<TxType, TxResult<T>>>::build_block_output(
-                &RethReceiptBuilder,
-                self.receipts,
-                self.block_state,
-                self.blob_gas_used,
-            );
-        output.result.gas_used = block_gas_used;
-        output.result.requests = requests;
+        let output = BlockExecutionOutput::new(
+            BlockExecutionResult {
+                receipts: self.receipts,
+                requests,
+                gas_used: block_gas_used,
+                blob_gas_used: self.blob_gas_used,
+            },
+            self.block_state,
+        );
 
         Ok((output, block_access_list))
     }
@@ -503,8 +517,8 @@ where
     <F::Types as evm2::EvmTypesHost>::Tx: Typed2718,
     <F::Types as evm2::EvmTypesHost>::TxResultExt: Send,
 {
-    inner: EthBlockExecutor<'a, F::Types>,
-    factory: &'a EthBlockExecutorFactory<C, F>,
+    inner: EthBlockExecutor<'a, F::Types, &'a RethReceiptBuilder>,
+    factory: &'a EthBlockExecutorFactory<RethReceiptBuilder, C, F>,
     chain_spec: Arc<C>,
     plan: EthBigBlockPlan<'a, F::Types>,
     next_segment: usize,
@@ -527,8 +541,8 @@ where
     <F::Types as evm2::EvmTypesHost>::TxResultExt: Send,
 {
     pub(crate) fn new(
-        inner: EthBlockExecutor<'a, F::Types>,
-        factory: &'a EthBlockExecutorFactory<C, F>,
+        inner: EthBlockExecutor<'a, F::Types, &'a RethReceiptBuilder>,
+        factory: &'a EthBlockExecutorFactory<RethReceiptBuilder, C, F>,
         chain_spec: Arc<C>,
         plan: EthBigBlockPlan<'a, F::Types>,
     ) -> Self {