chore: remove op-reth from repository (#21532)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>

bin/reth-bench-compare/Cargo.toml

@@ -98,5 +98,5 @@ min-trace-logs = [
     "reth-node-core/min-trace-logs",
 ]
 
-# no-op feature flag for switching between the `optimism` and default functionality in CI matrices
+# no-op feature flag for CI matrices
 ethereum = []

bin/reth-bench-compare/src/cli.rs

@@ -474,7 +474,6 @@ async fn run_compilation_phase(
     git_manager: &GitManager,
     compilation_manager: &CompilationManager,
     args: &Args,
-    is_optimism: bool,
 ) -> Result<(String, String)> {
     info!("=== Running compilation phase ===");
 
@@ -527,7 +526,7 @@ async fn run_compilation_phase(
         git_manager.switch_ref(git_ref)?;
 
         // Compile reth (with caching)
-        compilation_manager.compile_reth(commit, is_optimism, features, rustflags)?;
+        compilation_manager.compile_reth(commit, features, rustflags)?;
 
         info!("Completed compilation for {} reference", ref_type);
     }
@@ -547,7 +546,6 @@ async fn run_warmup_phase(
     node_manager: &mut NodeManager,
     benchmark_runner: &BenchmarkRunner,
     args: &Args,
-    is_optimism: bool,
     baseline_commit: &str,
     starting_tip: u64,
 ) -> Result<()> {
@@ -565,8 +563,7 @@ async fn run_warmup_phase(
     git_manager.switch_ref(warmup_ref)?;
 
     // Get the cached binary path for baseline (should already be compiled)
-    let binary_path =
-        compilation_manager.get_cached_binary_path_for_commit(baseline_commit, is_optimism);
+    let binary_path = compilation_manager.get_cached_binary_path_for_commit(baseline_commit);
 
     // Verify the cached binary exists
     if !binary_path.exists() {
@@ -619,18 +616,13 @@ async fn run_benchmark_workflow(
     comparison_generator: &mut ComparisonGenerator,
     args: &Args,
 ) -> Result<()> {
-    // Detect if this is an Optimism chain once at the beginning
-    let rpc_url = args.get_rpc_url();
-    let is_optimism = compilation_manager.detect_optimism_chain(&rpc_url).await?;
-
     // Run compilation phase for both binaries
     let (baseline_commit, feature_commit) =
-        run_compilation_phase(git_manager, compilation_manager, args, is_optimism).await?;
+        run_compilation_phase(git_manager, compilation_manager, args).await?;
 
     // Switch to baseline reference and get the starting tip
     git_manager.switch_ref(&args.baseline_ref)?;
-    let binary_path =
-        compilation_manager.get_cached_binary_path_for_commit(&baseline_commit, is_optimism);
+    let binary_path = compilation_manager.get_cached_binary_path_for_commit(&baseline_commit);
     if !binary_path.exists() {
         return Err(eyre!(
             "Cached baseline binary not found at {:?}. Compilation phase should have created it.",
@@ -660,7 +652,6 @@ async fn run_benchmark_workflow(
             node_manager,
             benchmark_runner,
             args,
-            is_optimism,
             &baseline_commit,
             starting_tip,
         )
@@ -686,8 +677,7 @@ async fn run_benchmark_workflow(
         git_manager.switch_ref(git_ref)?;
 
         // Get the cached binary path for this git reference (should already be compiled)
-        let binary_path =
-            compilation_manager.get_cached_binary_path_for_commit(commit, is_optimism);
+        let binary_path = compilation_manager.get_cached_binary_path_for_commit(commit);
 
         // Verify the cached binary exists
         if !binary_path.exists() {

bin/reth-bench-compare/src/compilation.rs

@@ -1,8 +1,6 @@
 //! Compilation operations for reth and reth-bench.
 
 use crate::git::GitManager;
-use alloy_primitives::address;
-use alloy_provider::{Provider, ProviderBuilder};
 use eyre::{eyre, Result, WrapErr};
 use std::{fs, path::PathBuf, process::Command};
 use tracing::{debug, error, info, warn};
@@ -25,54 +23,14 @@ impl CompilationManager {
         Ok(Self { repo_root, output_dir, git_manager })
     }
 
-    /// Detect if the RPC endpoint is an Optimism chain
-    pub(crate) async fn detect_optimism_chain(&self, rpc_url: &str) -> Result<bool> {
-        info!("Detecting chain type from RPC endpoint...");
-
-        // Create Alloy provider
-        let url = rpc_url.parse().map_err(|e| eyre!("Invalid RPC URL '{}': {}", rpc_url, e))?;
-        let provider = ProviderBuilder::new().connect_http(url);
-
-        // Check for Optimism predeploy at address 0x420000000000000000000000000000000000000F
-        let is_optimism = !provider
-            .get_code_at(address!("0x420000000000000000000000000000000000000F"))
-            .await?
-            .is_empty();
-
-        if is_optimism {
-            info!("Detected Optimism chain");
-        } else {
-            info!("Detected Ethereum chain");
-        }
-
-        Ok(is_optimism)
-    }
-
     /// Get the path to the cached binary using explicit commit hash
-    pub(crate) fn get_cached_binary_path_for_commit(
-        &self,
-        commit: &str,
-        is_optimism: bool,
-    ) -> PathBuf {
+    pub(crate) fn get_cached_binary_path_for_commit(&self, commit: &str) -> PathBuf {
         let identifier = &commit[..8]; // Use first 8 chars of commit
-
-        let binary_name = if is_optimism {
-            format!("op-reth_{}", identifier)
-        } else {
-            format!("reth_{}", identifier)
-        };
-
-        self.output_dir.join("bin").join(binary_name)
+        self.output_dir.join("bin").join(format!("reth_{identifier}"))
     }
 
     /// Compile reth using cargo build and cache the binary
-    pub(crate) fn compile_reth(
-        &self,
-        commit: &str,
-        is_optimism: bool,
-        features: &str,
-        rustflags: &str,
-    ) -> Result<()> {
+    pub(crate) fn compile_reth(&self, commit: &str, features: &str, rustflags: &str) -> Result<()> {
         // Validate that current git commit matches the expected commit
         let current_commit = self.git_manager.get_current_commit()?;
         if current_commit != commit {
@@ -83,7 +41,7 @@ impl CompilationManager {
             ));
         }
 
-        let cached_path = self.get_cached_binary_path_for_commit(commit, is_optimism);
+        let cached_path = self.get_cached_binary_path_for_commit(commit);
 
         // Check if cached binary already exists (since path contains commit hash, it's valid)
         if cached_path.exists() {
@@ -93,7 +51,7 @@ impl CompilationManager {
 
         info!("No cached binary found, compiling (commit: {})...", &commit[..8]);
 
-        let binary_name = if is_optimism { "op-reth" } else { "reth" };
+        let binary_name = "reth";
 
         info!(
             "Compiling {} with profiling configuration (commit: {})...",
@@ -107,14 +65,6 @@ impl CompilationManager {
         cmd.arg("--features").arg(features);
         info!("Using features: {features}");
 
-        // Add bin-specific arguments for optimism
-        if is_optimism {
-            cmd.arg("--bin")
-                .arg("op-reth")
-                .arg("--manifest-path")
-                .arg("crates/optimism/bin/Cargo.toml");
-        }
-
         cmd.current_dir(&self.repo_root);
 
         // Set RUSTFLAGS

bin/reth-bench/Cargo.toml

@@ -117,7 +117,7 @@ min-trace-logs = [
     "reth-node-core/min-trace-logs",
 ]
 
-# no-op feature flag for switching between the `optimism` and default functionality in CI matrices
+# no-op feature flag for CI matrices
 ethereum = []
 
 [[bin]]