Struct fuel_core_p2p::config::Config

pub struct Config<State = Initialized> {

    pub keypair: Keypair,
    pub network_name: String,
    pub checksum: Checksum,
    pub address: IpAddr,
    pub public_address: Option<Multiaddr>,
    pub tcp_port: u16,
    pub max_block_size: usize,
    pub bootstrap_nodes: Vec<Multiaddr>,
    pub enable_mdns: bool,
    pub allow_private_addresses: bool,
    pub random_walk: Option<Duration>,
    pub connection_idle_timeout: Option<Duration>,
    pub reserved_nodes: Vec<Multiaddr>,
    pub reserved_nodes_only_mode: bool,
    pub max_peers_connected: u32,
    pub max_connections_per_peer: u32,
    pub identify_interval: Option<Duration>,
    pub info_interval: Option<Duration>,
    pub gossipsub_config: GossipsubConfig,
    pub topics: Vec<String>,
    pub heartbeat_config: HeartbeatConfig,
    pub set_request_timeout: Duration,
    pub set_connection_keep_alive: Duration,
    pub metrics: bool,
    pub state: State,
}

Fields

keypair: Keypair

The keypair used for for handshake during communication with other p2p nodes.

network_name: String

Name of the Network

checksum: Checksum

Checksum is a hash(sha256) of Genesis - chain id.

address: IpAddr

IP address for Swarm to listen on

public_address: Option<Multiaddr>

Optional address of your local node made reachable for other nodes in the network.

tcp_port: u16

The TCP port that Swarm listens on

max_block_size: usize

Max Size of a Block in bytes

bootstrap_nodes: Vec<Multiaddr>

enable_mdns: bool

allow_private_addresses: bool

random_walk: Option<Duration>

connection_idle_timeout: Option<Duration>

reserved_nodes: Vec<Multiaddr>

Priority nodes that the node should maintain connection to

reserved_nodes_only_mode: bool

Should the node only accept connection requests from the Reserved Nodes

max_peers_connected: u32

Max number of unique peers connected This number should be at least number of mesh_n from Gossipsub configuration. The total number of connections will be (max_peers_connected + reserved_nodes.len()) * max_connections_per_peer

max_connections_per_peer: u32

Max number of connections per single peer The total number of connections will be (max_peers_connected + reserved_nodes.len()) * max_connections_per_peer

identify_interval: Option<Duration>

The interval at which identification requests are sent to the remote on established connections after the first request

info_interval: Option<Duration>

The duration between the last successful outbound or inbound ping and the next outbound ping

gossipsub_config: GossipsubConfig

topics: Vec<String>

heartbeat_config: HeartbeatConfig

set_request_timeout: Duration

Sets the timeout for inbound and outbound requests.

set_connection_keep_alive: Duration

Sets the keep-alive timeout of idle connections.

metrics: bool

Enables prometheus metrics for this fuel-service

state: State

It is the state of the config initialization. Everyone can create an instance of the Self with the NotInitialized state. But it can be set into the Initialized state only with the init method.

Implementations

impl Config<NotInitialized>

pub fn init(self, genesis: Genesis) -> Result<Config<Initialized>>

Inits the P2PConfig with some lazily loaded data.

impl Config<NotInitialized>

pub fn default(network_name: &str) -> Self

Trait Implementations

impl<State: Clone> Clone for Config<State>

fn clone(&self) -> Config<State>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for Config<State>

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

Formats the value using the given formatter.