diff --git a/crates/optimism/evm/src/lib.rs b/crates/optimism/evm/src/lib.rs index 7e5ae9e5b4c..96b9c101883 100644 --- a/crates/optimism/evm/src/lib.rs +++ b/crates/optimism/evm/src/lib.rs @@ -14,7 +14,7 @@ extern crate alloc; use alloc::sync::Arc; use alloy_consensus::{BlockHeader, Header}; use alloy_eips::Decodable2718; -use alloy_evm::{FromRecoveredTx, FromTxWithEncoded}; +use alloy_evm::{EvmFactory, FromRecoveredTx, FromTxWithEncoded}; use alloy_op_evm::block::receipt_builder::OpReceiptBuilder; use alloy_primitives::U256; use core::fmt::Debug; @@ -23,7 +23,8 @@ use op_alloy_rpc_types_engine::OpExecutionData; use op_revm::{OpSpecId, OpTransaction}; use reth_chainspec::EthChainSpec; use reth_evm::{ - ConfigureEngineEvm, ConfigureEvm, EvmEnv, EvmEnvFor, ExecutableTxIterator, ExecutionCtxFor, + precompiles::PrecompilesMap, ConfigureEngineEvm, ConfigureEvm, EvmEnv, EvmEnvFor, + ExecutableTxIterator, ExecutionCtxFor, TransactionEnv, }; use reth_optimism_chainspec::OpChainSpec; use reth_optimism_forks::OpHardforks; @@ -60,15 +61,19 @@ pub struct OpEvmConfig< ChainSpec = OpChainSpec, N: NodePrimitives = OpPrimitives, R = OpRethReceiptBuilder, + EvmFactory = OpEvmFactory, > { /// Inner [`OpBlockExecutorFactory`]. - pub executor_factory: OpBlockExecutorFactory>, + pub executor_factory: OpBlockExecutorFactory, EvmFactory>, /// Optimism block assembler. pub block_assembler: OpBlockAssembler, - _pd: core::marker::PhantomData, + #[doc(hidden)] + pub _pd: core::marker::PhantomData, } -impl Clone for OpEvmConfig { +impl Clone + for OpEvmConfig +{ fn clone(&self) -> Self { Self { executor_factory: self.executor_factory.clone(), @@ -98,14 +103,20 @@ impl OpEvmConfig _pd: core::marker::PhantomData, } } +} +impl OpEvmConfig +where + ChainSpec: OpHardforks, + N: NodePrimitives, +{ /// Returns the chain spec associated with this configuration. pub const fn chain_spec(&self) -> &Arc { self.executor_factory.spec() } } -impl ConfigureEvm for OpEvmConfig +impl ConfigureEvm for OpEvmConfig where ChainSpec: EthChainSpec
+ OpHardforks, N: NodePrimitives< @@ -117,12 +128,19 @@ where >, OpTransaction: FromRecoveredTx + FromTxWithEncoded, R: OpReceiptBuilder, + EvmF: EvmFactory< + Tx: FromRecoveredTx + + FromTxWithEncoded + + TransactionEnv, + Precompiles = PrecompilesMap, + Spec = OpSpecId, + > + Debug, Self: Send + Sync + Unpin + Clone + 'static, { type Primitives = N; type Error = EIP1559ParamError; type NextBlockEnvCtx = OpNextBlockEnvAttributes; - type BlockExecutorFactory = OpBlockExecutorFactory>; + type BlockExecutorFactory = OpBlockExecutorFactory, EvmF>; type BlockAssembler = OpBlockAssembler; fn block_executor_factory(&self) -> &Self::BlockExecutorFactory { diff --git a/crates/optimism/node/tests/it/builder.rs b/crates/optimism/node/tests/it/builder.rs index eba2aed422d..e0437a5f655 100644 --- a/crates/optimism/node/tests/it/builder.rs +++ b/crates/optimism/node/tests/it/builder.rs @@ -1,11 +1,32 @@ //! Node builder setup tests. +use alloy_primitives::{address, Bytes}; +use core::marker::PhantomData; +use op_revm::{ + precompiles::OpPrecompiles, OpContext, OpHaltReason, OpSpecId, OpTransaction, + OpTransactionError, +}; use reth_db::test_utils::create_test_rw_db; +use reth_evm::{precompiles::PrecompilesMap, Database, Evm, EvmEnv, EvmFactory}; use reth_node_api::{FullNodeComponents, NodeTypesWithDBAdapter}; -use reth_node_builder::{Node, NodeBuilder, NodeConfig}; -use reth_optimism_chainspec::BASE_MAINNET; -use reth_optimism_node::{args::RollupArgs, OpNode}; +use reth_node_builder::{ + components::ExecutorBuilder, BuilderContext, FullNodeTypes, Node, NodeBuilder, NodeConfig, + NodeTypes, +}; +use reth_optimism_chainspec::{OpChainSpec, BASE_MAINNET, OP_SEPOLIA}; +use reth_optimism_evm::{OpBlockExecutorFactory, OpEvm, OpEvmFactory, OpRethReceiptBuilder}; +use reth_optimism_node::{args::RollupArgs, OpEvmConfig, OpExecutorBuilder, OpNode}; +use reth_optimism_primitives::OpPrimitives; use reth_provider::providers::BlockchainProvider; +use revm::{ + context::{Cfg, ContextTr, TxEnv}, + context_interface::result::EVMError, + inspector::NoOpInspector, + interpreter::interpreter::EthInterpreter, + precompile::{Precompile, PrecompileId, PrecompileOutput, PrecompileResult, Precompiles}, + Inspector, +}; +use std::sync::OnceLock; #[test] fn test_basic_setup() { @@ -36,3 +57,112 @@ fn test_basic_setup() { }) .check_launch(); } + +#[test] +fn test_setup_custom_precompiles() { + /// Unichain custom precompiles. + struct UniPrecompiles; + + impl UniPrecompiles { + /// Returns map of precompiles for Unichain. + fn precompiles(spec_id: OpSpecId) -> PrecompilesMap { + static INSTANCE: OnceLock = OnceLock::new(); + + PrecompilesMap::from_static(INSTANCE.get_or_init(|| { + let mut precompiles = OpPrecompiles::new_with_spec(spec_id).precompiles().clone(); + // Custom precompile. + let precompile = Precompile::new( + PrecompileId::custom("custom"), + address!("0x0000000000000000000000000000000000756e69"), + |_, _| PrecompileResult::Ok(PrecompileOutput::new(0, Bytes::new())), + ); + precompiles.extend([precompile]); + precompiles + })) + } + } + + /// Builds Unichain EVM configuration. + #[derive(Clone, Debug)] + struct UniEvmFactory; + + impl EvmFactory for UniEvmFactory { + type Evm>> = OpEvm; + type Context = OpContext; + type Tx = OpTransaction; + type Error = + EVMError; + type HaltReason = OpHaltReason; + type Spec = OpSpecId; + type Precompiles = PrecompilesMap; + + fn create_evm( + &self, + db: DB, + input: EvmEnv, + ) -> Self::Evm { + let mut op_evm = OpEvmFactory::default().create_evm(db, input); + *op_evm.components_mut().2 = UniPrecompiles::precompiles(op_evm.ctx().cfg().spec()); + + op_evm + } + + fn create_evm_with_inspector< + DB: Database, + I: Inspector, EthInterpreter>, + >( + &self, + db: DB, + input: EvmEnv, + inspector: I, + ) -> Self::Evm { + let mut op_evm = + OpEvmFactory::default().create_evm_with_inspector(db, input, inspector); + *op_evm.components_mut().2 = UniPrecompiles::precompiles(op_evm.ctx().cfg().spec()); + + op_evm + } + } + + /// Unichain executor builder. + struct UniExecutorBuilder; + + impl ExecutorBuilder for UniExecutorBuilder + where + Node: FullNodeTypes>, + { + type EVM = OpEvmConfig< + OpChainSpec, + ::Primitives, + OpRethReceiptBuilder, + UniEvmFactory, + >; + + async fn build_evm(self, ctx: &BuilderContext) -> eyre::Result { + let OpEvmConfig { executor_factory, block_assembler, _pd: _ } = + OpExecutorBuilder::default().build_evm(ctx).await?; + let uni_executor_factory = OpBlockExecutorFactory::new( + *executor_factory.receipt_builder(), + ctx.chain_spec(), + UniEvmFactory, + ); + let uni_evm_config = OpEvmConfig { + executor_factory: uni_executor_factory, + block_assembler, + _pd: PhantomData, + }; + Ok(uni_evm_config) + } + } + + NodeBuilder::new(NodeConfig::new(OP_SEPOLIA.clone())) + .with_database(create_test_rw_db()) + .with_types::() + .with_components( + OpNode::default() + .components() + // Custom EVM configuration + .executor(UniExecutorBuilder), + ) + .check_launch(); +} diff --git a/examples/custom-evm/src/main.rs b/examples/custom-evm/src/main.rs index e60cd669ab0..b5e69670ec7 100644 --- a/examples/custom-evm/src/main.rs +++ b/examples/custom-evm/src/main.rs @@ -100,7 +100,7 @@ where } } -/// Returns precompiles for Fjor spec. +/// Returns precompiles for Prague spec. pub fn prague_custom() -> &'static Precompiles { static INSTANCE: OnceLock = OnceLock::new(); INSTANCE.get_or_init(|| {