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, ) -> Self

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<Block = <Events::Primitives as NodePrimitives>::Block, Receipt = <Events::Primitives as NodePrimitives>::Receipt, Header = <Events::Primitives as NodePrimitives>::BlockHeader> + AccountReader + ChangeSetReader, Pool: TransactionPool + 'static, Network: NetworkInfo + Peers + Clone + 'static, Tasks: TaskSpawner + Clone + 'static, Events: CanonStateSubscriptions<Primitives = BlockExecutor::Primitives> + Clone + 'static, EvmConfig: ConfigureEvm<Header = <BlockExecutor::Primitives as NodePrimitives>::BlockHeader, Transaction = <BlockExecutor::Primitives as NodePrimitives>::SignedTx>, BlockExecutor: BlockExecutorProvider, Consensus: FullConsensus<BlockExecutor::Primitives> + Clone + 'static,

pub fn build_with_auth_server<EngineApi, EngineT, EthApi>( self, module_config: TransportRpcModuleConfig, engine: EngineApi, eth: DynEthApiBuilder<Provider, Pool, EvmConfig, Network, Tasks, Events, EthApi>, payload_validator: Arc<dyn PayloadValidator<Block = Provider::Block>>, ) -> (TransportRpcModules, AuthRpcModule, RpcRegistryInner<Provider, Pool, Network, Tasks, Events, EthApi, BlockExecutor, Consensus>)

where EngineT: EngineTypes, EngineApi: EngineApiServer<EngineT>, EthApi: FullEthApiServer<Provider: BlockReader<Block = <Events::Primitives as NodePrimitives>::Block, Receipt = <Events::Primitives as NodePrimitives>::Receipt, Header = <Events::Primitives as NodePrimitives>::BlockHeader>, Pool: TransactionPool<Transaction: PoolTransaction<Pooled = PooledTransaction>>>,

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: DynEthApiBuilder<Provider, Pool, EvmConfig, Network, Tasks, Events, EthApi>, payload_validator: Arc<dyn PayloadValidator<Block = Provider::Block>>, ) -> 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 reth_consensus::noop::NoopConsensus;
use reth_engine_primitives::PayloadValidator;
use reth_evm::ConfigureEvm;
use reth_evm_ethereum::execute::EthExecutorProvider;
use reth_network_api::noop::NoopNetwork;
use reth_primitives::{Header, TransactionSigned};
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;
use std::sync::Arc;

fn init<Evm, Validator>(evm: Evm, validator: Validator)
where
    Evm: ConfigureEvm<Header = Header, Transaction = TransactionSigned> + 'static,
    Validator: PayloadValidator<Block = reth_primitives::Block> + 'static,
{
    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), Arc::new(validator));

    let eth_api = registry.eth_api();
}

pub fn build<EthApi>( self, module_config: TransportRpcModuleConfig, eth: DynEthApiBuilder<Provider, Pool, EvmConfig, Network, Tasks, Events, EthApi>, payload_validator: Arc<dyn PayloadValidator<Block = Provider::Block>>, ) -> TransportRpcModules<()>

where EthApi: FullEthApiServer<Provider: BlockReader<Receipt = <Events::Primitives as NodePrimitives>::Receipt, Block = <Events::Primitives as NodePrimitives>::Block, Header = <Events::Primitives as NodePrimitives>::BlockHeader>, Pool: TransactionPool<Transaction: PoolTransaction<Pooled = PooledTransaction>>>, Pool: TransactionPool<Transaction = <EthApi::Pool as TransactionPool>::Transaction>,

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

Trait Implementations

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

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: Debug, Pool: Debug, Network: Debug, Tasks: Debug, Events: Debug, EvmConfig: Debug, BlockExecutor: Debug, Consensus: Debug> Debug for RpcModuleBuilder<Provider, Pool, Network, Tasks, Events, EvmConfig, BlockExecutor, Consensus>

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

Formats the value using the given formatter.

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

fn default() -> Self

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.