Struct BootstrapClient 

pub struct BootstrapClient<N: Network>(/* private fields */);

Implementations

impl<N: Network> BootstrapClient<N>

pub async fn new( listener_addr: SocketAddr, account: Account<N>, genesis_header: Header<N>, dev: Option<u16>, ) -> Result<Self>

pub fn address(&self) -> Address<N>

Returns the account address of the node.

pub fn private_key(&self) -> &PrivateKey<N>

Returns the account private key of the node.

pub fn view_key(&self) -> &ViewKey<N>

Returns the account view key of the node.

pub fn resolve_to_listener( &self, connected_addr: SocketAddr, ) -> Option<SocketAddr>

Returns the listener IP address from the connected peer address.

pub fn is_dev(&self) -> bool

Returns true if the node is in development mode.

pub async fn get_or_update_committee( &self, ) -> Result<Option<HashSet<Address<N>>>>

Returns the current validator committee or updates it from the explorer, if we are capable of obtaining it from the network.

pub fn get_known_validators(&self) -> HashMap<SocketAddr, Address<N>>

Returns the list of known validators connected in Gateway mode.

pub async fn shut_down(&self)

Shuts down the bootstrap client.

Trait Implementations

impl<N: Clone + Network> Clone for BootstrapClient<N>

fn clone(&self) -> BootstrapClient<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Network> Deref for BootstrapClient<N>

type Target = Arc<InnerBootstrapClient<N>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<N: Network> Disconnect for BootstrapClient<N>

fn handle_disconnect<'life0, 'async_trait>( &'life0 self, peer_addr: SocketAddr, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Any extra operations to be performed during a disconnect.

fn enable_disconnect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Attaches the behavior specified in Disconnect::handle_disconnect to every occurrence of the node disconnecting from a peer.

impl<N: Network> Handshake for BootstrapClient<N>

fn perform_handshake<'life0, 'async_trait>( &'life0 self, connection: Connection, ) -> Pin<Box<dyn Future<Output = Result<Connection>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Performs the handshake; temporarily assumes control of the Connection and returns it if the handshake is successful.

const TIMEOUT_MS: u64 = 3_000u64

The maximum time allowed for a connection to perform a handshake before it is rejected.

fn enable_handshake<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Prepares the node to perform specified network handshakes.

fn borrow_stream<'a>(&self, conn: &'a mut Connection) -> &'a mut TcpStream

Borrows the full connection stream to be used in the implementation of Handshake::perform_handshake.

fn take_stream(&self, conn: &mut Connection) -> TcpStream

Assumes full control of a connection’s stream in the implementation of Handshake::perform_handshake, by the end of which it must be followed by Handshake::return_stream.

fn return_stream<T>(&self, conn: &mut Connection, stream: T)

where T: AsyncRead + AsyncWrite + Send + Sync + 'static,

This method only needs to be called if Handshake::take_stream had been called before; it is used to return a (potentially modified) stream back to the applicable connection.

impl<N: Network> OnConnect for BootstrapClient<N>

fn on_connect<'life0, 'async_trait>( &'life0 self, peer_addr: SocketAddr, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Any initial actions to be executed after the handshake is concluded; in order to be able to communicate with the peer in the usual manner (i.e. via [Writing]), only its SocketAddr (as opposed to the related [Connection] object) is provided as an argument.

fn enable_on_connect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Attaches the behavior specified in OnConnect::on_connect right after every successful handshake.

impl<N: Network> P2P for BootstrapClient<N>

fn tcp(&self) -> &Tcp

Returns a reference to the TCP instance.

impl<N: Network> PeerPoolHandling<N> for BootstrapClient<N>

const MAXIMUM_POOL_SIZE: usize = 10_000usize

The maximum number of peers permitted to be stored in the peer pool.

const OWNER: &'static str = "[Network]"

const PEER_SLASHING_COUNT: usize = 200usize

The number of candidate peers to be removed from the pool once MAXIMUM_POOL_SIZE is reached. It must be lower than MAXIMUM_POOL_SIZE.

fn is_dev(&self) -> bool

Returns true if the owning node is in development mode.

fn peer_pool(&self) -> &RwLock<HashMap<SocketAddr, Peer<N>>>

fn resolver(&self) -> &RwLock<Resolver<N>>

fn local_ip(&self) -> SocketAddr

Returns the listener address of this node.

fn is_local_ip(&self, addr: SocketAddr) -> bool

Returns true if the given IP is this node.

fn is_valid_peer_ip(&self, ip: SocketAddr) -> bool

Returns true if the given IP is not this node, is not a bogon address, and is not unspecified.

fn max_connected_peers(&self) -> usize

Returns the maximum number of connected peers.

fn check_connection_attempt( &self, listener_addr: SocketAddr, ) -> Result<bool, Error>

Ensure we are allowed to connect to the given listener address of a peer.

fn connect(&self, listener_addr: SocketAddr) -> Option<JoinHandle<bool>>

Attempts to connect to the given peer’s listener address.

fn disconnect(&self, listener_addr: SocketAddr) -> JoinHandle<bool>

Disconnects from the given peer IP, if the peer is connected. The returned boolean indicates whether the peer was actually disconnected from, or if this was a noop.

fn downgrade_peer_to_candidate(&self, listener_addr: SocketAddr)

Downgrades a connected peer to candidate status.

fn insert_candidate_peers(&self, listener_addrs: Vec<(SocketAddr, Option<u32>)>)

Adds new candidate peers to the peer pool, ensuring their validity and following the limit on the number of peers in the pool. The listener addresses may be paired with the last known block height of the associated peer.

fn remove_peer(&self, listener_addr: SocketAddr)

Completely removes an entry from the peer pool.

fn resolve_to_ambiguous(&self, listener_addr: SocketAddr) -> Option<SocketAddr>

Returns the connected peer address from the listener IP address.

fn resolve_to_aleo_addr(&self, listener_addr: SocketAddr) -> Option<Address<N>>

Returns the connected peer aleo address from the listener IP address.

fn is_connecting(&self, listener_addr: SocketAddr) -> bool

Returns true if the node is connecting to the given peer’s listener address.

fn is_connected(&self, listener_addr: SocketAddr) -> bool

Returns true if the node is connected to the given peer listener address.

fn is_trusted(&self, listener_addr: SocketAddr) -> bool

Returns true if the given listener address is trusted.

fn number_of_peers(&self) -> usize

Returns the number of all peers.

fn number_of_connected_peers(&self) -> usize

Returns the number of connected peers.

fn number_of_connecting_peers(&self) -> usize

Returns the number of connecting peers.

fn number_of_candidate_peers(&self) -> usize

Returns the number of candidate peers.

fn get_connected_peer( &self, listener_addr: SocketAddr, ) -> Option<ConnectedPeer<N>>

Returns the connected peer given the peer IP, if it exists.

fn update_connected_peer<F>( &self, listener_addr: &SocketAddr, update_fn: F, ) -> bool

where F: FnMut(&mut ConnectedPeer<N>),

Updates the connected peer - if it exists - given the peer IP and a closure. The returned status indicates whether the update was successful, i.e. the peer had existed.

fn get_peers(&self) -> Vec<Peer<N>>

Returns the list of all peers (connected, connecting, and candidate).

fn get_connected_peers(&self) -> Vec<ConnectedPeer<N>>

Returns all connected peers.

fn get_best_connected_peers( &self, max_entries: Option<usize>, ) -> Vec<ConnectedPeer<N>>

Returns an optionally bounded list of all connected peers sorted by their block height (highest first) and failure count (lowest first).

fn filter_connected_peers<P>(&self, predicate: P) -> Vec<ConnectedPeer<N>>

where P: FnMut(&ConnectedPeer<N>) -> bool,

Returns all connected peers that satisify the given predicate.

fn connected_peers(&self) -> Vec<SocketAddr>

Returns the list of connected peers.

fn trusted_peers(&self) -> Vec<SocketAddr>

Returns the list of trusted peers.

fn get_candidate_peers(&self) -> Vec<CandidatePeer>

Returns the list of candidate peers.

fn unconnected_trusted_peers(&self) -> HashSet<SocketAddr>

Returns the list of unconnected trusted peers.

fn load_cached_peers( storage_mode: &StorageMode, filename: &str, ) -> Result<Vec<SocketAddr>, Error>

Loads any previously cached peer addresses so they can be introduced as initial candidate peers to connect to.

fn save_best_peers( &self, storage_mode: &StorageMode, filename: &str, max_entries: Option<usize>, ) -> Result<(), Error>

Preserve the peers who have the greatest known block heights, and the lowest number of registered network failures.

fn add_connecting_peer(&self, listener_addr: SocketAddr) -> bool

fn ip_ban_peer(&self, listener_addr: SocketAddr, reason: Option<&str>)

Temporarily IP-ban and disconnect from the peer with the given listener address and an optional reason for the ban. This also removes the peer from the candidate pool.

fn is_ip_banned(&self, ip: IpAddr) -> bool

Check whether the given IP address is currently banned.

fn update_ip_ban(&self, ip: IpAddr)

Insert or update a banned IP.

impl<N: Network> Reading for BootstrapClient<N>

fn codec(&self, _peer_addr: SocketAddr, _side: ConnectionSide) -> Self::Codec

Creates a Decoder used to interpret messages from the network. The side param indicates the connection side from the node’s perspective.

fn process_message<'life0, 'async_trait>( &'life0 self, peer_addr: SocketAddr, message: Self::Message, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes a message received from the network.

type Codec = BootstrapClientCodec<N>

The user-supplied Decoder used to interpret inbound messages.

type Message = <BootstrapClientCodec<N> as Decoder>::Item

The final (deserialized) type of inbound messages.

fn message_queue_depth(&self) -> usize

The depth of per-connection queues used to process inbound messages; the greater it is, the more inbound messages the node can enqueue, but setting it to a large value can make the node more susceptible to DoS attacks.

const INITIAL_BUFFER_SIZE: usize = 1_048_576usize

The initial size of a per-connection buffer for reading inbound messages. Can be set to the maximum expected size of the inbound message in order to only allocate it once.

fn enable_reading<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Prepares the node to receive messages.

impl<N: Network> Writing for BootstrapClient<N>

fn codec(&self, _addr: SocketAddr, _side: ConnectionSide) -> Self::Codec

Creates an [Encoder] used to write the outbound messages to the target stream. The side parameter indicates the connection side from the node’s perspective.

type Codec = BootstrapClientCodec<N>

The user-supplied Encoder used to write outbound messages to the target stream.

type Message = MessageOrEvent<N>

The type of the outbound messages; unless their serialization is expensive and the message is broadcasted (in which case it would get serialized multiple times), serialization should be done in the implementation of Self::Codec.

fn message_queue_depth(&self) -> usize

The depth of per-connection queues used to send outbound messages; the greater it is, the more outbound messages the node can enqueue. Setting it to a large value is not recommended, as doing it might obscure potential issues with your implementation (like slow serialization) or network.

fn enable_writing<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Prepares the node to send messages.

fn unicast( &self, addr: SocketAddr, message: Self::Message, ) -> Result<Receiver<Result<(), Error>>, Error>

Sends the provided message to the specified SocketAddr. Returns as soon as the message is queued to be sent, without waiting for the actual delivery; instead, the caller is provided with a oneshot::Receiver which can be used to determine when and whether the message has been delivered.