Revert "Moving Optimism bin to Optimism Cli" (#9875)

bin/reth/Cargo.toml

@@ -56,6 +56,9 @@ reth-static-file-types = { workspace = true, features = ["clap"] }
 reth-trie = { workspace = true, features = ["metrics"] }
 reth-trie-db = { workspace = true, features = ["metrics"] }
 reth-node-api.workspace = true
+reth-node-optimism = { workspace = true, optional = true, features = [
+    "optimism",
+] }
 reth-node-core.workspace = true
 reth-ethereum-payload-builder.workspace = true
 reth-db-common.workspace = true
@@ -64,9 +67,11 @@ reth-node-builder.workspace = true
 reth-node-events.workspace = true
 reth-node-metrics.workspace = true
 reth-consensus.workspace = true
+reth-optimism-primitives.workspace = true
 reth-engine-util.workspace = true
 reth-prune.workspace = true
 reth-stages-api.workspace = true
+reth-optimism-cli = { workspace = true, optional = true }
 
 # crypto
 alloy-rlp.workspace = true
@@ -106,7 +111,7 @@ itertools.workspace = true
 discv5.workspace = true
 
 [target.'cfg(unix)'.dependencies]
-tikv-jemallocator = { workspace = true, optional = true }
+tikv-jemallocator = { version = "0.5.0", optional = true }
 libc = "0.2"
 
 [dev-dependencies]
@@ -128,6 +133,21 @@ min-info-logs = ["tracing/release_max_level_info"]
 min-debug-logs = ["tracing/release_max_level_debug"]
 min-trace-logs = ["tracing/release_max_level_trace"]
 
+optimism = [
+    "dep:reth-node-optimism",
+    "dep:reth-optimism-cli",
+    "reth-beacon-consensus/optimism",
+    "reth-blockchain-tree/optimism",
+    "reth-node-core/optimism",
+    "reth-optimism-cli?/optimism",
+    "reth-primitives/optimism",
+    "reth-provider/optimism",
+    "reth-rpc/optimism",
+]
+
+# no-op feature flag for switching between the `optimism` and default functionality in CI matrices
+ethereum = []
+
 [[bin]]
 name = "reth"
 path = "src/main.rs"
@@ -135,3 +155,8 @@ path = "src/main.rs"
 [[bin]]
 name = "engine2"
 path = "src/engine2.rs"
+
+[[bin]]
+name = "op-reth"
+path = "src/optimism.rs"
+required-features = ["optimism"]

bin/reth/src/cli/mod.rs

@@ -6,6 +6,7 @@ use crate::{
         LogArgs,
     },
     commands::debug_cmd,
+    macros::block_executor,
     version::{LONG_VERSION, SHORT_VERSION},
 };
 use clap::{value_parser, Parser, Subcommand};
@@ -18,7 +19,6 @@ use reth_cli_commands::{
 use reth_cli_runner::CliRunner;
 use reth_db::DatabaseEnv;
 use reth_node_builder::{NodeBuilder, WithLaunchContext};
-use reth_node_ethereum::EthExecutorProvider;
 use reth_tracing::FileWorkerGuard;
 use std::{ffi::OsString, fmt, future::Future, sync::Arc};
 use tracing::info;
@@ -151,13 +151,20 @@ impl<Ext: clap::Args + fmt::Debug> Cli<Ext> {
             }
             Commands::Init(command) => runner.run_blocking_until_ctrl_c(command.execute()),
             Commands::InitState(command) => runner.run_blocking_until_ctrl_c(command.execute()),
-            Commands::Import(command) => {
-                runner.run_blocking_until_ctrl_c(command.execute(EthExecutorProvider::ethereum))
+            Commands::Import(command) => runner.run_blocking_until_ctrl_c(
+                command.execute(|chain_spec| block_executor!(chain_spec)),
+            ),
+            #[cfg(feature = "optimism")]
+            Commands::ImportOp(command) => runner.run_blocking_until_ctrl_c(command.execute()),
+            #[cfg(feature = "optimism")]
+            Commands::ImportReceiptsOp(command) => {
+                runner.run_blocking_until_ctrl_c(command.execute())
             }
             Commands::DumpGenesis(command) => runner.run_blocking_until_ctrl_c(command.execute()),
             Commands::Db(command) => runner.run_blocking_until_ctrl_c(command.execute()),
-            Commands::Stage(command) => runner
-                .run_command_until_exit(|ctx| command.execute(ctx, EthExecutorProvider::ethereum)),
+            Commands::Stage(command) => runner.run_command_until_exit(|ctx| {
+                command.execute(ctx, |chain_spec| block_executor!(chain_spec))
+            }),
             Commands::P2P(command) => runner.run_until_ctrl_c(command.execute()),
             #[cfg(feature = "dev")]
             Commands::TestVectors(command) => runner.run_until_ctrl_c(command.execute()),
@@ -193,6 +200,14 @@ pub enum Commands<Ext: clap::Args + fmt::Debug = NoArgs> {
     /// This syncs RLP encoded blocks from a file.
     #[command(name = "import")]
     Import(import::ImportCommand),
+    /// This syncs RLP encoded OP blocks below Bedrock from a file, without executing.
+    #[cfg(feature = "optimism")]
+    #[command(name = "import-op")]
+    ImportOp(reth_optimism_cli::ImportOpCommand),
+    /// This imports RLP encoded receipts from a file.
+    #[cfg(feature = "optimism")]
+    #[command(name = "import-receipts-op")]
+    ImportReceiptsOp(reth_optimism_cli::ImportReceiptsOpCommand),
     /// Dumps genesis block JSON configuration to stdout.
     DumpGenesis(dump_genesis::DumpGenesisCommand),
     /// Database debugging utilities

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

@@ -1,4 +1,5 @@
 //! Command for debugging block building.
+use crate::macros::block_executor;
 use alloy_rlp::Decodable;
 use clap::Parser;
 use eyre::Context;
@@ -18,7 +19,6 @@ use reth_evm::execute::{BlockExecutionOutput, BlockExecutorProvider, Executor};
 use reth_execution_types::ExecutionOutcome;
 use reth_fs_util as fs;
 use reth_node_api::PayloadBuilderAttributes;
-use reth_node_ethereum::EthExecutorProvider;
 use reth_payload_builder::database::CachedReads;
 use reth_primitives::{
     constants::eip4844::LoadKzgSettingsError, revm_primitives::KzgSettings, Address,
@@ -120,7 +120,7 @@ impl Command {
         let consensus: Arc<dyn Consensus> =
             Arc::new(EthBeaconConsensus::new(provider_factory.chain_spec()));
 
-        let executor = EthExecutorProvider::ethereum(provider_factory.chain_spec());
+        let executor = block_executor!(provider_factory.chain_spec());
 
         // configure blockchain tree
         let tree_externals =
@@ -221,6 +221,17 @@ impl Command {
         let payload_config = PayloadConfig::new(
             Arc::clone(&best_block),
             Bytes::default(),
+            #[cfg(feature = "optimism")]
+            reth_node_optimism::OptimismPayloadBuilderAttributes::try_new(
+                best_block.hash(),
+                reth_rpc_types::engine::OptimismPayloadAttributes {
+                    payload_attributes: payload_attrs,
+                    transactions: None,
+                    no_tx_pool: None,
+                    gas_limit: None,
+                },
+            )?,
+            #[cfg(not(feature = "optimism"))]
             reth_payload_builder::EthPayloadBuilderAttributes::try_new(
                 best_block.hash(),
                 payload_attrs,
@@ -237,6 +248,13 @@ impl Command {
             None,
         );
 
+        #[cfg(feature = "optimism")]
+        let payload_builder = reth_node_optimism::OptimismPayloadBuilder::new(
+            reth_node_optimism::OptimismEvmConfig::default(),
+        )
+        .compute_pending_block();
+
+        #[cfg(not(feature = "optimism"))]
         let payload_builder = reth_ethereum_payload_builder::EthereumPayloadBuilder::default();
 
         match payload_builder.try_build(args)? {
@@ -253,8 +271,7 @@ impl Command {
                     SealedBlockWithSenders::new(block.clone(), senders).unwrap();
 
                 let db = StateProviderDatabase::new(blockchain_db.latest()?);
-                let executor =
-                    EthExecutorProvider::ethereum(provider_factory.chain_spec()).executor(db);
+                let executor = block_executor!(provider_factory.chain_spec()).executor(db);
 
                 let BlockExecutionOutput { state, receipts, requests, .. } =
                     executor.execute((&block_with_senders.clone().unseal(), U256::MAX).into())?;

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

@@ -1,6 +1,6 @@
 //! Command for debugging execution.
 
-use crate::{args::NetworkArgs, utils::get_single_header};
+use crate::{args::NetworkArgs, macros::block_executor, utils::get_single_header};
 use clap::Parser;
 use futures::{stream::select as stream_select, StreamExt};
 use reth_beacon_consensus::EthBeaconConsensus;
@@ -19,7 +19,6 @@ use reth_exex::ExExManagerHandle;
 use reth_network::{NetworkEvents, NetworkHandle};
 use reth_network_api::NetworkInfo;
 use reth_network_p2p::{bodies::client::BodiesClient, headers::client::HeadersClient};
-use reth_node_ethereum::EthExecutorProvider;
 use reth_primitives::{BlockHashOrNumber, BlockNumber, B256};
 use reth_provider::{
     BlockExecutionWriter, ChainSpecProvider, ProviderFactory, StageCheckpointReader,
@@ -81,7 +80,7 @@ impl Command {
         let prune_modes = config.prune.clone().map(|prune| prune.segments).unwrap_or_default();
 
         let (tip_tx, tip_rx) = watch::channel(B256::ZERO);
-        let executor = EthExecutorProvider::ethereum(provider_factory.chain_spec());
+        let executor = block_executor!(provider_factory.chain_spec());
 
         let pipeline = Pipeline::builder()
             .with_tip_sender(tip_tx)

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

@@ -2,6 +2,7 @@
 
 use crate::{
     args::NetworkArgs,
+    macros::block_executor,
     utils::{get_single_body, get_single_header},
 };
 use backon::{ConstantBuilder, Retryable};
@@ -16,7 +17,6 @@ use reth_evm::execute::{BlockExecutionOutput, BlockExecutorProvider, Executor};
 use reth_execution_types::ExecutionOutcome;
 use reth_network::NetworkHandle;
 use reth_network_api::NetworkInfo;
-use reth_node_ethereum::EthExecutorProvider;
 use reth_primitives::BlockHashOrNumber;
 use reth_provider::{
     writer::StorageWriter, AccountExtReader, ChainSpecProvider, HashingWriter, HeaderProvider,
@@ -130,7 +130,7 @@ impl Command {
             provider_factory.static_file_provider(),
         ));
 
-        let executor = EthExecutorProvider::ethereum(provider_factory.chain_spec()).executor(db);
+        let executor = block_executor!(provider_factory.chain_spec()).executor(db);
 
         let merkle_block_td =
             provider.header_td_by_number(merkle_block_number)?.unwrap_or_default();

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

@@ -1,5 +1,5 @@
 //! Command for debugging merkle trie calculation.
-use crate::{args::NetworkArgs, utils::get_single_header};
+use crate::{args::NetworkArgs, macros::block_executor, utils::get_single_header};
 use backon::{ConstantBuilder, Retryable};
 use clap::Parser;
 use reth_beacon_consensus::EthBeaconConsensus;
@@ -14,7 +14,6 @@ use reth_evm::execute::{BatchExecutor, BlockExecutorProvider};
 use reth_network::NetworkHandle;
 use reth_network_api::NetworkInfo;
 use reth_network_p2p::full_block::FullBlockClient;
-use reth_node_ethereum::EthExecutorProvider;
 use reth_primitives::BlockHashOrNumber;
 use reth_provider::{
     writer::StorageWriter, BlockNumReader, BlockWriter, ChainSpecProvider, HeaderProvider,
@@ -92,7 +91,7 @@ impl Command {
             )
             .await?;
 
-        let executor_provider = EthExecutorProvider::ethereum(provider_factory.chain_spec());
+        let executor_provider = block_executor!(provider_factory.chain_spec());
 
         // Initialize the fetch client
         info!(target: "reth::cli", target_block_number=self.to, "Downloading tip of block range");

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

@@ -1,4 +1,4 @@
-use crate::args::NetworkArgs;
+use crate::{args::NetworkArgs, macros::block_executor};
 use clap::Parser;
 use eyre::Context;
 use reth_basic_payload_builder::{BasicPayloadJobGenerator, BasicPayloadJobGeneratorConfig};
@@ -16,7 +16,6 @@ use reth_engine_util::engine_store::{EngineMessageStore, StoredEngineApiMessage}
 use reth_fs_util as fs;
 use reth_network::NetworkHandle;
 use reth_network_api::NetworkInfo;
-use reth_node_ethereum::EthExecutorProvider;
 use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
 use reth_provider::{
     providers::BlockchainProvider, CanonStateSubscriptions, ChainSpecProvider, ProviderFactory,
@@ -79,7 +78,7 @@ impl Command {
         let consensus: Arc<dyn Consensus> =
             Arc::new(EthBeaconConsensus::new(provider_factory.chain_spec()));
 
-        let executor = EthExecutorProvider::ethereum(provider_factory.chain_spec());
+        let executor = block_executor!(provider_factory.chain_spec());
 
         // Configure blockchain tree
         let tree_externals =
@@ -108,8 +107,15 @@ impl Command {
             .await?;
 
         // Set up payload builder
+        #[cfg(not(feature = "optimism"))]
         let payload_builder = reth_ethereum_payload_builder::EthereumPayloadBuilder::default();
 
+        // Optimism's payload builder is implemented on the OptimismPayloadBuilder type.
+        #[cfg(feature = "optimism")]
+        let payload_builder = reth_node_optimism::OptimismPayloadBuilder::new(
+            reth_node_optimism::OptimismEvmConfig::default(),
+        );
+
         let payload_generator = BasicPayloadJobGenerator::with_builder(
             blockchain_db.clone(),
             NoopTransactionPool::default(),
@@ -119,6 +125,13 @@ impl Command {
             payload_builder,
         );
 
+        #[cfg(feature = "optimism")]
+        let (payload_service, payload_builder): (
+            _,
+            PayloadBuilderHandle<reth_node_optimism::OptimismEngineTypes>,
+        ) = PayloadBuilderService::new(payload_generator, blockchain_db.canonical_state_stream());
+
+        #[cfg(not(feature = "optimism"))]
         let (payload_service, payload_builder): (
             _,
             PayloadBuilderHandle<reth_node_ethereum::EthEngineTypes>,

bin/reth/src/engine2.rs

@@ -6,6 +6,7 @@
 #[global_allocator]
 static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
+#[cfg(not(feature = "optimism"))]
 fn main() {
     use reth::cli::Cli;
     use reth_node_ethereum::{launch::EthNodeLauncher, node::EthereumAddOns, EthereumNode};

bin/reth/src/lib.rs

@@ -31,6 +31,7 @@
 
 pub mod cli;
 pub mod commands;
+mod macros;
 
 /// Re-exported utils.
 pub mod utils {

bin/reth/src/macros.rs

@@ -0,0 +1,20 @@
+//! Helper macros
+
+/// Creates the block executor type based on the configured feature.
+///
+/// Note(mattsse): This is incredibly horrible and will be replaced
+#[cfg(not(feature = "optimism"))]
+macro_rules! block_executor {
+    ($chain_spec:expr) => {
+        reth_node_ethereum::EthExecutorProvider::ethereum($chain_spec)
+    };
+}
+
+#[cfg(feature = "optimism")]
+macro_rules! block_executor {
+    ($chain_spec:expr) => {
+        reth_node_optimism::OpExecutorProvider::optimism($chain_spec)
+    };
+}
+
+pub(crate) use block_executor;

bin/reth/src/main.rs

@@ -5,6 +5,10 @@
 #[global_allocator]
 static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
+#[cfg(all(feature = "optimism", not(test)))]
+compile_error!("Cannot build the `reth` binary with the `optimism` feature flag enabled. Did you mean to build `op-reth`?");
+
+#[cfg(not(feature = "optimism"))]
 fn main() {
     use reth::cli::Cli;
     use reth_node_ethereum::EthereumNode;

bin/reth/src/optimism.rs

@@ -0,0 +1,46 @@
+#![allow(missing_docs, rustdoc::missing_crate_level_docs)]
+
+use clap::Parser;
+use reth::cli::Cli;
+use reth_node_optimism::{args::RollupArgs, rpc::SequencerClient, OptimismNode};
+use std::sync::Arc;
+
+// We use jemalloc for performance reasons
+#[cfg(all(feature = "jemalloc", unix))]
+#[global_allocator]
+static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+#[cfg(not(feature = "optimism"))]
+compile_error!("Cannot build the `op-reth` binary with the `optimism` feature flag disabled. Did you mean to build `reth`?");
+
+#[cfg(feature = "optimism")]
+fn main() {
+    reth_cli_util::sigsegv_handler::install();
+
+    // Enable backtraces unless a RUST_BACKTRACE value has already been explicitly provided.
+    if std::env::var_os("RUST_BACKTRACE").is_none() {
+        std::env::set_var("RUST_BACKTRACE", "1");
+    }
+
+    if let Err(err) = Cli::<RollupArgs>::parse().run(|builder, rollup_args| async move {
+        let handle = builder
+            .node(OptimismNode::new(rollup_args.clone()))
+            .extend_rpc_modules(move |ctx| {
+                // register sequencer tx forwarder
+                if let Some(sequencer_http) = rollup_args.sequencer_http {
+                    ctx.registry.set_eth_raw_transaction_forwarder(Arc::new(SequencerClient::new(
+                        sequencer_http,
+                    )));
+                }
+
+                Ok(())
+            })
+            .launch()
+            .await?;
+
+        handle.node_exit_future.await
+    }) {
+        eprintln!("Error: {err:?}");
+        std::process::exit(1);
+    }
+}