Struct NetworkParams

pub struct NetworkParams {

    pub bootnodes: Vec<MultiaddrWithPeerId>,
    pub reserved_nodes: Vec<MultiaddrWithPeerId>,
    pub reserved_only: bool,
    pub public_addr: Vec<Multiaddr>,
    pub listen_addr: Vec<Multiaddr>,
    pub port: Option<u16>,
    pub no_private_ip: bool,
    pub allow_private_ip: bool,
    pub out_peers: u32,
    pub in_peers: u32,
    pub in_peers_light: u32,
    pub no_mdns: bool,
    pub max_parallel_downloads: u32,
    pub node_key_params: NodeKeyParams,
    pub discover_local: bool,
    pub kademlia_disjoint_query_paths: bool,
    pub kademlia_replication_factor: NonZeroUsize,
    pub ipfs_server: bool,
    pub sync: SyncMode,
    pub max_blocks_per_request: u32,
    pub network_backend: NetworkBackendType,
}

Parameters used to create the network configuration.

Fields

bootnodes: Vec<MultiaddrWithPeerId>

Specify a list of bootnodes.

reserved_nodes: Vec<MultiaddrWithPeerId>

Specify a list of reserved node addresses.

reserved_only: bool

Whether to only synchronize the chain with reserved nodes.

Also disables automatic peer discovery. TCP connections might still be established with non-reserved nodes. In particular, if you are a validator your node might still connect to other validator nodes and collator nodes regardless of whether they are defined as reserved nodes.

public_addr: Vec<Multiaddr>

Public address that other nodes will use to connect to this node.

This can be used if there’s a proxy in front of this node.

listen_addr: Vec<Multiaddr>

Listen on this multiaddress.

By default: If --validator is passed: /ip4/0.0.0.0/tcp/<port> and /ip6/[::]/tcp/<port>. Otherwise: /ip4/0.0.0.0/tcp/<port>/ws and /ip6/[::]/tcp/<port>/ws.

port: Option<u16>

Specify p2p protocol TCP port.

no_private_ip: bool

Always forbid connecting to private IPv4/IPv6 addresses.

The option doesn’t apply to addresses passed with --reserved-nodes or --bootnodes. Enabled by default for chains marked as “live” in their chain specifications.

Address allocation for private networks is specified by RFC1918).

allow_private_ip: bool

Always accept connecting to private IPv4/IPv6 addresses.

Enabled by default for chains marked as “local” in their chain specifications, or when --dev is passed.

Address allocation for private networks is specified by RFC1918).

out_peers: u32

Number of outgoing connections we’re trying to maintain.

in_peers: u32

Maximum number of inbound full nodes peers.

in_peers_light: u32

Maximum number of inbound light nodes peers.

no_mdns: bool

Disable mDNS discovery (default: true).

By default, the network will use mDNS to discover other nodes on the local network. This disables it. Automatically implied when using –dev.

max_parallel_downloads: u32

Maximum number of peers from which to ask for the same blocks in parallel.

This allows downloading announced blocks from multiple peers. Decrease to save traffic and risk increased latency.

node_key_params: NodeKeyParams

discover_local: bool

Enable peer discovery on local networks.

By default this option is true for --dev or when the chain type is Local/Development and false otherwise.

kademlia_disjoint_query_paths: bool

Require iterative Kademlia DHT queries to use disjoint paths.

Disjoint paths increase resiliency in the presence of potentially adversarial nodes.

See the S/Kademlia paper for more information on the high level design as well as its security improvements.

kademlia_replication_factor: NonZeroUsize

Kademlia replication factor.

Determines to how many closest peers a record is replicated to.

Discovery mechanism requires successful replication to all kademlia_replication_factor peers to consider record successfully put.

ipfs_server: bool

Join the IPFS network and serve transactions over bitswap protocol.

sync: SyncMode

Blockchain syncing mode.

max_blocks_per_request: u32

Maximum number of blocks per request.

Try reducing this number from the default value if you have a slow network connection and observe block requests timing out.

network_backend: NetworkBackendType

Network backend used for P2P networking.

Litep2p is a lightweight alternative to libp2p, that is designed to be more efficient and easier to use. At the same time, litep2p brings performance improvements and reduces the CPU usage significantly.

Libp2p is the old network backend, that may still be used for compatibility reasons until the whole ecosystem is migrated to litep2p.

Implementations

impl NetworkParams

pub fn network_config( &self, chain_spec: &Box<dyn ChainSpec>, is_dev: bool, is_validator: bool, net_config_path: Option<PathBuf>, client_id: &str, node_name: &str, node_key: NodeKeyConfig, default_listen_port: u16, ) -> NetworkConfiguration

Fill the given NetworkConfiguration by looking at the cli parameters.

Trait Implementations

impl Args for NetworkParams

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self.

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can update self.

impl Clone for NetworkParams

fn clone(&self) -> NetworkParams

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NetworkParams

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

Formats the value using the given formatter.

impl FromArgMatches for NetworkParams

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.