Begin upgrading to v1.10.0-rc

Author: meyer9

Cargo.lock

@@ -12,15 +12,14 @@ use op_alloy_consensus::OpTypedTransaction;
 use op_alloy_rpc_types::OpTransactionRequest;
 use op_revm::{OpHaltReason, OpTransactionError};
 use reth_evm::{
-    ConfigureEvm, Evm, EvmError, InvalidTxError, eth::receipt_builder::ReceiptBuilderCtx,
-    precompiles::PrecompilesMap,
+    ConfigureEvm, Evm, EvmEnv, EvmError, InvalidTxError, eth::receipt_builder::ReceiptBuilderCtx, precompiles::PrecompilesMap, rpc::TryIntoTxEnv
 };
 use reth_node_api::PayloadBuilderError;
 use reth_optimism_primitives::OpTransactionSigned;
 use reth_primitives::Recovered;
 use reth_provider::{ProviderError, StateProvider};
 use reth_revm::{State, database::StateProviderDatabase};
-use reth_rpc_api::eth::{EthTxEnvError, transaction::TryIntoTxEnv};
+use reth_rpc_api::eth::{EthTxEnvError};
 use revm::{
     DatabaseCommit, DatabaseRef,
     context::{
@@ -323,7 +322,8 @@ pub trait BuilderTransactions<ExtraCtx: Debug + Default = (), Extra: Debug + Def
         expected_logs: Vec<B256>,
         evm: &mut OpEvm<impl Database, NoOpInspector, PrecompilesMap>,
     ) -> Result<SimulationSuccessResult<T>, BuilderTransactionError> {
-        let tx_env = tx.try_into_tx_env(evm.cfg(), evm.block())?;
+        let evm_env = EvmEnv { cfg_env: evm.cfg().clone(), block_env: evm.block().clone() };
+        let tx_env = tx.try_into_tx_env(&evm_env)?;
         let to = tx_env.base.kind.into_to().unwrap_or_default();
 
         let ResultAndState { result, state } = match evm.transact(tx_env) {

Cargo.toml

@@ -21,10 +21,9 @@ use core::time::Duration;
 use eyre::WrapErr as _;
 use reth::payload::PayloadBuilderAttributes;
 use reth_basic_payload_builder::BuildOutcome;
-use reth_chain_state::ExecutedBlock;
 use reth_chainspec::EthChainSpec;
 use reth_evm::{ConfigureEvm, execute::BlockBuilder};
-use reth_node_api::{Block, NodePrimitives, PayloadBuilderError};
+use reth_node_api::{Block, BuiltPayloadExecutedBlock, NodePrimitives, PayloadBuilderError};
 use reth_optimism_consensus::{calculate_receipt_root_no_memo_optimism, isthmus};
 use reth_optimism_evm::{OpEvmConfig, OpNextBlockEnvAttributes};
 use reth_optimism_forks::OpHardforks;
@@ -336,7 +335,7 @@ where
             .map_err(|e| PayloadBuilderError::Other(e.into()))?;
 
         let state_provider = self.client.state_by_block_hash(ctx.parent().hash())?;
-        let db = StateProviderDatabase::new(&state_provider);
+        let db = StateProviderDatabase::new(state_provider);
         self.address_gas_limiter.refresh(ctx.block_number());
 
         // 1. execute the pre steps and seal an early block with that
@@ -346,6 +345,8 @@ where
             .with_bundle_update()
             .build();
 
+        let state_provider = self.client.state_by_block_hash(ctx.parent().hash())?;
+
         let mut info = execute_pre_steps(&mut state, &ctx)?;
         let sequencer_tx_time = sequencer_tx_start_time.elapsed();
         ctx.metrics.sequencer_tx_duration.record(sequencer_tx_time);
@@ -537,13 +538,15 @@ where
                 return Ok(());
             }
 
+            let state_provider = self.client.state_by_block_hash(ctx.parent().hash())?;
+
             // build first flashblock immediately
             let next_flashblocks_ctx = match self
                 .build_next_flashblock(
                     &ctx,
                     &mut info,
                     &mut state,
-                    &state_provider,
+                    state_provider,
                     &mut best_txs,
                     &block_cancel,
                     &best_payload,
@@ -601,7 +604,7 @@ where
         ctx: &OpPayloadBuilderCtx<FlashblocksExtraCtx>,
         info: &mut ExecutionInfo<FlashblocksExecutionInfo>,
         state: &mut State<DB>,
-        state_provider: impl reth::providers::StateProvider + Clone,
+        state_provider: impl reth::providers::StateProvider,
         best_txs: &mut NextBestFlashblocksTxs<Pool>,
         block_cancel: &CancellationToken,
         best_payload: &BlockCell<OpBuiltPayload>,
@@ -1110,11 +1113,11 @@ where
         RecoveredBlock::new_unhashed(block.clone(), info.executed_senders.clone());
     // create the executed block data
 
-    let executed = ExecutedBlock {
+    let executed = BuiltPayloadExecutedBlock {
         recovered_block: Arc::new(recovered_block),
         execution_output: Arc::new(execution_outcome),
-        hashed_state: Arc::new(hashed_state),
-        trie_updates: Arc::new(trie_output),
+        hashed_state: either::Either::Left(Arc::new(hashed_state)),
+        trie_updates: either::Either::Left(Arc::new(trie_output)),
     };
     debug!(target: "payload_builder", message = "Executed block created");
 

crates/builder/op-rbuilder/src/builders/builder_tx.rs

@@ -470,8 +470,7 @@ mod tests {
     use alloy_primitives::U256;
     use rand::rng;
     use reth::tasks::TokioTaskExecutor;
-    use reth_chain_state::ExecutedBlock;
-    use reth_node_api::NodePrimitives;
+    use reth_node_api::{BuiltPayloadExecutedBlock, NodePrimitives};
     use reth_optimism_payload_builder::{OpPayloadPrimitives, payload::OpPayloadBuilderAttributes};
     use reth_optimism_primitives::OpPrimitives;
     use reth_primitives::SealedBlock;
@@ -590,7 +589,7 @@ mod tests {
         }
 
         /// Returns the entire execution data for the built block, if available.
-        fn executed_block(&self) -> Option<ExecutedBlock<Self::Primitives>> {
+        fn executed_block(&self) -> Option<BuiltPayloadExecutedBlock<Self::Primitives>> {
             None
         }
 

crates/builder/op-rbuilder/src/builders/flashblocks/payload.rs

@@ -14,9 +14,8 @@ use alloy_evm::Database;
 use alloy_primitives::U256;
 use reth::payload::PayloadBuilderAttributes;
 use reth_basic_payload_builder::{BuildOutcome, BuildOutcomeKind, MissingPayloadBehaviour};
-use reth_chain_state::ExecutedBlock;
 use reth_evm::{ConfigureEvm, execute::BlockBuilder};
-use reth_node_api::{Block, PayloadBuilderError};
+use reth_node_api::{Block, BuiltPayloadExecutedBlock, PayloadBuilderError};
 use reth_optimism_consensus::{calculate_receipt_root_no_memo_optimism, isthmus};
 use reth_optimism_evm::{OpEvmConfig, OpNextBlockEnvAttributes};
 use reth_optimism_forks::OpHardforks;
@@ -586,16 +585,16 @@ impl<Txs: PayloadTxsBounds> OpBuilder<'_, Txs> {
         info!(target: "payload_builder", id=%ctx.attributes().payload_id(), "sealed built block");
 
         // create the executed block data
-        let executed = ExecutedBlock {
+        let executed = BuiltPayloadExecutedBlock {
             recovered_block: Arc::new(
                 RecoveredBlock::<alloy_consensus::Block<OpTransactionSigned>>::new_sealed(
                     sealed_block.as_ref().clone(),
                     info.executed_senders,
                 ),
             ),
             execution_output: Arc::new(execution_outcome),
-            hashed_state: Arc::new(hashed_state),
-            trie_updates: Arc::new(trie_output),
+            hashed_state: either::Either::Left(Arc::new(hashed_state)),
+            trie_updates: either::Either::Left(Arc::new(trie_output)),
         };
 
         let no_tx_pool = ctx.attributes().no_tx_pool;

crates/builder/op-rbuilder/src/builders/generator.rs

@@ -78,6 +78,7 @@ where
             EngineCapabilities::new(OP_ENGINE_CAPABILITIES.iter().copied()),
             engine_validator,
             ctx.config.engine.accept_execution_requests_hash,
+            ctx.node.network().clone(),
         );
 
         Ok(OpEngineApiExt::new(OpEngineApi::new(inner)))

crates/builder/op-rbuilder/src/builders/standard/payload.rs

@@ -337,8 +337,18 @@ pub fn default_node_config() -> NodeConfig<OpChainSpec> {
     let data_path = tempdir
         .join(format!("rbuilder.{random_id}.datadir"))
         .to_path_buf();
+    
+    let rocksdb_path = tempdir
+        .join(format!("rbuilder.{random_id}.rocksdb"))
+        .to_path_buf();
+
+    let pprof_dumps_path = tempdir
+        .join(format!("rbuilder.{random_id}.pprof-dumps"))
+        .to_path_buf();
 
     std::fs::create_dir_all(&data_path).expect("Failed to create temporary data directory");
+    std::fs::create_dir_all(&rocksdb_path).expect("Failed to create temporary rocksdb directory");
+    std::fs::create_dir_all(&pprof_dumps_path).expect("Failed to create temporary pprof dumps directory");
 
     let rpc_ipc_path = tempdir
         .join(format!("rbuilder.{random_id}.rpc-ipc"))
@@ -363,6 +373,8 @@ pub fn default_node_config() -> NodeConfig<OpChainSpec> {
             .to_string_lossy()
             .parse()
             .expect("Failed to parse data dir path"),
+        rocksdb_path: Some(rocksdb_path),
+        pprof_dumps_path: Some(pprof_dumps_path),
         static_files_path: None,
     };
 

crates/builder/op-rbuilder/src/primitives/reth/engine_api_builder.rs

@@ -253,8 +253,9 @@ where
         // state hasn't been cleared yet after canonical block commit
         if let Some(canonical_tx) = EthTransactions::transaction_by_hash(&self.eth_api, tx_hash)
             .await?
-            .map(|tx| tx.into_transaction(self.eth_api.tx_resp_builder()))
-            .transpose()?
+            .map(|tx| tx.into_transaction(self.eth_api.converter()))
+            .transpose()
+            .map_err(Eth::Error::from)?
         {
             return Ok(Some(canonical_tx));
         }

crates/builder/op-rbuilder/src/tests/framework/instance.rs

@@ -8,7 +8,7 @@ use alloy_op_evm::block::receipt_builder::OpReceiptBuilder;
 use alloy_primitives::B256;
 use alloy_rpc_types::TransactionTrait;
 use alloy_rpc_types_eth::state::StateOverride;
-use op_alloy_consensus::{OpDepositReceipt, OpTxEnvelope};
+use op_alloy_consensus::{OpDepositReceipt, OpReceipt, OpTxEnvelope};
 use op_alloy_rpc_types::{OpTransactionReceipt, Transaction};
 use reth::revm::{Database, DatabaseCommit, context::result::ResultAndState, state::EvmState};
 use reth_evm::{
@@ -131,11 +131,12 @@ where
         effective_gas_price: u128,
     ) -> Result<ExecutedPendingTransaction, StateProcessorError> {
         let (deposit_receipt_version, deposit_nonce) = if transaction.is_deposit() {
-            let deposit_receipt = receipt
+            let OpReceipt::Deposit(deposit_receipt) = &receipt
                 .inner
                 .inner
-                .as_deposit_receipt()
-                .ok_or(ExecutionError::DepositReceiptMismatch)?;
+                .receipt else {
+                    return Err(ExecutionError::DepositReceiptMismatch.into());
+                };
 
             (deposit_receipt.deposit_receipt_version, deposit_receipt.deposit_nonce)
         } else {
@@ -261,11 +262,12 @@ where
                 self.next_log_index += receipt.logs().len();
 
                 let (deposit_receipt_version, deposit_nonce) = if transaction.is_deposit() {
-                    let deposit_receipt = op_receipt
+                    let OpReceipt::Deposit(deposit_receipt) =  &op_receipt
                         .inner
                         .inner
-                        .as_deposit_receipt()
-                        .ok_or(ExecutionError::DepositReceiptMismatch)?;
+                        .receipt else {
+                            return Err(ExecutionError::DepositReceiptMismatch.into());
+                        };
 
                     (deposit_receipt.deposit_receipt_version, deposit_receipt.deposit_nonce)
                 } else {