Struct SocialWebNet 

pub struct SocialWebNet { /* private fields */ }

The node’s managed WireGuard mesh: a set of peer tunnels sharing this node’s static keypair.

Implementations

impl SocialWebNet

pub fn new( keys: WgKeypair, bind_ip: IpAddr, read_timeout: Option<Duration>, ) -> SocialWebNet

Create an empty mesh for this node. bind_ip is where per-peer sockets bind (e.g. 0.0.0.0 / :: in production, 127.0.0.1 in tests); read_timeout bounds each pump so a quiet peer does not stall the loop.

pub fn public_key_hex(&self) -> String

This node’s WireGuard public key as lowercase hex — what peers need to address it.

pub fn peers(&self) -> Vec<String>

The peer ids currently in the mesh.

pub fn add_peer( &mut self, peer_id: &str, peer_pubkey_hex: &str, endpoint: Option<SocketAddr>, ) -> Result<SocketAddr, String>

Add a peer to the mesh: bind a fresh socket and build its tunnel.

peer_pubkey_hex is the peer’s WireGuard public key (64 hex chars — as stored on a SocialPeer / carried in a ConnectionIdentifier). endpoint is where to send to if already known (else None, and it is learned by roaming from the first authenticated packet). Returns the local socket address bound for this peer, so the caller can advertise it back through the coordination plane. Idempotent-ish: adding an existing peer id replaces its tunnel (a fresh socket + handshake state).

pub fn remove_peer(&mut self, peer_id: &str) -> bool

Remove a peer and drop its tunnel/socket. Returns whether the peer was present.

pub fn local_addr(&self, peer_id: &str) -> Option<SocketAddr>

The local socket address bound for a peer, if present.

pub fn set_peer_endpoint( &mut self, peer_id: &str, addr: SocketAddr, ) -> Result<(), String>

Point a peer’s tunnel at addr (e.g. once its endpoint is learned from the coordination plane).

pub fn has_session(&self, peer_id: &str) -> bool

Whether a live WireGuard session exists with a peer.

pub fn initiate_handshake(&mut self, peer_id: &str) -> Result<(), String>

Start the handshake with a peer (initiator side). Requires the peer’s endpoint to be set.

pub fn send_to(&mut self, peer_id: &str, inner: &[u8]) -> Result<bool, String>

Encrypt and send one inner IPv6 packet to a peer. See WgTunnel::send_packet for the pre-session behaviour (a handshake init is sent and the caller retries once established).

pub fn send_datagram( &mut self, peer_id: &str, src_port: u16, dst_port: u16, payload: &[u8], ) -> Result<bool, String>

Frame payload as an overlay IPv6/UDP datagram addressed to dst_port (from src_port) and send it to a peer. This is the application-message path over the mesh: the receiver recovers (src_port, dst_port, payload) with mesh_datagram::decode_datagram on the MeshPacket::inner it pumps. See super::mesh_datagram::ports for well-known ports.

pub fn pump(&mut self, peer_id: &str) -> Result<TunnelEvent, String>

Pump one datagram for a single peer. See WgTunnel::pump.

pub fn pump_all(&mut self) -> Vec<Result<MeshPacket, (String, String)>>

Pump every peer once, returning any decrypted inner packets (tagged by peer). Control-only traffic and idle sockets produce nothing. A per-peer error is surfaced against that peer id rather than aborting the whole sweep.

pub fn tick_all(&mut self) -> Vec<(String, String)>

Drive WireGuard timers for every peer once (call ~1 Hz). Per-peer errors are collected, not fatal.