Struct PeerConnection 

pub struct PeerConnection<T>
where
    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> PeerConnection<T>

where T: Transport,

pub fn peer(&self) -> &PublicKey

The remote peer’s public key.

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

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

impl<M> PeerConnection<LocalNode<M>>

where M: MacBackend,

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.

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 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 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 for PeerConnection<T>

where T: Clone + Transport,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.