feat: integrate engine2 for optimism (#10222)

bin/reth/src/optimism.rs

@@ -2,7 +2,11 @@
 
 use clap::Parser;
 use reth::cli::Cli;
-use reth_node_optimism::{args::RollupArgs, rpc::SequencerClient, OptimismNode};
+use reth_node_builder::EngineNodeLauncher;
+use reth_node_optimism::{
+    args::RollupArgs, node::OptimismAddOns, rpc::SequencerClient, OptimismNode,
+};
+use reth_provider::providers::BlockchainProvider2;
 use std::sync::Arc;
 
 // We use jemalloc for performance reasons
@@ -23,22 +27,54 @@ fn main() {
     }
 
     if let Err(err) = Cli::<RollupArgs>::parse().run(|builder, rollup_args| async move {
-        let handle = builder
+        let enable_engine2 = rollup_args.experimental;
-            .node(OptimismNode::new(rollup_args.clone()))
+        let sequencer_http_arg = rollup_args.sequencer_http.clone();
-            .extend_rpc_modules(move |ctx| {
+        match enable_engine2 {
-                // register sequencer tx forwarder
+            true => {
-                if let Some(sequencer_http) = rollup_args.sequencer_http {
+                let handle = builder
-                    ctx.registry.set_eth_raw_transaction_forwarder(Arc::new(SequencerClient::new(
+                    .with_types_and_provider::<OptimismNode, BlockchainProvider2<_>>()
-                        sequencer_http,
+                    .with_components(OptimismNode::components(rollup_args))
-                    )));
+                    .with_add_ons::<OptimismAddOns>()
-                }
+                    .extend_rpc_modules(move |ctx| {
+                        // register sequencer tx forwarder
+                        if let Some(sequencer_http) = sequencer_http_arg {
+                            ctx.registry.set_eth_raw_transaction_forwarder(Arc::new(
+                                SequencerClient::new(sequencer_http),
+                            ));
+                        }
 
-                Ok(())
+                        Ok(())
-            })
+                    })
-            .launch()
+                    .launch_with_fn(|builder| {
-            .await?;
+                        let launcher = EngineNodeLauncher::new(
+                            builder.task_executor().clone(),
+                            builder.config().datadir(),
+                        );
+                        builder.launch_with(launcher)
+                    })
+                    .await?;
 
-        handle.node_exit_future.await
+                handle.node_exit_future.await
+            }
+            false => {
+                let handle = builder
+                    .node(OptimismNode::new(rollup_args.clone()))
+                    .extend_rpc_modules(move |ctx| {
+                        // register sequencer tx forwarder
+                        if let Some(sequencer_http) = sequencer_http_arg {
+                            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);

crates/optimism/node/src/args.rs

@@ -33,6 +33,10 @@ pub struct RollupArgs {
     /// enables discovery v4 if provided
     #[arg(long = "rollup.discovery.v4", default_value = "false")]
     pub discovery_v4: bool,
+
+    /// Enable the engine2 experimental features on op-reth binary
+    #[arg(long = "engine.experimental", default_value = "false")]
+    pub experimental: bool,
 }
 
 #[cfg(test)]