Struct P2PConfig 

pub struct P2PConfig {

    pub laddr: String,
    pub external_address: String,
    pub seeds: Vec<String>,
    pub persistent_peers: Vec<String>,
    pub upnp: bool,
    pub local_net: bool,
    pub max_num_inbound_peers: u64,
    pub max_num_outbound_peers: u64,
    pub unconditional_peer_ids: Vec<String>,
    pub persistent_peers_max_dial_period: Duration,
    pub flush_throttle_timeout: Duration,
    pub max_packet_msg_payload_size: u64,
    pub send_rate: u64,
    pub recv_rate: u64,
    pub pex: bool,
    pub seed_mode: bool,
    pub private_peer_ids: Vec<String>,
    pub allow_duplicate_ip: bool,
    pub handshake_timeout: Duration,
    pub dial_timeout: Duration,
}

Fields

laddr: String

Address to listen for incoming connections.

external_address: String

Address to advertise to peers for them to dial If empty, will use the same port as the laddr, and will introspect on the listener or use UPnP to figure out the address. ip and port are required example: 159.89.10.97:26656

seeds: Vec<String>

List of seeds

persistent_peers: Vec<String>

List of persistent peers.

upnp: bool

UPNP port forwarding

local_net: bool

Private or local net.

max_num_inbound_peers: u64

Maximum number of inbound peers

max_num_outbound_peers: u64

Maximum number of outbound peers to connect to, excluding persistent peers

unconditional_peer_ids: Vec<String>

List of node IDs, to which a connection will be (re)established ignoring any existing limits

persistent_peers_max_dial_period: Duration

Maximum pause when redialing a persistent peer (if zero, exponential backoff is used)

flush_throttle_timeout: Duration

Time to wait before flushing messages out on the connection

max_packet_msg_payload_size: u64

Maximum size of a message packet payload, in bytes

send_rate: u64

Rate at which packets can be sent, in bytes/second

recv_rate: u64

Rate at which packets can be received, in bytes/second

pex: bool

Set true to enable the peer-exchange reactor

seed_mode: bool

Seed mode, in which node constantly crawls the network and looks for peers. If another node asks it for addresses, it responds and disconnects.

Does not work if the peer-exchange reactor is disabled.

private_peer_ids: Vec<String>

Comma separated list of peer IDs to keep private (will not be gossiped to other peers)

allow_duplicate_ip: bool

Toggle to disable guard against peers connecting from the same ip.

handshake_timeout: Duration

Peer connection configuration.

dial_timeout: Duration

Implementations

impl P2PConfig

pub fn laddr(self, laddr: &str) -> Self

pub fn external_address(self, external_address: &str) -> Self

pub fn seeds(self, seeds: Vec<String>) -> Self

pub fn persistent_peers(self, persistent_peers: Vec<String>) -> Self

pub fn upnp(self, upnp: bool) -> Self

pub fn local_net(self, local_net: bool) -> Self

pub fn max_num_inbound_peers(self, max_num_inbound_peers: u64) -> Self

pub fn max_num_outbound_peers(self, max_num_outbound_peers: u64) -> Self

pub fn unconditional_peer_ids(self, unconditional_peer_ids: Vec<String>) -> Self

pub fn persistent_peers_max_dial_period( self, persistent_peers_max_dial_period: Duration, ) -> Self

pub fn flush_throttle_timeout(self, flush_throttle_timeout: Duration) -> Self

pub fn send_rate(self, send_rate: u64) -> Self

pub fn recv_rate(self, recv_rate: u64) -> Self

pub fn pex(self, pex: bool) -> Self

pub fn seed_mode(self, seed_mode: bool) -> Self

pub fn private_peer_ids(self, private_peer_ids: Vec<String>) -> Self

pub fn allow_duplicate_ip(self, allow_duplicate_ip: bool) -> Self

pub fn handshake_timeout(self, handshake_timeout: Duration) -> Self

pub fn dial_timeout(self, dial_timeout: Duration) -> Self

Trait Implementations

impl Clone for P2PConfig

fn clone(&self) -> P2PConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for P2PConfig

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

Formats the value using the given formatter.

impl Default for P2PConfig

fn default() -> Self

Returns the “default value” for a type.