fix(node): adapt to reth v2.0.0 breaking changes

- Remove reth-primitives dependency (deleted upstream)
- Remove PayloadBuilderAttributes trait (merged into PayloadAttributes)
- Refactor EvolveEnginePayloadBuilderAttributes to impl PayloadAttributes
- Change PayloadBuilder::Attributes to EvolveEnginePayloadAttributes
- Migrate PayloadConfig to include payload_id field
- Migrate BuildArguments to include execution_cache and trie_handle
- Rename TransactionEnv to TransactionEnvMut (alloy-evm)
- Update TryIntoTxEnv to new 3-generic-param signature
- Add consensus_ref to PoolTransaction impl
- Fix build_with_tasks generic args (3 → 2)
- Add slot_num field to BlockEnv initializers
- Remove set_state_clear_flag (handled by EVM spec)
- Update BlockBuilder::finish to accept precomputed state root
- Fix receipt conversion (replace into_rpc with map_logs)
- Fix Withdrawals/Cow type mismatches
- Rename extra_data_bytes to extra_data
- Fix reth_primitives imports to alloy_consensus/reth_primitives_traits
- Update BlockExecutorFactory::create_executor to use StateDB bound
- Also remove reth-primitives from tests/Cargo.toml

Author: randygrok

Cargo.lock

@@ -23,7 +23,6 @@ reth-ethereum = { workspace = true, features = ["node", "cli", "pool"] }
 reth-ethereum-forks.workspace = true
 reth-ethereum-payload-builder.workspace = true
 reth-payload-primitives.workspace = true
-reth-primitives.workspace = true
 reth-primitives-traits.workspace = true
 reth-node-api.workspace = true
 reth-provider = { workspace = true, features = ["test-utils"] }

crates/node/Cargo.toml

@@ -1,23 +1,21 @@
 use alloy_consensus::BlockHeader;
-use alloy_eips::{eip4895::Withdrawals, Decodable2718};
+use alloy_eips::Decodable2718;
 use alloy_primitives::{Address, Bytes, B256};
 use alloy_rpc_types::{
     engine::{PayloadAttributes as RpcPayloadAttributes, PayloadId},
     Withdrawal,
 };
 use reth_chainspec::EthereumHardforks;
 use reth_engine_local::payload::LocalPayloadAttributesBuilder;
-use reth_ethereum::node::api::payload::{PayloadAttributes, PayloadBuilderAttributes};
-use reth_payload_builder::EthPayloadBuilderAttributes;
-use reth_payload_primitives::PayloadAttributesBuilder;
+use reth_ethereum::node::api::payload::PayloadAttributes;
+use reth_payload_primitives::{payload_id, PayloadAttributesBuilder};
 use reth_primitives_traits::SealedHeader;
 use serde::{Deserialize, Serialize};
 
-use crate::tracing_ext::RecordDurationOnDrop;
-use tracing::{info, instrument};
-
 use crate::error::EvolveEngineError;
+use crate::tracing_ext::RecordDurationOnDrop;
 use ev_primitives::TransactionSigned;
+use tracing::{info, instrument};
 
 /// Evolve payload attributes that support passing transactions via Engine API.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -33,6 +31,10 @@ pub struct EvolveEnginePayloadAttributes {
 }
 
 impl PayloadAttributes for EvolveEnginePayloadAttributes {
+    fn payload_id(&self, parent_hash: &B256) -> PayloadId {
+        payload_id(parent_hash, &self.inner)
+    }
+
     fn timestamp(&self) -> u64 {
         self.inner.timestamp()
     }
@@ -57,33 +59,37 @@ impl From<RpcPayloadAttributes> for EvolveEnginePayloadAttributes {
 }
 
 /// Evolve payload builder attributes.
-#[derive(Clone, Debug, PartialEq, Eq)]
+///
+/// In reth v2.0.0, `PayloadBuilderAttributes` was removed. This type now implements
+/// `PayloadAttributes` directly and stores the decoded transactions from the Engine API.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct EvolveEnginePayloadBuilderAttributes {
-    /// Ethereum payload builder attributes.
-    pub ethereum_attributes: EthPayloadBuilderAttributes,
+    /// The inner RPC payload attributes.
+    #[serde(flatten)]
+    pub inner: RpcPayloadAttributes,
+    /// Parent block hash.
+    pub parent: B256,
     /// Decoded transactions from the Engine API.
+    #[serde(skip)]
     pub transactions: Vec<TransactionSigned>,
     /// Gas limit for the payload.
+    #[serde(rename = "gasLimit")]
     pub gas_limit: Option<u64>,
 }
 
-impl PayloadBuilderAttributes for EvolveEnginePayloadBuilderAttributes {
-    type RpcPayloadAttributes = EvolveEnginePayloadAttributes;
-    type Error = EvolveEngineError;
-
-    #[instrument(skip(parent, attributes, _version), fields(
+impl EvolveEnginePayloadBuilderAttributes {
+    /// Creates builder attributes from RPC attributes with decoded transactions.
+    #[instrument(skip(parent, attributes), fields(
         parent_hash = %parent,
         raw_tx_count = attributes.transactions.as_ref().map_or(0, |t| t.len()),
         gas_limit = ?attributes.gas_limit,
         duration_ms = tracing::field::Empty,
     ))]
-    fn try_new(
+    pub fn try_new(
         parent: B256,
         attributes: EvolveEnginePayloadAttributes,
-        _version: u8,
-    ) -> Result<Self, Self::Error> {
+    ) -> Result<Self, EvolveEngineError> {
         let _duration = RecordDurationOnDrop::new();
-        let ethereum_attributes = EthPayloadBuilderAttributes::new(parent, attributes.inner);
 
         // Decode transactions from bytes if provided.
         let transactions = attributes
@@ -102,47 +108,54 @@ impl PayloadBuilderAttributes for EvolveEnginePayloadBuilderAttributes {
         );
 
         Ok(Self {
-            ethereum_attributes,
+            inner: attributes.inner,
+            parent,
             transactions,
             gas_limit: attributes.gas_limit,
         })
     }
 
-    fn payload_id(&self) -> PayloadId {
-        self.ethereum_attributes.id
+    /// Returns the parent block hash.
+    pub fn parent(&self) -> B256 {
+        self.parent
     }
 
-    fn parent(&self) -> B256 {
-        self.ethereum_attributes.parent
+    /// Returns the suggested fee recipient.
+    pub fn suggested_fee_recipient(&self) -> Address {
+        self.inner.suggested_fee_recipient
     }
 
-    fn timestamp(&self) -> u64 {
-        self.ethereum_attributes.timestamp
+    /// Returns the prev randao value.
+    pub fn prev_randao(&self) -> B256 {
+        self.inner.prev_randao
     }
+}
 
-    fn parent_beacon_block_root(&self) -> Option<B256> {
-        self.ethereum_attributes.parent_beacon_block_root
+impl PayloadAttributes for EvolveEnginePayloadBuilderAttributes {
+    fn payload_id(&self, parent_hash: &B256) -> PayloadId {
+        payload_id(parent_hash, &self.inner)
     }
 
-    fn suggested_fee_recipient(&self) -> Address {
-        self.ethereum_attributes.suggested_fee_recipient
+    fn timestamp(&self) -> u64 {
+        self.inner.timestamp
     }
 
-    fn prev_randao(&self) -> B256 {
-        self.ethereum_attributes.prev_randao
+    fn withdrawals(&self) -> Option<&Vec<Withdrawal>> {
+        self.inner.withdrawals.as_ref()
     }
 
-    fn withdrawals(&self) -> &Withdrawals {
-        &self.ethereum_attributes.withdrawals
+    fn parent_beacon_block_root(&self) -> Option<B256> {
+        self.inner.parent_beacon_block_root
     }
 }
 
-impl From<EthPayloadBuilderAttributes> for EvolveEnginePayloadBuilderAttributes {
-    fn from(eth: EthPayloadBuilderAttributes) -> Self {
+impl From<EvolveEnginePayloadAttributes> for EvolveEnginePayloadBuilderAttributes {
+    fn from(attrs: EvolveEnginePayloadAttributes) -> Self {
         Self {
-            ethereum_attributes: eth,
+            inner: attrs.inner,
+            parent: B256::ZERO,
             transactions: Vec::new(),
-            gas_limit: None,
+            gas_limit: attrs.gas_limit,
         }
     }
 }
@@ -206,7 +219,7 @@ mod tests {
         };
 
         // we only care that the span was created with the right fields.
-        let _ = EvolveEnginePayloadBuilderAttributes::try_new(parent, attrs, 3);
+        let _ = EvolveEnginePayloadBuilderAttributes::try_new(parent, attrs);
 
         let span = collector
             .find_span("try_new")

crates/node/src/attributes.rs

@@ -12,7 +12,8 @@ use reth_evm::{
     ConfigureEvm, NextBlockEnvAttributes,
 };
 use reth_payload_builder_primitives::PayloadBuilderError;
-use reth_primitives::{transaction::SignedTransaction, Header, SealedHeader};
+use alloy_consensus::Header;
+use reth_primitives_traits::{SealedHeader, SignedTransaction};
 use reth_primitives_traits::SealedBlock;
 use reth_provider::{HeaderProvider, StateProviderFactory};
 use reth_revm::{database::StateProviderDatabase, State};
@@ -182,7 +183,7 @@ where
             trie_updates: _,
             block,
         } = builder
-            .finish(&state_provider)
+            .finish(&state_provider, None)
             .map_err(PayloadBuilderError::other)?;
 
         let sealed_block = block.sealed_block().clone();
@@ -240,7 +241,7 @@ mod tests {
     use alloy_primitives::B256;
     use evolve_ev_reth::EvolvePayloadAttributes;
     use reth_chainspec::ChainSpecBuilder;
-    use reth_primitives::Header;
+    use alloy_consensus::Header;
     use reth_provider::test_utils::MockEthProvider;
 
     #[tokio::test]
@@ -373,7 +374,7 @@ mod tests {
             input: Bytes::default(),
         };
         let signed = alloy_consensus::Signed::new_unhashed(
-            reth_primitives::Transaction::Legacy(legacy_tx),
+            reth_ethereum_primitives::Transaction::Legacy(legacy_tx),
             Signature::test_signature(),
         );
         let tx = EvTxEnvelope::Ethereum(reth_ethereum_primitives::TransactionSigned::from(signed));

crates/node/src/builder.rs

@@ -15,15 +15,15 @@ use alloy_evm::{
         spec::{EthExecutorSpec, EthSpec},
         EthBlockExecutionCtx,
     },
-    Database, EthEvmFactory, Evm, EvmFactory, FromRecoveredTx, FromTxWithEncoded, RecoveredTx,
+    EthEvmFactory, Evm, EvmFactory, FromRecoveredTx, FromTxWithEncoded, RecoveredTx,
 };
 use alloy_primitives::Log;
 use ev_primitives::{Receipt, TransactionSigned};
 use reth_ethereum_forks::EthereumHardfork;
 use reth_revm::{
     context_interface::block::Block as BlockEnvTr,
     database_interface::DatabaseCommitExt,
-    revm::{context_interface::result::ResultAndState, database::State, DatabaseCommit, Inspector},
+    revm::{context_interface::result::ResultAndState, DatabaseCommit, Inspector},
 };
 
 /// Execution result wrapper used by the EV block executor.
@@ -46,6 +46,10 @@ impl<H, T> alloy_evm::block::TxResult for EvTxResult<H, T> {
     fn result(&self) -> &ResultAndState<Self::HaltReason> {
         &self.result
     }
+
+    fn into_result(self) -> ResultAndState<Self::HaltReason> {
+        self.result
+    }
 }
 
 /// Receipt builder that works with Ev transaction envelopes.
@@ -110,11 +114,10 @@ where
     }
 }
 
-impl<'db, DB, E, Spec, R> BlockExecutor for EvBlockExecutor<'_, E, Spec, R>
+impl<E, Spec, R> BlockExecutor for EvBlockExecutor<'_, E, Spec, R>
 where
-    DB: Database + 'db,
     E: Evm<
-        DB = &'db mut State<DB>,
+        DB: alloy_evm::block::state::StateDB,
         Tx: FromRecoveredTx<R::Transaction> + FromTxWithEncoded<R::Transaction>,
     >,
     Spec: EthExecutorSpec,
@@ -127,11 +130,6 @@ where
         EvTxResult<<Self::Evm as Evm>::HaltReason, <R::Transaction as TransactionEnvelope>::TxType>;
 
     fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError> {
-        let state_clear_flag = self
-            .spec
-            .is_spurious_dragon_active_at_block(self.evm.block().number().saturating_to());
-        self.evm.db_mut().set_state_clear_flag(state_clear_flag);
-
         self.system_caller
             .apply_blockhashes_contract_call(self.ctx.parent_hash, &mut self.evm)?;
         self.system_caller
@@ -350,12 +348,12 @@ where
 
     fn create_executor<'a, DB, I>(
         &'a self,
-        evm: EvmF::Evm<&'a mut State<DB>, I>,
+        evm: EvmF::Evm<DB, I>,
         ctx: Self::ExecutionCtx<'a>,
     ) -> impl BlockExecutorFor<'a, Self, DB, I>
     where
-        DB: Database + 'a,
-        I: Inspector<EvmF::Context<&'a mut State<DB>>> + 'a,
+        DB: alloy_evm::block::state::StateDB + 'a,
+        I: Inspector<EvmF::Context<DB>> + 'a,
     {
         EvBlockExecutor::new(evm, ctx, self.spec.clone(), self.receipt_builder.clone())
     }

crates/node/src/evm_executor.rs

@@ -21,7 +21,7 @@ use reth_ethereum::{
 use reth_ethereum_forks::Hardforks;
 use reth_evm::{
     ConfigureEngineEvm, ConfigureEvm, EvmEnv, EvmEnvFor, ExecutableTxIterator, ExecutionCtxFor,
-    NextBlockEnvAttributes, TransactionEnv,
+    NextBlockEnvAttributes, TransactionEnvMut,
 };
 use reth_node_builder::PayloadBuilderConfig;
 use reth_primitives_traits::{
@@ -96,7 +96,7 @@ impl<ChainSpec, EvmF> ConfigureEvm for EvEvmConfig<ChainSpec, EvmF>
 where
     ChainSpec: EthExecutorSpec + EthChainSpec<Header = Header> + Hardforks + 'static,
     EvmF: reth_evm::EvmFactory<
-            Tx: TransactionEnv,
+            Tx: TransactionEnvMut,
             Spec = SpecId,
             BlockEnv = BlockEnv,
             Precompiles = reth_evm::precompiles::PrecompilesMap,
@@ -171,6 +171,7 @@ where
             gas_limit: header.gas_limit,
             basefee: header.base_fee_per_gas.unwrap_or_default(),
             blob_excess_gas_and_price,
+            slot_num: 0,
         };
 
         Ok(EvmEnv { cfg_env, block_env })
@@ -247,6 +248,7 @@ where
             gas_limit,
             basefee: basefee.unwrap_or_default(),
             blob_excess_gas_and_price,
+            slot_num: 0,
         };
 
         Ok(EvmEnv {
@@ -268,7 +270,7 @@ where
                 .body()
                 .withdrawals
                 .as_ref()
-                .map(std::borrow::Cow::Borrowed),
+                .map(|w| std::borrow::Cow::Borrowed(w.as_slice())),
             extra_data: block.header().extra_data.clone(),
         })
     }
@@ -283,7 +285,9 @@ where
             parent_hash: parent.hash(),
             parent_beacon_block_root: attributes.parent_beacon_block_root,
             ommers: &[],
-            withdrawals: attributes.withdrawals.map(std::borrow::Cow::Owned),
+            withdrawals: attributes
+                .withdrawals
+                .map(|w| std::borrow::Cow::Owned(w.into_inner())),
             extra_data: attributes.extra_data,
         })
     }
@@ -293,7 +297,7 @@ impl<ChainSpec, EvmF> ConfigureEngineEvm<ExecutionData> for EvEvmConfig<ChainSpe
 where
     ChainSpec: EthExecutorSpec + EthChainSpec<Header = Header> + Hardforks + 'static,
     EvmF: reth_evm::EvmFactory<
-            Tx: TransactionEnv + FromRecoveredTx<EvTxEnvelope> + FromTxWithEncoded<EvTxEnvelope>,
+            Tx: TransactionEnvMut + FromRecoveredTx<EvTxEnvelope> + FromTxWithEncoded<EvTxEnvelope>,
             Spec = SpecId,
             BlockEnv = BlockEnv,
             Precompiles = reth_evm::precompiles::PrecompilesMap,
@@ -350,6 +354,7 @@ where
             gas_limit: payload.payload.gas_limit(),
             basefee: payload.payload.saturated_base_fee_per_gas(),
             blob_excess_gas_and_price,
+            slot_num: 0,
         };
 
         Ok(EvmEnv { cfg_env, block_env })
@@ -448,7 +453,7 @@ where
     );
 
     Ok(EvEvmConfig::new_with_evm_factory(chain_spec, factory)
-        .with_extra_data(ctx.payload_builder_config().extra_data_bytes()))
+        .with_extra_data(ctx.payload_builder_config().extra_data()))
 }
 
 /// Thin wrapper so we can plug the EV executor into the node components builder.

crates/node/src/executor.rs

@@ -26,7 +26,7 @@ use std::sync::Arc;
 use tracing::info;
 
 use crate::{
-    attributes::{EvolveEnginePayloadAttributes, EvolveEnginePayloadBuilderAttributes},
+    attributes::EvolveEnginePayloadAttributes,
     executor::EvolveExecutorBuilder,
     payload_service::EvolvePayloadBuilderBuilder,
     payload_types::EvBuiltPayload,
@@ -44,7 +44,6 @@ impl PayloadTypes for EvolveEngineTypes {
     type ExecutionData = ExecutionData;
     type BuiltPayload = EvBuiltPayload;
     type PayloadAttributes = EvolveEnginePayloadAttributes;
-    type PayloadBuilderAttributes = EvolveEnginePayloadBuilderAttributes;
 
     fn block_to_payload(
         block: SealedBlock<