Struct smoldot_light::network_service::NetworkServiceChain

pub struct NetworkServiceChain<TPlat: PlatformRef> { /* private fields */ }

Implementations

impl<TPlat: PlatformRef> NetworkServiceChain<TPlat>

pub async fn subscribe(&self) -> Receiver<Event>

Subscribes to the networking events that happen on the given chain.

Calling this function returns a Receiver that receives events about the chain. The new channel will immediately receive events about all the existing connections, so that it is able to maintain a coherent view of the network.

Note that this function is async, but it should return very quickly.

The Receiver must be polled continuously. When the channel is full, the networking connections will be back-pressured until the channel isn’t full anymore.

The Receiver never yields None unless the NetworkService crashes or is destroyed. If None is yielded and the NetworkService is still alive, you should call NetworkServiceChain::subscribe again to obtain a new Receiver.

Panic

Panics if the given ChainId is invalid.

pub async fn ban_and_disconnect( &self, peer_id: PeerId, severity: BanSeverity, reason: &'static str, )

Starts asynchronously disconnecting the given peer. A Event::Disconnected will later be generated. Prevents a new gossip link with the same peer from being reopened for a little while.

reason is a human-readable string printed in the logs.

Due to race conditions, it is possible to reconnect to the peer soon after, in case the reconnection was already happening as the call to this function is still being processed. If that happens another Event::Disconnected will be delivered afterwards. In other words, this function guarantees that we will be disconnected in the future rather than guarantees that we will disconnect.

pub async fn blocks_request( self: Arc<Self>, target: PeerId, config: BlocksRequestConfig, timeout: Duration, ) -> Result<Vec<BlockData>, BlocksRequestError>

Sends a blocks request to the given peer.

pub async fn grandpa_warp_sync_request( self: Arc<Self>, target: PeerId, begin_hash: [u8; 32], timeout: Duration, ) -> Result<EncodedGrandpaWarpSyncResponse, WarpSyncRequestError>

Sends a grandpa warp sync request to the given peer.

pub async fn set_local_best_block(&self, best_hash: [u8; 32], best_number: u64)

pub async fn set_local_grandpa_state(&self, grandpa_state: GrandpaState)

pub async fn storage_proof_request( self: Arc<Self>, target: PeerId, config: StorageProofRequestConfig<impl Iterator<Item = impl AsRef<[u8]> + Clone>>, timeout: Duration, ) -> Result<EncodedMerkleProof, StorageProofRequestError>

Sends a storage proof request to the given peer.

pub async fn call_proof_request( self: Arc<Self>, target: PeerId, config: CallProofRequestConfig<'_, impl Iterator<Item = impl AsRef<[u8]>>>, timeout: Duration, ) -> Result<EncodedMerkleProof, CallProofRequestError>

Sends a call proof request to the given peer.

See also NetworkServiceChain::call_proof_request.

pub async fn announce_transaction( self: Arc<Self>, transaction: &[u8], ) -> Vec<PeerId>

Announces transaction to the peers we are connected to.

Returns a list of peers that we have sent the transaction to. Can return an empty Vec if we didn’t send the transaction to any peer.

Note that the remote doesn’t confirm that it has received the transaction. Because networking is inherently unreliable, successfully sending a transaction to a peer doesn’t necessarily mean that the remote has received it. In practice, however, the likelihood of a transaction not being received are extremely low. This can be considered as known flaw.

pub async fn send_block_announce( self: Arc<Self>, target: &PeerId, scale_encoded_header: &[u8], is_best: bool, ) -> Result<(), QueueNotificationError>

See service::ChainNetwork::gossip_send_block_announce.

pub async fn discover( &self, list: impl IntoIterator<Item = (PeerId, impl IntoIterator<Item = Multiaddr>)>, important_nodes: bool, )

Marks the given peers as belonging to the given chain, and adds some addresses to these peers to the address book.

The important_nodes parameter indicates whether these nodes are considered note-worthy and should have additional logging.

pub async fn discovered_nodes( &self, ) -> impl Iterator<Item = (PeerId, impl Iterator<Item = Multiaddr>)>

Returns a list of nodes (their PeerId and multiaddresses) that we know are part of the network.

Nodes that are discovered might disappear over time. In other words, there is no guarantee that a node that has been added through NetworkServiceChain::discover will later be returned by NetworkServiceChain::discovered_nodes.

pub async fn peers_list(&self) -> impl Iterator<Item = PeerId>

Returns an iterator to the list of PeerIds that we have an established connection with.