Struct FipsEndpoint 

pub struct FipsEndpoint { /* private fields */ }

A running embedded FIPS endpoint.

Implementations

impl FipsEndpoint

pub fn builder() -> FipsEndpointBuilder

Create a builder for an embedded endpoint.

pub fn npub(&self) -> &str

Local endpoint npub.

pub fn node_addr(&self) -> &NodeAddr

Local FIPS node address.

pub fn address(&self) -> FipsAddress

Local FIPS IPv6-compatible address.

pub fn discovery_scope(&self) -> Option<&str>

Application-level discovery scope, if configured.

pub async fn send_batch_to_peer( &self, remote: PeerIdentity, payloads: Vec<Vec<u8>>, ) -> Result<(), FipsEndpointError>

Send application-owned endpoint payloads to one resolved peer.

This is the canonical endpoint-data send path for applications that already validate and cache peer identities in their own routing table. It avoids per-packet npub allocation, endpoint cache lookup, and PeerIdentity::from_npub parsing while preserving owned-payload semantics.

pub async fn recv_batch_into( &self, messages: &mut Vec<FipsEndpointMessage>, max: usize, ) -> Option<usize>

Receive one endpoint message, then drain ready follow-ons into a caller-owned buffer.

This is the receive-side counterpart to Self::send_batch_to_peer: callers still get individual source-attributed messages, but a hot dataplane consumer can amortize the endpoint receiver lock, task wake, and message buffer allocation across a bounded burst.

pub fn blocking_send_batch_to_peer( &self, remote: PeerIdentity, payloads: Vec<Vec<u8>>, ) -> Result<(), FipsEndpointError>

Synchronous blocking batch send to one resolved remote identity.

This is the blocking-thread counterpart to Self::send_batch_to_peer. The caller keeps routing authority: FIPS only receives already-owned endpoint payloads for the resolved peer.

pub fn blocking_recv_batch_into( &self, messages: &mut Vec<FipsEndpointMessage>, max: usize, ) -> Option<usize>

Synchronous blocking batch receive into a caller-owned buffer.

This is the blocking-thread counterpart to Self::recv_batch_into: it parks the calling OS thread for the first message, then drains ready follow-ons while holding the endpoint receiver lock. MUST NOT be called from inside a tokio runtime; use this only from a dedicated blocking thread.

pub async fn update_peers( &self, peers: Vec<PeerConfig>, ) -> Result<UpdatePeersOutcome, FipsEndpointError>

Replace the runtime peer list. Newly added auto-connect peers get dialed immediately using every known address (overlay-fresh first, then operator/cache hints). Removed peers are dropped from the retry queue but stay connected if they currently are — the regular liveness timeout reaps idle sessions. Existing entries get their addresses field refreshed so the next retry sees the latest hints.

Pass an empty addresses vector for a peer if you want fips to resolve them entirely from the Nostr advert at dial time.

pub async fn refresh_peer_paths( &self, peers: Vec<PeerIdentity>, ) -> Result<usize, FipsEndpointError>

Force immediate direct-path refresh attempts for configured peers.

Unlike FipsEndpoint::update_peers, this does not require a config diff. It asks the running node to race a fresh direct handshake for the supplied active peers while preserving existing sessions and routes.

pub async fn peers(&self) -> Result<Vec<FipsEndpointPeer>, FipsEndpointError>

Snapshot authenticated peers known by the endpoint.

pub async fn local_advertised_endpoints( &self, ) -> Result<Vec<OverlayEndpointAdvert>, FipsEndpointError>

Snapshot the endpoint addresses this node is currently advertising via Nostr discovery.

pub async fn relay_statuses( &self, ) -> Result<Vec<FipsEndpointRelayStatus>, FipsEndpointError>

Snapshot live Nostr relay states used by the embedded endpoint.

pub async fn update_relays( &self, advert_relays: Vec<String>, dm_relays: Vec<String>, ) -> Result<(), FipsEndpointError>

Replace Nostr discovery relays without rebuilding the endpoint.

pub async fn send_ip_packet( &self, packet: impl Into<Vec<u8>>, ) -> Result<(), FipsEndpointError>

Send an outbound IPv6 packet into the FIPS session pipeline.

pub async fn recv_ip_packet(&self) -> Option<NodeDeliveredPacket>

Receive the next source-attributed IPv6 packet delivered by FIPS.

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

Shut down the endpoint and wait for the node task to stop.

Trait Implementations

impl Drop for FipsEndpoint

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.