Struct P2PNode

Source

pub struct P2PNode { /* private fields */ }

Expand description

Main P2P network node that manages connections, routing, and communication

This struct represents a complete P2P network participant that can:

Connect to other peers via QUIC transport
Participate in distributed hash table (DHT) operations
Send and receive messages through various protocols
Handle network events and peer lifecycle

Transport concerns (connections, messaging, events) are delegated to TransportHandle.

Implementations§

Source §

impl P2PNode

Source

pub async fn new(config: NodeConfig) -> Result<Self, P2PError>

Create a new P2P node with the given configuration

Source

pub fn peer_id(&self) -> &PeerId

Get the peer ID of this node.

Source

pub fn transport(&self) -> &Arc<TransportHandle>

Get the transport handle for sharing with other components.

Source

pub fn local_addr(&self) -> Option<MultiAddr>

Source

pub fn is_bootstrapped(&self) -> bool

Check if the node has completed the initial bootstrap process

Returns true if the node has successfully connected to at least one bootstrap peer and performed peer discovery (FIND_NODE).

Source

pub async fn re_bootstrap(&self) -> Result<(), P2PError>

Manually trigger re-bootstrap (useful for recovery or network rejoin)

This clears the bootstrapped state and attempts to reconnect to bootstrap peers and discover new peers.

Source

pub fn trust_engine(&self) -> Arc<TrustEngine>

Get the trust engine for advanced use cases

Source

pub async fn report_trust_event(&self, peer_id: &PeerId, event: TrustEvent)

Report a trust event for a peer.

Records a network-observable outcome (connection success/failure) that the DHT layer did not record automatically. See TrustEvent for the supported variants.

§Example

use saorsa_core::adaptive::TrustEvent;

node.report_trust_event(&peer_id, TrustEvent::SuccessfulResponse).await;
node.report_trust_event(&peer_id, TrustEvent::ConnectionFailed).await;

Source

pub fn peer_trust(&self, peer_id: &PeerId) -> f64

Get the current trust score for a peer (0.0 to 1.0).

Returns 0.5 (neutral) for unknown peers.

Source

pub fn adaptive_dht(&self) -> &AdaptiveDHT

Get the AdaptiveDHT component for direct access

Source

pub async fn send_request( &self, peer_id: &PeerId, protocol: &str, data: Vec<u8>, timeout: Duration, ) -> Result<PeerResponse, P2PError>

Send a request to a peer and wait for a response with automatic trust reporting.

Unlike fire-and-forget send_message(), this method:

Wraps the payload in a RequestResponseEnvelope with a unique message ID
Sends it on the /rr/<protocol> protocol prefix
Waits for a matching response (or timeout)
Automatically reports success or failure to the trust engine

The remote peer’s handler should call send_response() with the incoming message ID to route the response back.

§Arguments

peer_id - Target peer
protocol - Application protocol name (e.g. "peer_info")
data - Request payload bytes
timeout - Maximum time to wait for a response

§Returns

A [PeerResponse] on success, or an error on timeout / connection failure.

§Example

let response = node.send_request(&peer_id, "peer_info", request_data, Duration::from_secs(10)).await?;
println!("Got {} bytes from {}", response.data.len(), response.peer_id);

Source

pub async fn send_response( &self, peer_id: &PeerId, protocol: &str, message_id: &str, data: Vec<u8>, ) -> Result<(), P2PError>

Source

pub fn parse_request_envelope(data: &[u8]) -> Option<(String, bool, Vec<u8>)>

Source

pub async fn publish(&self, topic: &str, data: &[u8]) -> Result<(), P2PError>

Source

pub fn config(&self) -> &NodeConfig

Get the node configuration

Source

pub async fn start(&self) -> Result<(), P2PError>

Start the P2P node

Source

pub async fn run(&self) -> Result<(), P2PError>

Run the P2P node (blocks until shutdown)

Source

pub async fn stop(&self) -> Result<(), P2PError>

Stop the P2P node

Source

pub async fn shutdown(&self) -> Result<(), P2PError>

Graceful shutdown alias for tests

Source

pub fn is_running(&self) -> bool

Check if the node is running

Source

pub async fn listen_addrs(&self) -> Vec<MultiAddr>

Get the current listen addresses

Source

pub async fn connected_peers(&self) -> Vec<PeerId>

Get connected peers

Source

pub async fn peer_count(&self) -> usize

Get peer count

Source

pub async fn peer_info(&self, peer_id: &PeerId) -> Option<PeerInfo>

Get peer info

Source

pub async fn is_peer_connected(&self, peer_id: &PeerId) -> bool

Check if an authenticated peer is connected (has at least one active channel).

Source

pub async fn connect_peer( &self, address: &MultiAddr, ) -> Result<String, P2PError>

Connect to a peer, returning the transport-level channel ID.

The returned channel ID is not the app-level PeerId. To obtain the authenticated peer identity, call wait_for_peer_identity with the returned channel ID.

Source

pub async fn wait_for_peer_identity( &self, channel_id: &str, timeout: Duration, ) -> Result<PeerId, P2PError>

Wait for the identity exchange on channel_id to complete, returning the authenticated PeerId.

Use this after connect_peer to bridge the gap between the transport-level channel ID and the app-level peer identity required by send_message.

Source

pub async fn disconnect_peer(&self, peer_id: &PeerId) -> Result<(), P2PError>

Disconnect from a peer

Source

pub async fn send_message( &self, peer_id: &PeerId, protocol: &str, data: Vec<u8>, addrs: &[MultiAddr], ) -> Result<(), P2PError>

Send a message to an authenticated peer, reconnecting on demand.

Tries the existing connection first. If the send fails (stale QUIC session, peer not found, etc.), resolves a dial address from:

Caller-provided addrs (highest priority)
Addresses cached in the transport layer (snapshotted before the send attempt, since stale-channel cleanup removes them)
DHT routing table

Then dials, waits for identity exchange, and retries the send exactly once on the fresh connection. Concurrent reconnects to the same peer are serialised so only one dial is attempted at a time.

Source §