Struct WithLaunchContext 

pub struct WithLaunchContext<Builder> { /* private fields */ }

A NodeBuilder with its launch context already configured.

This exposes the same methods as NodeBuilder but with the launch context already configured, See WithLaunchContext::launch

Implementations

impl<Builder> WithLaunchContext<Builder>

pub const fn task_executor(&self) -> &TaskExecutor

Returns a reference to the task executor.

impl<DB, ChainSpec> WithLaunchContext<NodeBuilder<DB, ChainSpec>>

pub const fn config(&self) -> &NodeConfig<ChainSpec>

Returns a reference to the node builder’s config.

impl<DB, ChainSpec> WithLaunchContext<NodeBuilder<DB, ChainSpec>>

where DB: Database + DatabaseMetrics + Clone + Unpin + 'static, ChainSpec: EthChainSpec + EthereumHardforks,

pub fn with_types<T>( self, ) -> WithLaunchContext<NodeBuilderWithTypes<RethFullAdapter<DB, T>>>

where T: NodeTypesForProvider<ChainSpec = ChainSpec>,

Configures the types of the node.

pub fn with_types_and_provider<T, P>( self, ) -> WithLaunchContext<NodeBuilderWithTypes<FullNodeTypesAdapter<T, DB, P>>>

where T: NodeTypesForProvider<ChainSpec = ChainSpec>, P: FullProvider<NodeTypesWithDBAdapter<T, DB>>,

Configures the types of the node and the provider type that will be used by the node.

pub fn node<N>( self, node: N, ) -> WithLaunchContext<NodeBuilderWithComponents<RethFullAdapter<DB, N>, N::ComponentsBuilder, N::AddOns>>

where N: Node<RethFullAdapter<DB, N>, ChainSpec = ChainSpec> + NodeTypesForProvider,

Preconfigures the node with a specific node implementation.

This is a convenience method that sets the node’s types and components in one call.

pub async fn launch_node<N>( self, node: N, ) -> Result<<EngineNodeLauncher as LaunchNode<NodeBuilderWithComponents<RethFullAdapter<DB, N>, N::ComponentsBuilder, N::AddOns>>>::Node>

where N: Node<RethFullAdapter<DB, N>, ChainSpec = ChainSpec> + NodeTypesForProvider, N::AddOns: RethRpcAddOns<NodeAdapter<RethFullAdapter<DB, N>, <N::ComponentsBuilder as NodeComponentsBuilder<RethFullAdapter<DB, N>>>::Components>>, N::Primitives: FullNodePrimitives, EngineNodeLauncher: LaunchNode<NodeBuilderWithComponents<RethFullAdapter<DB, N>, N::ComponentsBuilder, N::AddOns>>,

Launches a preconfigured Node

This bootstraps the node internals, creates all the components with the given Node

Returns a NodeHandle that can be used to interact with the node.

impl<T: FullNodeTypes> WithLaunchContext<NodeBuilderWithTypes<T>>

pub fn with_components<CB>( self, components_builder: CB, ) -> WithLaunchContext<NodeBuilderWithComponents<T, CB, ()>>

where CB: NodeComponentsBuilder<T>,

Advances the state of the node builder to the next state where all components are configured

impl<T, CB> WithLaunchContext<NodeBuilderWithComponents<T, CB, ()>>

where T: FullNodeTypes, CB: NodeComponentsBuilder<T>,

pub fn with_add_ons<AO>( self, add_ons: AO, ) -> WithLaunchContext<NodeBuilderWithComponents<T, CB, AO>>

where AO: NodeAddOns<NodeAdapter<T, CB::Components>>,

Advances the state of the node builder to the next state where all customizable NodeAddOns types are configured.

impl<T, CB, AO> WithLaunchContext<NodeBuilderWithComponents<T, CB, AO>>

where T: FullNodeTypes, CB: NodeComponentsBuilder<T>, AO: RethRpcAddOns<NodeAdapter<T, CB::Components>>,

pub const fn config(&self) -> &NodeConfig<<T::Types as NodeTypes>::ChainSpec>

Returns a reference to the node builder’s config.

pub const fn db(&self) -> &T::DB

Returns a reference to node’s database.

pub const fn db_mut(&mut self) -> &mut T::DB

Returns a mutable reference to node’s database.

pub fn try_apply<F, R>(self, f: F) -> Result<Self, R>

where F: FnOnce(Self) -> Result<Self, R>,

Applies a fallible function to the builder.

pub fn try_apply_if<F, R>(self, cond: bool, f: F) -> Result<Self, R>

where F: FnOnce(Self) -> Result<Self, R>,

Applies a fallible function to the builder, if the condition is true.

pub fn apply<F>(self, f: F) -> Self

where F: FnOnce(Self) -> Self,

Apply a function to the builder

pub fn apply_if<F>(self, cond: bool, f: F) -> Self

where F: FnOnce(Self) -> Self,

Apply a function to the builder, if the condition is true.

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

where F: FnOnce(NodeAdapter<T, CB::Components>) -> Result<()> + Send + 'static,

Sets the hook that is run once the node’s components are initialized.

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

where F: FnOnce(FullNode<NodeAdapter<T, CB::Components>, AO>) -> Result<()> + Send + 'static,

Sets the hook that is run once the node has started.

pub fn map_add_ons<F>(self, f: F) -> Self

where F: FnOnce(AO) -> AO,

Modifies the addons with the given closure.

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

where F: FnOnce(RpcContext<'_, NodeAdapter<T, CB::Components>, AO::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<'_, NodeAdapter<T, CB::Components>, AO::EthApi>) -> Result<()> + Send + 'static,

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

This hook can obtain the node’s components (txpool, provider, etc.) and can modify the modules that the RPC server installs.

Examples

use jsonrpsee::{core::RpcResult, proc_macros::rpc};

#[derive(Clone)]
struct CustomApi<Pool> { pool: Pool }

#[rpc(server, namespace = "custom")]
impl CustomApi {
    #[method(name = "hello")]
    async fn hello(&self) -> RpcResult<String> {
        Ok("World".to_string())
    }
}

let node = NodeBuilder::new(config)
    .node(EthereumNode::default())
    .extend_rpc_modules(|ctx| {
        // Access node components, so they can used by the CustomApi
        let pool = ctx.pool().clone();
         
        // Add custom RPC namespace
        ctx.modules.merge_configured(CustomApi { pool }.into_rpc())?;
         
        Ok(())
    })
    .build()?;

pub fn install_exex<F, R, E>(self, exex_id: impl Into<String>, exex: F) -> Self

where F: FnOnce(ExExContext<NodeAdapter<T, CB::Components>>) -> R + Send + 'static, R: Future<Output = Result<E>> + Send, E: Future<Output = Result<()>> + Send,

Installs an ExEx (Execution Extension) in the node.

Note

The ExEx ID must be unique.

pub fn install_exex_if<F, R, E>( self, cond: bool, exex_id: impl Into<String>, exex: F, ) -> Self

where F: FnOnce(ExExContext<NodeAdapter<T, CB::Components>>) -> R + Send + 'static, R: Future<Output = Result<E>> + Send, E: Future<Output = Result<()>> + Send,

Installs an ExEx (Execution Extension) in the node if the condition is true.

Note

The ExEx ID must be unique.

pub async fn launch_with<L>(self, launcher: L) -> Result<L::Node>

where L: LaunchNode<NodeBuilderWithComponents<T, CB, AO>>,

Launches the node with the given launcher.

pub fn launch_with_fn<L, R>(self, launcher: L) -> R

where L: FnOnce(Self) -> R,

Launches the node with the given closure.

pub const fn check_launch(self) -> Self

Check that the builder can be launched

This is useful when writing tests to ensure that the builder is configured correctly.

pub async fn launch( self, ) -> Result<<EngineNodeLauncher as LaunchNode<NodeBuilderWithComponents<T, CB, AO>>>::Node>

where EngineNodeLauncher: LaunchNode<NodeBuilderWithComponents<T, CB, AO>>,

Launches the node with the EngineNodeLauncher that sets up engine API consensus and rpc

pub async fn launch_with_debug_capabilities( self, ) -> Result<<DebugNodeLauncher as LaunchNode<NodeBuilderWithComponents<T, CB, AO>>>::Node>

where T::Types: DebugNode<NodeAdapter<T, CB::Components>>, DebugNodeLauncher: LaunchNode<NodeBuilderWithComponents<T, CB, AO>>,

Launches the node with the DebugNodeLauncher.

This is equivalent to WithLaunchContext::launch, but will enable the debugging features, if they are configured.

pub fn engine_api_launcher(&self) -> EngineNodeLauncher

Returns an EngineNodeLauncher that can be used to launch the node with engine API support.

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.