Struct polkadot_node_network_protocol::request_response::network::Params

pub struct Params<B, H, Client>where
    B: 'static + Block,
    H: ExHashT,{

    pub role: Role,
    pub executor: Option<Box<dyn Fn(Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>) + Send + 'static, Global>>,
    pub transactions_handler_executor: Box<dyn Fn(Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>) + Send + 'static, Global>,
    pub network_config: NetworkConfiguration,
    pub chain: Arc<Client>,
    pub bitswap: Option<Bitswap<B>>,
    pub transaction_pool: Arc<dyn TransactionPool<H, B> + 'static>,
    pub protocol_id: ProtocolId,
    pub fork_id: Option<String>,
    pub import_queue: Box<dyn ImportQueue<B> + 'static, Global>,
    pub chain_sync: Box<dyn ChainSync<B> + 'static, Global>,
    pub metrics_registry: Option<Registry>,
    pub block_request_protocol_config: ProtocolConfig,
    pub light_client_request_protocol_config: ProtocolConfig,
    pub state_request_protocol_config: ProtocolConfig,
    pub warp_sync_protocol_config: Option<ProtocolConfig>,
}

Network initialization parameters.

Fields

role: Role

Assigned role for our node (full, light, …).

executor: Option<Box<dyn Fn(Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>) + Send + 'static, Global>>

How to spawn background tasks. If you pass None, then a threads pool will be used by default.

transactions_handler_executor: Box<dyn Fn(Pin<Box<dyn Future<Output = ()> + Send + 'static, Global>>) + Send + 'static, Global>

How to spawn the background task dedicated to the transactions handler.

network_config: NetworkConfiguration

Network layer configuration.

chain: Arc<Client>

Client that contains the blockchain.

bitswap: Option<Bitswap<B>>

Bitswap block request protocol implementation.

transaction_pool: Arc<dyn TransactionPool<H, B> + 'static>

Pool of transactions.

The network worker will fetch transactions from this object in order to propagate them on the network.

protocol_id: ProtocolId

Legacy name of the protocol to use on the wire. Should be different for each chain.

fork_id: Option<String>

Fork ID to distinguish protocols of different hard forks. Part of the standard protocol name on the wire.

import_queue: Box<dyn ImportQueue<B> + 'static, Global>

Import queue to use.

The import queue is the component that verifies that blocks received from other nodes are valid.

chain_sync: Box<dyn ChainSync<B> + 'static, Global>

Instance of chain sync implementation.

metrics_registry: Option<Registry>

Registry for recording prometheus metrics to.

block_request_protocol_config: ProtocolConfig

Request response configuration for the block request protocol.

RequestResponseConfig::name is used to tag outgoing block requests with the correct protocol name. In addition all of RequestResponseConfig is used to handle incoming block requests, if enabled.

Can be constructed either via sc_network_sync::block_request_handler::generate_protocol_config allowing outgoing but not incoming requests, or constructed via sc_network_sync::block_request_handler:: BlockRequestHandler::new allowing both outgoing and incoming requests.

light_client_request_protocol_config: ProtocolConfig

Request response configuration for the light client request protocol.

Can be constructed either via sc_network_light::light_client_requests::generate_protocol_config allowing outgoing but not incoming requests, or constructed via sc_network_light::light_client_requests::handler::LightClientRequestHandler::new allowing both outgoing and incoming requests.

state_request_protocol_config: ProtocolConfig

Request response configuration for the state request protocol.

Can be constructed either via sc_network_sync::state_request_handler::generate_protocol_config allowing outgoing but not incoming requests, or constructed via sc_network_sync::state_request_handler::StateRequestHandler::new allowing both outgoing and incoming requests.

warp_sync_protocol_config: Option<ProtocolConfig>

Optional warp sync protocol config.