Struct MeshRouter 

pub struct MeshRouter<R: SignalingTransport, F: PeerLinkFactory> { /* private fields */ }

Mesh router handles peer discovery and negotiated link establishment.

This is the shared routing logic between production transports and simulation. It uses traits for signaling transport and negotiated link factories so the same router can drive Nostr websockets, LAN buses, BLE, WebRTC, or mocks.

Uses the standard concurrent-offer “perfect negotiation” pattern:

• Both peers can send offers when they discover each other
• On collision (both sent offers), “polite” peer backs off and accepts incoming
• This ensures connections form even when one peer is satisfied but can accept

Implementations

impl<R: SignalingTransport + 'static, F: PeerLinkFactory + 'static> MeshRouter<R, F>

pub fn new( peer_id: String, transport: Arc<R>, conn_factory: Arc<F>, pools: PoolSettings, debug: bool, ) -> Self

Create a new mesh router.

pub fn set_classifier(&mut self, tx: Sender<ClassifyRequest>)

Set classifier for peer pool assignment

pub fn peer_id(&self) -> &str

Get our peer ID

pub async fn send_hello(&self, roots: Vec<String>) -> Result<(), TransportError>

Send hello broadcast

pub async fn handle_message( &self, msg: SignalingMessage, ) -> Result<(), TransportError>

Handle incoming signaling message

This is the core signaling logic shared between production and simulation.

pub async fn peer_count(&self) -> usize

Get connected peer count

pub async fn peer_ids(&self) -> Vec<String>

Get peer IDs

pub async fn get_channel(&self, peer_id: &str) -> Option<Arc<dyn PeerLink>>

Get a peer’s channel

pub async fn remove_peer(&self, peer_id: &str) -> Option<Arc<dyn PeerLink>>

Remove a peer and any pending offer state.

pub async fn needs_peers(&self) -> bool

Check if we need more peers (below satisfied in any pool)

pub async fn can_accept(&self) -> bool

Check if we can accept more peers (below max in any pool)