feat: op-reth

Cargo.toml

@@ -152,4 +152,4 @@ c-kzg = { git = "https://github.com/ethereum/c-kzg-4844" }
 
 ### misc-testing
 proptest = "1.0"
-arbitrary = "1.1"
+arbitrary = "1.1"

bin/reth/Cargo.toml

@@ -96,14 +96,28 @@ jemallocator = { version = "0.5.0", optional = true }
 jemalloc-ctl = { version = "0.5.0", optional = true }
 
 [features]
-default = ["jemalloc"]
+default = ["jemalloc", "ethereum"]
 jemalloc = ["dep:jemallocator", "dep:jemalloc-ctl"]
 jemalloc-prof = ["jemalloc", "jemallocator?/profiling"]
 min-error-logs = ["tracing/release_max_level_error"]
 min-warn-logs = ["tracing/release_max_level_warn"]
 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 = [
+  "reth-primitives/optimism",
+  "reth-revm/optimism",
+  "reth-interfaces/optimism",
+  "reth-rpc/optimism",
+  "reth-rpc-engine-api/optimism",
+  "reth-transaction-pool/optimism",
+  "reth-provider/optimism",
+  "reth-beacon-consensus/optimism",
+  "reth-basic-payload-builder/optimism",
+  "reth-network/optimism",
+  "reth-network-api/optimism"
+]
+ethereum = []
 
 [build-dependencies]
 vergen = { version = "8.0.0", features = ["build", "cargo", "git", "gitcl"] }

bin/reth/src/args/mod.rs

@@ -43,4 +43,10 @@ pub use dev_args::DevArgs;
 mod pruning_args;
 pub use pruning_args::PruningArgs;
 
+/// RollupArgs for configuring the op-reth rollup
+#[cfg(feature = "optimism")]
+mod rollup_args;
+#[cfg(feature = "optimism")]
+pub use rollup_args::RollupArgs;
+
 pub mod utils;

bin/reth/src/args/rollup_args.rs

@@ -0,0 +1,21 @@
+//! clap [Args](clap::Args) for op-reth rollup configuration
+
+/// Parameters for rollup configuration
+#[derive(Debug, clap::Args)]
+#[command(next_help_heading = "Rollup")]
+pub struct RollupArgs {
+    /// HTTP endpoint for the sequencer mempool
+    #[arg(long = "rollup.sequencer-http", value_name = "HTTP_URL")]
+    pub sequencer_http: Option<String>,
+
+    /// Disable transaction pool gossip
+    #[arg(long = "rollup.disable-tx-pool-gossip")]
+    pub disable_txpool_gossip: bool,
+
+    /// By default the pending block equals the latest block
+    /// to save resources and not leak txs from the tx-pool,
+    /// this flag enables computing of the pending block
+    /// from the tx-pool instead.
+    #[arg(long = "rollup.compute-pending-block")]
+    pub compute_pending_block: bool,
+}

bin/reth/src/cli/ext.rs

@@ -76,24 +76,39 @@ pub trait RethNodeCommandConfig: fmt::Debug {
         pool: Pool,
         executor: Tasks,
         chain_spec: Arc<ChainSpec>,
+        #[cfg(feature = "optimism")] compute_pending_block: bool,
     ) -> eyre::Result<PayloadBuilderHandle>
     where
         Conf: PayloadBuilderConfig,
         Provider: StateProviderFactory + BlockReaderIdExt + Clone + Unpin + 'static,
         Pool: TransactionPool + Unpin + 'static,
         Tasks: TaskSpawner + Clone + Unpin + 'static,
     {
+        let payload_job_config = BasicPayloadJobGeneratorConfig::default()
+            .interval(conf.interval())
+            .deadline(conf.deadline())
+            .max_payload_tasks(conf.max_payload_tasks())
+            .extradata(conf.extradata_rlp_bytes())
+            .max_gas_limit(conf.max_gas_limit());
+
+        #[cfg(feature = "optimism")]
+        let payload_job_config = payload_job_config.compute_pending_block(compute_pending_block);
+
+        // The default payload builder is implemented on the unit type.
+        #[cfg(not(feature = "optimism"))]
+        let payload_builder = ();
+
+        // Optimism's payload builder is impelmented on the OptimismPayloadBuilder type.
+        #[cfg(feature = "optimism")]
+        let payload_builder = reth_basic_payload_builder::OptimismPayloadBuilder;
+
         let payload_generator = BasicPayloadJobGenerator::new(
             provider,
             pool,
             executor.clone(),
-            BasicPayloadJobGeneratorConfig::default()
-                .interval(conf.interval())
-                .deadline(conf.deadline())
-                .max_payload_tasks(conf.max_payload_tasks())
-                .extradata(conf.extradata_rlp_bytes())
-                .max_gas_limit(conf.max_gas_limit()),
+            payload_job_config,
             chain_spec,
+            payload_builder,
         );
         let (payload_service, payload_builder) = PayloadBuilderService::new(payload_generator);
 
@@ -198,6 +213,7 @@ impl<T: RethNodeCommandConfig> RethNodeCommandConfig for NoArgs<T> {
         pool: Pool,
         executor: Tasks,
         chain_spec: Arc<ChainSpec>,
+        #[cfg(feature = "optimism")] compute_pending_block: bool,
     ) -> eyre::Result<PayloadBuilderHandle>
     where
         Conf: PayloadBuilderConfig,
@@ -207,7 +223,15 @@ impl<T: RethNodeCommandConfig> RethNodeCommandConfig for NoArgs<T> {
     {
         self.inner_mut()
             .ok_or_else(|| eyre::eyre!("config value must be set"))?
-            .spawn_payload_builder_service(conf, provider, pool, executor, chain_spec)
+            .spawn_payload_builder_service(
+                conf,
+                provider,
+                pool,
+                executor,
+                chain_spec,
+                #[cfg(feature = "optimism")]
+                compute_pending_block,
+            )
     }
 }
 

bin/reth/src/init.rs

@@ -273,6 +273,8 @@ mod tests {
             genesis_hash: None,
             paris_block_and_final_difficulty: None,
             deposit_contract: None,
+            #[cfg(feature = "optimism")]
+            optimism: false,
             ..Default::default()
         });
 

bin/reth/src/node/mod.rs

@@ -156,6 +156,10 @@ pub struct NodeCommand<Ext: RethCliExt = ()> {
     /// Additional cli arguments
     #[clap(flatten)]
     pub ext: Ext::Node,
+
+    #[cfg(feature = "optimism")]
+    #[clap(flatten)]
+    rollup: crate::args::RollupArgs,
 }
 
 impl<Ext: RethCliExt> NodeCommand<Ext> {
@@ -174,6 +178,8 @@ impl<Ext: RethCliExt> NodeCommand<Ext> {
             db,
             dev,
             pruning,
+            #[cfg(feature = "optimism")]
+            rollup,
             ..
         } = self;
         NodeCommand {
@@ -190,13 +196,27 @@ impl<Ext: RethCliExt> NodeCommand<Ext> {
             dev,
             pruning,
             ext,
+            #[cfg(feature = "optimism")]
+            rollup,
         }
     }
 
     /// Execute `node` command
     pub async fn execute(mut self, ctx: CliContext) -> eyre::Result<()> {
         info!(target: "reth::cli", "reth {} starting", SHORT_VERSION);
 
+        #[cfg(not(any(feature = "ethereum", feature = "optimism")))]
+        compile_error!(
+            "Either feature \"optimism\" or \"ethereum\" must be enabled for this crate."
+        );
+
+        // We cannot do this since runs with `--all-features` will error.
+        // See mutually exclusive features discussion here:
+        // https://github.com/rust-lang/cargo/issues/2980
+        //
+        // #[cfg(all(feature = "ethereum", feature = "optimism"))]
+        // compile_error!("Cannot use both \"optimism\" and \"ethereum\" feature flags.");
+
         // Raise the fd limit of the process.
         // Does not do anything on windows.
         raise_fd_limit();
@@ -327,6 +347,8 @@ impl<Ext: RethCliExt> NodeCommand<Ext> {
             transaction_pool.clone(),
             ctx.task_executor.clone(),
             Arc::clone(&self.chain),
+            #[cfg(feature = "optimism")]
+            self.rollup.compute_pending_block,
         )?;
 
         let max_block = if let Some(block) = self.debug.max_block {
@@ -705,7 +727,8 @@ impl<Ext: RethCliExt> NodeCommand<Ext> {
         secret_key: SecretKey,
         default_peers_path: PathBuf,
     ) -> NetworkConfig<ProviderFactory<Arc<DatabaseEnv>>> {
-        self.network
+        let cfg_builder = self
+            .network
             .network_config(config, self.chain.clone(), secret_key, default_peers_path)
             .with_task_executor(Box::new(executor))
             .set_head(head)
@@ -716,8 +739,14 @@ impl<Ext: RethCliExt> NodeCommand<Ext> {
             .discovery_addr(SocketAddr::V4(SocketAddrV4::new(
                 Ipv4Addr::UNSPECIFIED,
                 self.network.discovery.port.unwrap_or(DEFAULT_DISCOVERY_PORT),
-            )))
-            .build(ProviderFactory::new(db, self.chain.clone()))
+            )));
+
+        #[cfg(feature = "optimism")]
+        let cfg_builder = cfg_builder
+            .sequencer_endpoint(self.rollup.sequencer_http.clone())
+            .disable_tx_gossip(self.rollup.disable_txpool_gossip);
+
+        cfg_builder.build(ProviderFactory::new(db, self.chain.clone()))
     }
 
     #[allow(clippy::too_many_arguments)]

crates/consensus/beacon/Cargo.toml

@@ -44,3 +44,12 @@ reth-revm = { path = "../../revm" }
 reth-downloaders = { path = "../../net/downloaders" }
 
 assert_matches = "1.5"
+
+[features]
+optimism = [
+  "reth-consensus-common/optimism",
+  "reth-primitives/optimism",
+  "reth-interfaces/optimism",
+  "reth-provider/optimism",
+  "reth-rpc-types/optimism",
+]

crates/consensus/beacon/src/engine/mod.rs

@@ -1014,27 +1014,30 @@ where
         //    forkchoiceState.headBlockHash and identified via buildProcessId value if
         //    payloadAttributes is not null and the forkchoice state has been updated successfully.
         //    The build process is specified in the Payload building section.
-        let attributes = PayloadBuilderAttributes::new(state.head_block_hash, attrs);
-
-        // send the payload to the builder and return the receiver for the pending payload id,
-        // initiating payload job is handled asynchronously
-        let pending_payload_id = self.payload_builder.send_new_payload(attributes);
-
-        // Client software MUST respond to this method call in the following way:
-        // {
-        //      payloadStatus: {
-        //          status: VALID,
-        //          latestValidHash: forkchoiceState.headBlockHash,
-        //          validationError: null
-        //      },
-        //      payloadId: buildProcessId
-        // }
-        //
-        // if the payload is deemed VALID and the build process has begun.
-        OnForkChoiceUpdated::updated_with_pending_payload_id(
-            PayloadStatus::new(PayloadStatusEnum::Valid, Some(state.head_block_hash)),
-            pending_payload_id,
-        )
+        match PayloadBuilderAttributes::try_new(state.head_block_hash, attrs) {
+            Ok(attributes) => {
+                // send the payload to the builder and return the receiver for the pending payload
+                // id, initiating payload job is handled asynchronously
+                let pending_payload_id = self.payload_builder.send_new_payload(attributes);
+
+                // Client software MUST respond to this method call in the following way:
+                // {
+                //      payloadStatus: {
+                //          status: VALID,
+                //          latestValidHash: forkchoiceState.headBlockHash,
+                //          validationError: null
+                //      },
+                //      payloadId: buildProcessId
+                // }
+                //
+                // if the payload is deemed VALID and the build process has begun.
+                OnForkChoiceUpdated::updated_with_pending_payload_id(
+                    PayloadStatus::new(PayloadStatusEnum::Valid, Some(state.head_block_hash)),
+                    pending_payload_id,
+                )
+            }
+            Err(_) => OnForkChoiceUpdated::invalid_payload_attributes(),
+        }
     }
 
     /// When the Consensus layer receives a new block via the consensus gossip protocol,

crates/consensus/common/Cargo.toml

@@ -18,3 +18,6 @@ reth-interfaces = { workspace = true, features = ["test-utils"] }
 reth-provider = { workspace = true, features = ["test-utils"] }
 assert_matches = "1.5.0"
 mockall = "0.11.3"
+
+[features]
+optimism = ["reth-primitives/optimism"]