feat: enable external EngineApi access

Cargo.toml

@@ -147,6 +147,7 @@ members = [
     "examples/custom-rlpx-subprotocol",
     "examples/custom-node",
     "examples/db-access",
+    "examples/engine-api-access",
     "examples/exex-hello-world",
     "examples/exex-subscription",
     "examples/exex-test",

crates/node/builder/src/engine_api_ext.rs

@@ -0,0 +1,45 @@
+//! `EngineApiBuilder` callback wrapper
+//!
+//! Wraps an `EngineApiBuilder` to provide access to the built Engine API instance.
+
+use crate::rpc::EngineApiBuilder;
+use eyre::Result;
+use reth_node_api::{AddOnsContext, FullNodeComponents};
+use reth_rpc_api::IntoEngineApiRpcModule;
+
+/// Provides access to an `EngineApi` instance with a callback
+#[derive(Debug)]
+pub struct EngineApiExt<B, F> {
+    /// The inner builder that constructs the actual `EngineApi`
+    inner: B,
+    /// Optional callback function to execute with the built API
+    callback: Option<F>,
+}
+
+impl<B, F> EngineApiExt<B, F> {
+    /// Creates a new wrapper that calls `callback` when the API is built.
+    pub const fn new(inner: B, callback: F) -> Self {
+        Self { inner, callback: Some(callback) }
+    }
+}
+
+impl<N, B, F> EngineApiBuilder<N> for EngineApiExt<B, F>
+where
+    B: EngineApiBuilder<N>,
+    N: FullNodeComponents,
+    B::EngineApi: IntoEngineApiRpcModule + Send + Sync + Clone + 'static,
+    F: FnOnce(B::EngineApi) + Send + Sync + 'static,
+{
+    type EngineApi = B::EngineApi;
+
+    /// Builds the `EngineApi` and executes the callback if present.
+    async fn build_engine_api(mut self, ctx: &AddOnsContext<'_, N>) -> Result<Self::EngineApi> {
+        let api = self.inner.build_engine_api(ctx).await?;
+
+        if let Some(callback) = self.callback.take() {
+            callback(api.clone());
+        }
+
+        Ok(api)
+    }
+}

crates/node/builder/src/lib.rs

@@ -18,6 +18,10 @@ pub mod hooks;
 pub mod node;
 pub use node::*;
 
+/// Support for accessing the EngineApi outside the RPC server context.
+mod engine_api_ext;
+pub use engine_api_ext::EngineApiExt;
+
 /// Support for configuring the components of a node.
 pub mod components;
 pub use components::{NodeComponents, NodeComponentsBuilder};

crates/optimism/node/src/rpc.rs

@@ -14,7 +14,7 @@ use reth_payload_builder::PayloadStore;
 use reth_rpc_engine_api::{EngineApi, EngineCapabilities};
 
 /// Builder for basic [`OpEngineApi`] implementation.
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct OpEngineApiBuilder<EV> {
     engine_validator_builder: EV,
 }

examples/engine-api-access/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "example-engine-api-access"
+version = "0.0.0"
+publish = false
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+# reth
+reth-db = { workspace = true, features = ["op", "test-utils"] }
+reth-node-builder.workspace = true
+reth-optimism-consensus.workspace = true
+reth-tasks.workspace = true
+reth-node-api.workspace = true
+reth-rpc-api.workspace = true
+reth-tracing.workspace = true
+reth-provider.workspace = true
+reth-optimism-node.workspace = true
+reth-optimism-chainspec.workspace = true
+
+# alloy
+alloy-rpc-types-engine.workspace = true
+
+async-trait.workspace = true
+clap = { workspace = true, features = ["derive"] }
+eyre.workspace = true
+jsonrpsee.workspace = true
+futures.workspace = true
+serde_json.workspace = true
+tokio = { workspace = true, features = ["sync"] }

examples/engine-api-access/src/main.rs

@@ -0,0 +1,49 @@
+//! Example demonstrating how to access the Engine API instance during construction.
+//!
+//! Run with
+//!
+//! ```sh
+//! cargo run -p engine-api-access
+//! ```
+
+use reth_db::test_utils::create_test_rw_db;
+use reth_node_builder::{EngineApiExt, FullNodeComponents, NodeBuilder, NodeConfig};
+use reth_optimism_chainspec::BASE_MAINNET;
+use reth_optimism_node::{
+    args::RollupArgs,
+    node::{OpAddOns, OpEngineValidatorBuilder},
+    OpEngineApiBuilder, OpNode,
+};
+use tokio::sync::oneshot;
+
+#[tokio::main]
+async fn main() {
+    // Op node configuration and setup
+    let config = NodeConfig::new(BASE_MAINNET.clone());
+    let db = create_test_rw_db();
+    let args = RollupArgs::default();
+    let op_node = OpNode::new(args);
+
+    let (engine_api_tx, _engine_api_rx) = oneshot::channel();
+
+    let engine_api =
+        EngineApiExt::new(OpEngineApiBuilder::<OpEngineValidatorBuilder>::default(), move |api| {
+            let _ = engine_api_tx.send(api);
+        });
+
+    let _builder = NodeBuilder::new(config)
+        .with_database(db)
+        .with_types::<OpNode>()
+        .with_components(op_node.components())
+        .with_add_ons(OpAddOns::default().with_engine_api(engine_api))
+        .on_component_initialized(move |ctx| {
+            let _provider = ctx.provider();
+            Ok(())
+        })
+        .on_node_started(|_full_node| Ok(()))
+        .on_rpc_started(|_ctx, handles| {
+            let _client = handles.rpc.http_client();
+            Ok(())
+        })
+        .check_launch();
+}