refactor: Enable library usage of rollup-boost

* unify client configuration with ClientArgs struct
* Consolidate BuilderArgs/L2ClientArgs into unified ClientArgs pattern
* Move JWT handling into ClientArgs with helper methods
* Update ProxyLayer to accept HttpClient instances instead of raw config
* Add RollupBoostServer::new_from_args for cleaner initialization
* Bump reth-rpc-layer to v1.8.2

Author: teddyknox

Cargo.lock

@@ -25,7 +25,7 @@ url = "2.2.0"
 sha2 = { version = "0.10", default-features = false }
 
 # Reth deps
-reth-optimism-payload-builder = { git = "https://github.com/paradigmxyz/reth", tag = "v1.8.1" }
+reth-optimism-payload-builder = { git = "https://github.com/paradigmxyz/reth", tag = "v1.8.2" }
 
 # Alloy libraries
 alloy-rpc-types-engine = "1.0.35"
@@ -39,6 +39,7 @@ alloy-rpc-types = "1.0.35"
 alloy-genesis = "1.0.35"
 alloy-rpc-client = "1.0.35"
 alloy-provider = "1.0.35"
+alloy-op-evm = "0.21.0"
 op-alloy-network = "0.20.0"
 op-alloy-rpc-types-engine = "0.20.0"
 op-alloy-consensus = "0.20.0"

Cargo.toml

@@ -1,25 +1,19 @@
-use alloy_rpc_types_engine::JwtSecret;
+use crate::server::IntoRpcModule;
 use clap::Parser;
-use eyre::bail;
-use jsonrpsee::{RpcModule, server::Server};
-use parking_lot::Mutex;
-use std::{
-    net::{IpAddr, SocketAddr},
-    path::PathBuf,
-    str::FromStr,
-    sync::Arc,
-};
+use jsonrpsee::server::Server;
+use std::{net::SocketAddr, path::PathBuf, sync::Arc};
 use tokio::signal::unix::{SignalKind, signal as unix_signal};
 use tracing::{Level, info};
 
 use crate::{
-    BlockSelectionPolicy, Flashblocks, FlashblocksArgs, ProxyLayer, RollupBoostServer, RpcClient,
+    BlockSelectionPolicy, ClientArgs, DebugServer, FlashblocksArgs, PayloadSource, ProxyLayer,
+    RollupBoostServer,
     client::rpc::{BuilderArgs, L2ClientArgs},
     debug_api::ExecutionMode,
     get_version, init_metrics,
-    payload::PayloadSource,
     probe::ProbeLayer,
 };
+use crate::{FlashblocksService, RpcClient};
 
 #[derive(Clone, Parser, Debug)]
 #[clap(author, version = get_version(), about)]
@@ -112,90 +106,36 @@ impl RollupBoostArgs {
         init_metrics(&self)?;
 
         let debug_addr = format!("{}:{}", self.debug_host, self.debug_server_port);
-        let l2_client_args = self.l2_client;
-
-        let l2_auth_jwt = if let Some(secret) = l2_client_args.l2_jwt_token {
-            secret
-        } else if let Some(path) = l2_client_args.l2_jwt_path.as_ref() {
-            JwtSecret::from_file(path)?
-        } else {
-            bail!("Missing L2 Client JWT secret");
-        };
+        let l2_client_args: ClientArgs = self.l2_client.clone().into();
+        let l2_http_client = l2_client_args.new_http_client(PayloadSource::L2)?;
 
-        let l2_client = RpcClient::new(
-            l2_client_args.l2_url.clone(),
-            l2_auth_jwt,
-            l2_client_args.l2_timeout,
-            PayloadSource::L2,
-        )?;
-
-        let builder_args = self.builder;
-        let builder_auth_jwt = if let Some(secret) = builder_args.builder_jwt_token {
-            secret
-        } else if let Some(path) = builder_args.builder_jwt_path.as_ref() {
-            JwtSecret::from_file(path)?
-        } else {
-            bail!("Missing Builder JWT secret");
-        };
-
-        let builder_client = RpcClient::new(
-            builder_args.builder_url.clone(),
-            builder_auth_jwt,
-            builder_args.builder_timeout,
-            PayloadSource::Builder,
-        )?;
+        let builder_client_args: ClientArgs = self.builder.clone().into();
+        let builder_http_client = builder_client_args.new_http_client(PayloadSource::Builder)?;
 
         let (probe_layer, probes) = ProbeLayer::new();
-        let execution_mode = Arc::new(Mutex::new(self.execution_mode));
-
-        let (rpc_module, health_handle): (RpcModule<()>, _) = if self.flashblocks.flashblocks {
-            let flashblocks_args = self.flashblocks;
-            let inbound_url = flashblocks_args.flashblocks_builder_url;
-            let outbound_addr = SocketAddr::new(
-                IpAddr::from_str(&flashblocks_args.flashblocks_host)?,
-                flashblocks_args.flashblocks_port,
-            );
-
-            let builder_client = Arc::new(Flashblocks::run(
-                builder_client.clone(),
-                inbound_url,
-                outbound_addr,
-                flashblocks_args.flashblock_builder_ws_reconnect_ms,
-            )?);
-
-            let rollup_boost = RollupBoostServer::new(
-                l2_client,
-                builder_client,
-                execution_mode.clone(),
-                self.block_selection_policy,
-                probes.clone(),
-                self.external_state_root,
-                self.ignore_unhealthy_builders,
-            );
 
+        let (health_handle, rpc_module) = if self.flashblocks.flashblocks {
+            let server = RollupBoostServer::<FlashblocksService>::new_from_args(
+                self.clone(),
+                probes.clone(),
+            )?;
+            let rollup_boost = Arc::new(server);
             let health_handle = rollup_boost
                 .spawn_health_check(self.health_check_interval, self.max_unsafe_interval);
-
-            // Spawn the debug server
-            rollup_boost.start_debug_server(debug_addr.as_str()).await?;
-            (rollup_boost.try_into()?, health_handle)
+            let debug_server = DebugServer::new(rollup_boost.clone());
+            debug_server.run(&debug_addr).await?;
+            let rpc_module = rollup_boost.into_rpc_module()?;
+            (health_handle, rpc_module)
         } else {
-            let rollup_boost = RollupBoostServer::new(
-                l2_client,
-                Arc::new(builder_client),
-                execution_mode.clone(),
-                self.block_selection_policy,
-                probes.clone(),
-                self.external_state_root,
-                self.ignore_unhealthy_builders,
-            );
-
+            let server =
+                RollupBoostServer::<RpcClient>::new_from_args(self.clone(), probes.clone())?;
+            let rollup_boost = Arc::new(server);
             let health_handle = rollup_boost
                 .spawn_health_check(self.health_check_interval, self.max_unsafe_interval);
-
-            // Spawn the debug server
-            rollup_boost.start_debug_server(debug_addr.as_str()).await?;
-            (rollup_boost.try_into()?, health_handle)
+            let debug_server = DebugServer::new(rollup_boost.clone());
+            debug_server.run(&debug_addr).await?;
+            let rpc_module = rollup_boost.into_rpc_module()?;
+            (health_handle, rpc_module)
         };
 
         // Build and start the server
@@ -205,12 +145,8 @@ impl RollupBoostArgs {
             tower::ServiceBuilder::new()
                 .layer(probe_layer)
                 .layer(ProxyLayer::new(
-                    l2_client_args.l2_url,
-                    l2_auth_jwt,
-                    l2_client_args.l2_timeout,
-                    builder_args.builder_url,
-                    builder_auth_jwt,
-                    builder_args.builder_timeout,
+                    l2_http_client.clone(),
+                    builder_http_client.clone(),
                 ));
 
         let server = Server::builder()
@@ -247,6 +183,12 @@ impl RollupBoostArgs {
     }
 }
 
+impl Default for RollupBoostArgs {
+    fn default() -> Self {
+        Self::parse_from::<_, &str>(std::iter::empty())
+    }
+}
+
 #[derive(Clone, Debug)]
 pub enum LogFormat {
     Json,

crates/rollup-boost/src/cli.rs

@@ -1,5 +1,6 @@
 use crate::EngineApiExt;
 use crate::client::auth::AuthLayer;
+use crate::client::http::HttpClient as RollupBoostHttpClient;
 use crate::payload::{NewPayload, OpExecutionPayloadEnvelope, PayloadSource, PayloadVersion};
 use crate::server::EngineApiClient;
 use crate::version::{CARGO_PKG_VERSION, VERGEN_GIT_SHA};
@@ -10,6 +11,7 @@ use alloy_rpc_types_engine::{
 };
 use alloy_rpc_types_eth::{Block, BlockNumberOrTag};
 use clap::{Parser, arg};
+use eyre::bail;
 use http::{HeaderMap, Uri};
 use jsonrpsee::core::async_trait;
 use jsonrpsee::core::middleware::layer::RpcLogger;
@@ -101,7 +103,7 @@ impl From<RpcClientError> for ErrorObjectOwned {
 ///
 /// - **Engine API** calls are faciliated via the `auth_client` (requires JWT authentication).
 ///
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct RpcClient {
     /// Handles requests to the authenticated Engine API (requires JWT authentication)
     auth_client: RpcClientService,
@@ -376,8 +378,68 @@ impl EngineApiExt for RpcClient {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct ClientArgs {
+    /// Auth server address
+    pub url: Uri,
+
+    /// Hex encoded JWT secret to use for the authenticated engine-API RPC server.
+    pub jwt_token: Option<JwtSecret>,
+
+    /// Path to a JWT secret to use for the authenticated engine-API RPC server.
+    pub jwt_path: Option<PathBuf>,
+
+    /// Timeout for http calls in milliseconds
+    pub timeout: u64,
+}
+
+impl ClientArgs {
+    fn get_auth_jwt(&self) -> eyre::Result<JwtSecret> {
+        if let Some(secret) = self.jwt_token {
+            Ok(secret)
+        } else if let Some(path) = self.jwt_path.as_ref() {
+            Ok(JwtSecret::from_file(path)?)
+        } else {
+            bail!("Missing Client JWT secret");
+        }
+    }
+
+    pub fn new_rpc_client(&self, payload_source: PayloadSource) -> eyre::Result<RpcClient> {
+        RpcClient::new(
+            self.url.clone(),
+            self.get_auth_jwt()?,
+            self.timeout,
+            payload_source,
+        )
+        .map_err(eyre::Report::from)
+    }
+
+    pub fn new_http_client(
+        &self,
+        payload_source: PayloadSource,
+    ) -> eyre::Result<RollupBoostHttpClient> {
+        Ok(RollupBoostHttpClient::new(
+            self.url.clone(),
+            self.get_auth_jwt()?,
+            payload_source,
+            self.timeout,
+        ))
+    }
+}
+
+impl Default for ClientArgs {
+    fn default() -> Self {
+        Self {
+            url: "127.0.0.1:8551".parse::<Uri>().unwrap(),
+            jwt_token: None,
+            jwt_path: None,
+            timeout: 1000,
+        }
+    }
+}
+
 /// Generates Clap argument structs with a prefix to create a unique namespace when specifying RPC client config via the CLI.
-macro_rules! define_rpc_args {
+macro_rules! define_client_args {
     ($(($name:ident, $prefix:ident)),*) => {
         $(
             paste! {
@@ -399,12 +461,30 @@ macro_rules! define_rpc_args {
                     #[arg(long, env, default_value_t = 1000)]
                     pub [<$prefix _timeout>]: u64,
                 }
+
+
+                impl From<$name> for ClientArgs {
+                    fn from(args: $name) -> Self {
+                        ClientArgs {
+                            url: args.[<$prefix _url>].clone(),
+                            jwt_token: args.[<$prefix _jwt_token>].clone(),
+                            jwt_path: args.[<$prefix _jwt_path>],
+                            timeout: args.[<$prefix _timeout>],
+                        }
+                    }
+                }
+
+                impl Default for $name {
+                    fn default() -> Self {
+                        Self::parse_from::<_, &str>(std::iter::empty())
+                    }
+                }
             }
         )*
     };
 }
 
-define_rpc_args!((BuilderArgs, builder), (L2ClientArgs, l2));
+define_client_args!((BuilderArgs, builder), (L2ClientArgs, l2));
 
 #[cfg(test)]
 pub mod tests {