Struct LocalNode 

pub struct LocalNode<M>
where
    M: MacBackend,
{ /* private fields */ }

Per-identity application handle.

LocalNode owns its channel membership set via shared interior state. Different LocalNode instances (for different identities) may join different channel sets.

Implementations

impl<M> LocalNode<M>

where M: MacBackend,

pub fn identity_id(&self) -> LocalIdentityId

The identity slot this node operates on.

pub async fn peer( &self, key: PublicKey, ) -> Result<PeerConnection<LocalNode<M>>, NodeError<M>>

Create a peer connection (registers peer in MAC if new).

pub async fn remove_peer(&self, key: &PublicKey) -> bool

Remove a peer from the MAC and drop this node’s per-peer bookkeeping: outstanding pings and per-peer subscription tables. Returns whether the peer was registered in the MAC. Idempotent — removing an unknown peer still clears any node-layer residue and reports false.

pub async fn frame_counter(&self) -> Option<u32>

Return the live TX frame counter for this node’s identity, if available.

pub async fn persisted_frame_counter(&self) -> Option<u32>

Return the persisted TX frame-counter boundary for this node’s identity.

pub async fn for_each_peer(&self, f: &mut dyn FnMut(PublicKey))

Invoke f for every peer currently registered in the MAC-layer peer registry.

Covers all known peers, not just those with an active crypto session.

pub async fn for_each_peer_counter( &self, f: &mut dyn FnMut(PublicKey, u32, u32), )

Invoke f for each peer with established crypto state, passing the peer’s public key, last-accepted RX counter, and persisted RX boundary.

pub async fn peer_route(&self, peer: &PublicKey) -> Option<CachedRoute>

Return the route the MAC has cached for peer, if any.

A cached route is what the next send to this peer will use, so this is the state to inspect when traffic takes an unexpected path.

pub async fn clear_peer_route(&self, peer: &PublicKey) -> bool

Forget the route cached for peer, returning whether one was held.

Sends fall back to the default delivery mode until an inbound packet teaches a route again; the peer and its crypto state are untouched.

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

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

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

where F: FnMut(PublicKey, Option<&str>) + 'static,

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

where F: FnMut(NodeHint, Option<PublicKey>) + 'static,

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

where F: FnMut(PublicKey, &OwnedMacCommand) + 'static,

pub fn enable_identity_responder<P>( &self, profile: NodeIdentityProfile, policy: P, )

where P: FnMut(&IdentityRequestContext<'_>) -> RespondDecision + 'static,

Enable the built-in Identity Request responder with a custom respond policy.

The node will answer a matching Identity Request with an authenticated unicast identity response (see identity_responder). policy is the registerable discriminator invoked for each selected request; return [RespondDecision::Ignore] to decline. Replaces any previously enabled responder.

pub fn enable_identity_responder_default(&self, profile: NodeIdentityProfile)

Enable the Identity Request responder with the default_respond_policy.

pub fn disable_identity_responder(&self)

Disable the Identity Request responder, if enabled.

pub fn update_identity_profile(&self, f: impl FnOnce(&mut NodeIdentityProfile))

Update the live fields of the enabled responder’s identity profile (e.g. refresh location/altitude_m from a GPS fix). No-op if the responder is not enabled.

pub fn with_identity_profile<R>( &self, f: impl FnOnce(&NodeIdentityProfile) -> R, ) -> Option<R>

Read the enabled responder’s identity profile, returning None if the responder is not enabled.

The point of reading it rather than reconstructing it is that there is one statement of what this node is, and every framing of it — the Identity Request reply, a standalone signed advertisement, a local-control read — has to be that same statement.

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

where F: FnMut(&[u8]) + 'static,

Subscribe to raw on-wire bytes of every frame successfully handed to the radio.

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

where F: FnMut(PublicKey, SendToken) + 'static,

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

where F: FnMut(PublicKey, SendToken) + 'static,

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

where F: FnMut(PublicKey) + 'static,

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

where F: FnMut(PublicKey) + 'static,

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

where F: FnMut(PublicKey, PfsFailure) + 'static,

Subscribe to PFS negotiation failures for any peer. The handler is invoked with the peer’s long-term key and a coarse [PfsFailure] reason whenever a local PFS step (accepting a request, completing a response, or tearing down) fails — so a stalled negotiation reports a reason instead of silently doing nothing.

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

where F: FnMut(PublicKey, u64) + 'static,

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

where F: FnMut(PublicKey, &PongMetadata) + 'static,

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

where F: FnMut(PublicKey) + 'static,

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

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

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

pub async fn join( &self, channel: &Channel, ) -> Result<BoundChannel<M>, NodeError<M>>

Join a channel. Registers the channel key in the MAC if this is the first node to join it. Returns the bound channel handle.

pub async fn leave(&self, channel: &Channel) -> Result<(), NodeError<M>>

Leave a channel. Marks the membership entry inactive, bumps that entry’s generation counter, and unregisters the channel key from the MAC so inbound traffic on it is no longer decrypted.

pub fn bound_channel(&self, channel: &Channel) -> Option<BoundChannel<M>>

Get a handle to an already-joined channel.

pub fn bound_channels(&self) -> Vec<BoundChannel<M>>

List all joined channels.

Trait Implementations

impl<M> Clone for LocalNode<M>

where M: Clone + MacBackend,

fn clone(&self) -> LocalNode<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M> Transport for LocalNode<M>

where M: MacBackend,

type Error = NodeError<M>

async fn send( &self, to: &PublicKey, payload: &[u8], options: &SendOptions, ) -> Result<SendProgressTicket, <LocalNode<M> as Transport>::Error>

Send a payload to a specific destination.

async fn send_all( &self, payload: &[u8], options: &SendOptions, ) -> Result<SendProgressTicket, <LocalNode<M> as Transport>::Error>

Send a payload to all reachable nodes in this transport’s scope.