Struct RpcModuleBuilder

pub struct RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus> { /* private fields */ }

A builder type to configure the RPC module: See [RpcModule]

This is the main entrypoint and the easiest way to configure an RPC server.

Implementations

impl<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus> RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

pub const fn new( provider: Provider, pool: Pool, network: Network, executor: Tasks, events: Events, evm_config: EvmConfig, block_executor: BlockExecutor, consensus: Consensus, ) -> RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

Create a new instance of the builder

pub fn with_provider<P>( self, provider: P, ) -> RpcModuleBuilder<P, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

where P: BlockReader + StateProviderFactory + EvmEnvProvider + 'static,

Configure the provider instance.

pub fn with_pool<P>( self, pool: P, ) -> RpcModuleBuilder<Provider, P, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

where P: TransactionPool + 'static,

Configure the transaction pool instance.

pub fn with_noop_pool( self, ) -> RpcModuleBuilder<Provider, NoopTransactionPool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

Configure a NoopTransactionPool instance.

Caution: This will configure a pool API that does absolutely nothing. This is only intended for allow easier setup of namespaces that depend on the EthApi which requires a TransactionPool implementation.

pub fn with_network<N>( self, network: N, ) -> RpcModuleBuilder<Provider, Pool, N, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

where N: NetworkInfo + Peers + 'static,

Configure the network instance.

pub fn with_noop_network( self, ) -> RpcModuleBuilder<Provider, Pool, NoopNetwork, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

Configure a NoopNetwork instance.

Caution: This will configure a network API that does absolutely nothing. This is only intended for allow easier setup of namespaces that depend on the EthApi which requires a NetworkInfo implementation.

pub fn with_executor<T>( self, executor: T, ) -> RpcModuleBuilder<Provider, Pool, Network, T, Events, EvmConfig, BlockExecutor, Consensus>

where T: TaskSpawner + 'static,

Configure the task executor to use for additional tasks.

pub fn with_tokio_executor( self, ) -> RpcModuleBuilder<Provider, Pool, Network, TokioTaskExecutor, Events, EvmConfig, BlockExecutor, Consensus>

Configure TokioTaskExecutor as the task executor to use for additional tasks.

This will spawn additional tasks directly via tokio::task::spawn, See TokioTaskExecutor.

pub fn with_events<E>( self, events: E, ) -> RpcModuleBuilder<Provider, Pool, Network, Tasks, E, EvmConfig, BlockExecutor, Consensus>

where E: CanonStateSubscriptions + 'static,

Configure the event subscriber instance

pub fn with_evm_config<E>( self, evm_config: E, ) -> RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, E, BlockExecutor, Consensus>

where E: ConfigureEvm + 'static,

Configure the evm configuration type

pub fn with_block_executor<BE>( self, block_executor: BE, ) -> RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BE, Consensus>

where BE: BlockExecutorProvider,

Configure the block executor provider

pub fn with_consensus<C>( self, consensus: C, ) -> RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, C>

Configure the consensus implementation.

impl<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus> RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

where Provider: FullRpcProvider + AccountReader + ChangeSetReader, Pool: TransactionPool + 'static, Network: NetworkInfo + Peers + Clone + 'static, Tasks: TaskSpawner + Clone + 'static, Events: CanonStateSubscriptions + Clone + 'static, EvmConfig: ConfigureEvm<Header = Header>, BlockExecutor: BlockExecutorProvider, Consensus: Consensus + Clone + 'static,

pub fn build_with_auth_server<EngineApi, EngineT, EthApi>( self, module_config: TransportRpcModuleConfig, engine: EngineApi, eth: Box<dyn FnOnce(&EthApiBuilderCtx<Provider, Pool, EvmConfig, Network, Tasks, Events>) -> EthApi>, ) -> (TransportRpcModules, AuthRpcModule, RpcRegistryInner<Provider, Pool, Network, Tasks, Events, EthApi, BlockExecutor, Consensus>)

where EngineT: EngineTypes, EngineApi: EngineApiServer<EngineT>, EthApi: FullEthApiServer,

Configures all [RpcModule]s specific to the given TransportRpcModuleConfig which can be used to start the transport server(s).

This behaves exactly as RpcModuleBuilder::build for the TransportRpcModules, but also configures the auth (engine api) server, which exposes a subset of the eth_ namespace.

pub fn into_registry<EthApi>( self, config: RpcModuleConfig, eth: Box<dyn FnOnce(&EthApiBuilderCtx<Provider, Pool, EvmConfig, Network, Tasks, Events>) -> EthApi>, ) -> RpcRegistryInner<Provider, Pool, Network, Tasks, Events, EthApi, BlockExecutor, Consensus>

where EthApi: EthApiTypes + 'static,

Converts the builder into a RpcRegistryInner which can be used to create all components.

This is useful for getting access to API handlers directly:

Example

use alloy_consensus::Header;
use reth_consensus::noop::NoopConsensus;
use reth_evm::ConfigureEvm;
use reth_evm_ethereum::execute::EthExecutorProvider;
use reth_network_api::noop::NoopNetwork;
use reth_provider::test_utils::{NoopProvider, TestCanonStateSubscriptions};
use reth_rpc::EthApi;
use reth_rpc_builder::RpcModuleBuilder;
use reth_tasks::TokioTaskExecutor;
use reth_transaction_pool::noop::NoopTransactionPool;

fn init<Evm: ConfigureEvm<Header = Header> + 'static>(evm: Evm) {
    let mut registry = RpcModuleBuilder::default()
        .with_provider(NoopProvider::default())
        .with_pool(NoopTransactionPool::default())
        .with_network(NoopNetwork::default())
        .with_executor(TokioTaskExecutor::default())
        .with_events(TestCanonStateSubscriptions::default())
        .with_evm_config(evm)
        .with_block_executor(EthExecutorProvider::mainnet())
        .with_consensus(NoopConsensus::default())
        .into_registry(Default::default(), Box::new(EthApi::with_spawner));

    let eth_api = registry.eth_api();
}

pub fn build<EthApi>( self, module_config: TransportRpcModuleConfig, eth: Box<dyn FnOnce(&EthApiBuilderCtx<Provider, Pool, EvmConfig, Network, Tasks, Events>) -> EthApi>, ) -> TransportRpcModules

where EthApi: FullEthApiServer,

Configures all [RpcModule]s specific to the given TransportRpcModuleConfig which can be used to start the transport server(s).

Trait Implementations

impl<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus> Clone for RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

where Provider: Clone, Pool: Clone, Network: Clone, Tasks: Clone, Events: Clone, EvmConfig: Clone, BlockExecutor: Clone, Consensus: Clone,

fn clone( &self, ) -> RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus> Debug for RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

where Provider: Debug, Pool: Debug, Network: Debug, Tasks: Debug, Events: Debug, EvmConfig: Debug, BlockExecutor: Debug, Consensus: Debug,

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

Formats the value using the given formatter.

impl Default for RpcModuleBuilder<(), (), (), (), (), (), (), ()>

fn default() -> RpcModuleBuilder<(), (), (), (), (), (), (), ()>

Returns the “default value” for a type.

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.