Struct RpcAddOns 

pub struct RpcAddOns<Node: FullNodeComponents, EthB: EthApiBuilder<Node>, PVB, EB = BasicEngineApiBuilder<PVB>, EVB = BasicEngineValidatorBuilder<PVB>, RpcMiddleware = Identity> {
    pub hooks: RpcHooks<Node, EthB::EthApi>,
    /* private fields */
}

Node add-ons containing RPC server configuration, with customizable eth API handler.

This struct can be used to provide the RPC server functionality. It is responsible for launching the regular RPC and the authenticated RPC server (engine API). It is intended to be used and modified as part of the NodeAddOns see for example OpRpcAddons, EthereumAddOns.

It can be modified to register RPC API handlers, see RpcAddOns::launch_add_ons_with which takes a closure that provides access to all the configured modules (namespaces), and is invoked just before the servers are launched. This can be used to extend the node with custom RPC methods or even replace existing method handlers, see also TransportRpcModules.

Fields

hooks: RpcHooks<Node, EthB::EthApi>

Additional RPC add-ons.

Implementations

impl<Node, EthB, PVB, EB, EVB, RpcMiddleware> RpcAddOns<Node, EthB, PVB, EB, EVB, RpcMiddleware>

where Node: FullNodeComponents, EthB: EthApiBuilder<Node>,

pub fn new( eth_api_builder: EthB, payload_validator_builder: PVB, engine_api_builder: EB, engine_validator_builder: EVB, rpc_middleware: RpcMiddleware, ) -> Self

Creates a new instance of the RPC add-ons.

pub fn with_engine_api<T>( self, engine_api_builder: T, ) -> RpcAddOns<Node, EthB, PVB, T, EVB, RpcMiddleware>

Maps the EngineApiBuilder builder type.

pub fn with_payload_validator<T>( self, payload_validator_builder: T, ) -> RpcAddOns<Node, EthB, T, EB, EVB, RpcMiddleware>

Maps the PayloadValidatorBuilder builder type.

pub fn with_engine_validator<T>( self, engine_validator_builder: T, ) -> RpcAddOns<Node, EthB, PVB, EB, T, RpcMiddleware>

Maps the EngineValidatorBuilder builder type.

pub fn with_rpc_middleware<T>( self, rpc_middleware: T, ) -> RpcAddOns<Node, EthB, PVB, EB, EVB, T>

Sets the RPC middleware stack for processing RPC requests.

This method configures a custom middleware stack that will be applied to all RPC requests across HTTP, WebSocket, and IPC transports. The middleware is applied to the RPC service layer, allowing you to intercept, modify, or enhance RPC request processing.

How It Works

The middleware uses the Tower ecosystem’s Layer pattern. When an RPC server is started, the configured middleware stack is applied to create a layered service that processes requests in the order the layers were added.

Examples

use reth_rpc_builder::{RpcServiceBuilder, RpcRequestMetrics};
use tower::Layer;

// Simple example with metrics
let metrics_layer = RpcRequestMetrics::new(metrics_recorder);
let with_metrics = rpc_addons.with_rpc_middleware(
    RpcServiceBuilder::new().layer(metrics_layer)
);

// Composing multiple middleware layers
let middleware_stack = RpcServiceBuilder::new()
    .layer(rate_limit_layer)
    .layer(logging_layer)
    .layer(metrics_layer);
let with_full_stack = rpc_addons.with_rpc_middleware(middleware_stack);

Notes

• Middleware is applied to the RPC service layer, not the HTTP transport layer
• The default middleware is Identity (no-op), which passes through requests unchanged
• Middleware layers are applied in the order they are added via .layer()

pub fn with_tokio_runtime(self, tokio_runtime: Option<Handle>) -> Self

Sets the tokio runtime for the RPC servers.

Caution: This runtime must not be created from within asynchronous context.

pub fn layer_rpc_middleware<T>( self, layer: T, ) -> RpcAddOns<Node, EthB, PVB, EB, EVB, Stack<RpcMiddleware, T>>

Add a new layer T to the configured RpcServiceBuilder.

pub fn option_layer_rpc_middleware<T>( self, layer: Option<T>, ) -> RpcAddOns<Node, EthB, PVB, EB, EVB, Stack<RpcMiddleware, Either<T, Identity>>>

Optionally adds a new layer T to the configured RpcServiceBuilder.

pub fn on_rpc_started<F>(self, hook: F) -> Self

where F: FnOnce(RpcContext<'_, Node, EthB::EthApi>, RethRpcServerHandles) -> Result<()> + Send + 'static,

Sets the hook that is run once the rpc server is started.

pub fn extend_rpc_modules<F>(self, hook: F) -> Self

where F: FnOnce(RpcContext<'_, Node, EthB::EthApi>) -> Result<()> + Send + 'static,

Sets the hook that is run to configure the rpc modules.

impl<N, EthB, PVB, EB, EVB, RpcMiddleware> RpcAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware>

where N: FullNodeComponents, N::Provider: ChainSpecProvider<ChainSpec: EthereumHardforks>, EthB: EthApiBuilder<N>, EB: EngineApiBuilder<N>, EVB: EngineValidatorBuilder<N>, RpcMiddleware: RethRpcMiddleware,

pub async fn launch_rpc_server<F>( self, ctx: AddOnsContext<'_, N>, ext: F, ) -> Result<RpcServerOnlyHandle<N, EthB::EthApi>>

where F: FnOnce(RpcModuleContainer<'_, N, EthB::EthApi>) -> Result<()>,

Launches only the regular RPC server (HTTP/WS/IPC), without the authenticated Engine API server.

This is useful when you only need the regular RPC functionality and want to avoid starting the auth server.

pub async fn launch_add_ons_with<F>( self, ctx: AddOnsContext<'_, N>, ext: F, ) -> Result<RpcHandle<N, EthB::EthApi>>

where F: FnOnce(RpcModuleContainer<'_, N, EthB::EthApi>) -> Result<()>,

Launches the RPC servers with the given context and an additional hook for extending modules. Whether the auth server is launched depends on the CLI configuration.

pub async fn launch_add_ons_with_opt_engine<F>( self, ctx: AddOnsContext<'_, N>, ext: F, disable_auth: bool, ) -> Result<RpcHandle<N, EthB::EthApi>>

where F: FnOnce(RpcModuleContainer<'_, N, EthB::EthApi>) -> Result<()>,

Launches the RPC servers with the given context and an additional hook for extending modules. Optionally disables the auth server based on the disable_auth parameter.

When disable_auth is true, the auth server will not be started and a noop handle will be used instead.

Trait Implementations

impl<Node, EthB, PVB, EB, EVB, RpcMiddleware> Debug for RpcAddOns<Node, EthB, PVB, EB, EVB, RpcMiddleware>

where Node: FullNodeComponents, EthB: EthApiBuilder<Node>, PVB: Debug, EB: Debug, EVB: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Node, EthB, EV, EB, Engine> Default for RpcAddOns<Node, EthB, EV, EB, Engine, Identity>

where Node: FullNodeComponents, EthB: EthApiBuilder<Node>, EV: Default, EB: Default, Engine: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<N, EthB, PVB, EB, EVB, RpcMiddleware> EngineValidatorAddOn<N> for RpcAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware>

where N: FullNodeComponents, EthB: EthApiBuilder<N>, PVB: Send, EB: EngineApiBuilder<N>, EVB: EngineValidatorBuilder<N>, RpcMiddleware: Send,

type ValidatorBuilder = EVB

The validator builder type to use.

fn engine_validator_builder(&self) -> Self::ValidatorBuilder

Returns the validator builder.

impl<N, EthB, PVB, EB, EVB, RpcMiddleware> NodeAddOns<N> for RpcAddOns<N, EthB, PVB, EB, EVB, RpcMiddleware>

where N: FullNodeComponents, <N as FullNodeTypes>::Provider: ChainSpecProvider<ChainSpec: EthereumHardforks>, EthB: EthApiBuilder<N>, PVB: PayloadValidatorBuilder<N>, EB: EngineApiBuilder<N>, EVB: EngineValidatorBuilder<N>, RpcMiddleware: RethRpcMiddleware,

type Handle = RpcHandle<N, <EthB as EthApiBuilder<N>>::EthApi>

Handle to add-ons.

async fn launch_add_ons(self, ctx: AddOnsContext<'_, N>) -> Result<Self::Handle>

Configures and launches the add-ons.

impl<N: FullNodeComponents, EthB, EV, EB, Engine, RpcMiddleware> RethRpcAddOns<N> for RpcAddOns<N, EthB, EV, EB, Engine, RpcMiddleware>

where Self: NodeAddOns<N, Handle = RpcHandle<N, EthB::EthApi>>, EthB: EthApiBuilder<N>,

type EthApi = <EthB as EthApiBuilder<N>>::EthApi

eth API implementation.

fn hooks_mut(&mut self) -> &mut RpcHooks<N, Self::EthApi>

Returns a mutable reference to RPC hooks.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.