Struct PeerConnection 

pub struct PeerConnection<T: Transport> { /* private fields */ }

Relationship with one remote peer, bound to a transport context.

Generic over T: Transport — works with LocalNode (unicast) or BoundChannel (blind unicast) identically.

Implementations

impl<T: Transport> PeerConnection<T>

pub fn peer(&self) -> &PublicKey

The remote peer’s public key.

pub async fn send( &self, payload: &[u8], options: &SendOptions, ) -> Result<SendProgressTicket, T::Error>

Send a raw payload to this peer (delegates to transport.send()).

impl<M, T> PeerConnection<T>

where M: MacBackend, T: Transport<Error = NodeError<M>> + NodeAccess<Backend = M>,

Everything a peer relationship needs from the node behind its transport.

Implemented once for both carriages: a peer reached through a channel gets the same pings, subscriptions, and identity requests as one reached by plain unicast, and each frame goes out over the transport it was built on.

pub fn on_receive<F>(&self, handler: F) -> Subscription

where F: FnMut(&ReceivedPacketRef<'_>) -> bool + 'static,

pub fn on_ack_received<F>(&self, handler: F) -> Subscription

where F: FnMut(SendToken) + 'static,

pub fn on_ack_timeout<F>(&self, handler: F) -> Subscription

where F: FnMut(SendToken) + 'static,

pub fn on_pfs_established<F>(&self, handler: F) -> Subscription

where F: FnMut() + 'static,

pub fn on_pfs_ended<F>(&self, handler: F) -> Subscription

where F: FnMut() + 'static,

pub fn on_pong<F>(&self, handler: F) -> Subscription

where F: FnMut(u64) + 'static,

pub fn on_ping_timeout<F>(&self, handler: F) -> Subscription

where F: FnMut() + 'static,

pub async fn ping( &self, extra_bytes: usize, options: &SendOptions, timeout_ms: u64, ) -> Result<SendProgressTicket, NodeError<M>>

Send an echo request and record it as pending until the matching echo response arrives or timeout_ms elapses.

options is honoured as given, so a ping travels the same way the traffic it is measuring would: same MIC size, same encryption, same routing and region options. Only ack_requested is overridden — the echo response is the acknowledgement, so asking for a MAC ack as well would put a second frame on the air for nothing.

extra_bytes pads the payload beyond the 2-byte nonce. Padding matters for the same reason the MIC size does: packet error rate rises with frame length, so a minimal ping reports a link as usable when a full-size message would not get through. See PING_MIC_SIZE for the MIC size callers should normally ask for.

The padding is bounded by what one frame can carry, not by this call: a ping too large to build fails with the MAC’s own send error rather than being quietly shortened into a measurement of a smaller frame.

pub async fn request_identity( &self, options: &SendOptions, ) -> Result<SendProgressTicket, NodeError<M>>

Solicit this peer’s current identity by sending a targeted MAC Identity Request (command 1). Because the request is a unicast to a specific peer, no filter options are needed — filters exist only to narrow a broadcast solicitation. A random NONCE is included so the peer echoes it in its identity response, matching the responder’s correlation contract.

The response arrives asynchronously as a PayloadType::NodeIdentity frame on the normal receive path, not as the return value here.

pub async fn request_peer_repeaters( &self, nonce: u16, cursor: Option<&[u8]>, options: &SendOptions, ) -> Result<SendProgressTicket, NodeError<M>>

Ask this peer for one page of its known peer repeaters (command 10).

nonce is echoed in the response, which is what tells one page’s answer from a stale copy of an earlier one. cursor resumes an enumeration from where a previous response said to; pass None for the first page, and expect a Total on the answer to that one.

The response arrives asynchronously as a MAC command on the normal receive path, not as the return value here.

pub async fn route(&self) -> Option<CachedRoute>

The route the MAC has cached for this peer, if any.

pub async fn clear_route(&self) -> bool

Forget this peer’s cached route, returning whether one was held.

pub async fn restore_route(&self, route: CachedRoute) -> bool

Install a route learned before this MAC existed, returning whether it could be installed.

impl<M: MacBackend> PeerConnection<LocalNode<M>>

Forward secrecy is negotiated between two nodes, not inside a channel: the session it establishes replaces the pairwise keys a unicast is sealed with. These stay on the plain-unicast transport.

pub async fn request_pfs( &self, duration_minutes: u16, options: &SendOptions, ) -> Result<SendProgressTicket, NodeError<M>>

pub async fn end_pfs(&self, options: &SendOptions) -> Result<(), NodeError<M>>

pub async fn pfs_status(&self) -> Result<PfsStatus, NodeError<M>>

Trait Implementations

impl<T: Clone + Transport> Clone for PeerConnection<T>

fn clone(&self) -> PeerConnection<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.