@decentnetwork/peer 0.1.37 → 0.1.39

package/dist/compat/tcp-relay-pool.d.ts

@@ -64,7 +64,7 @@ export declare class TcpRelayPool extends EventEmitter {
      * online. Returns the count of relays that accepted the write — 0 if
      * the friend isn't online on any TCP relay.
      */
-    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array): number;
+    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array, droppable?: boolean): number;
     /** Diagnostics. */
     connectedCount(): number;
     /**

package/dist/compat/tcp-relay-pool.js

@@ -173,7 +173,7 @@ export class TcpRelayPool extends EventEmitter {
      * online. Returns the count of relays that accepted the write — 0 if
      * the friend isn't online on any TCP relay.
      */
-    sendToFriend(friendPublicKey, payload) {
+    sendToFriend(friendPublicKey, payload, droppable = false) {
         if (friendPublicKey.length !== KEY_SIZE)
             return 0;
         // Send via the FIRST connected relay where the friend is online; only
@@ -191,7 +191,7 @@ export class TcpRelayPool extends EventEmitter {
                 continue;
             if (!r.client.hasFriendOnline(friendPublicKey))
                 continue;
-            if (r.client.sendToFriend(friendPublicKey, payload)) {
+            if (r.client.sendToFriend(friendPublicKey, payload, droppable)) {
                 return 1;
             }
         }

package/dist/compat/tcp-relay.d.ts

@@ -82,11 +82,11 @@ export declare class TcpRelayClient extends EventEmitter {
      * if the relay says they're offline. Caller should treat false as
      * "try another transport".
      */
-    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array): boolean;
+    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array, droppable?: boolean): boolean;
     /** Send a PING; relay echoes it as PONG. ping_id is opaque 8 bytes. */
     sendPing(): boolean;
     /** Send DATA payload to the friend at `connectionId`. */
-    sendData(connectionId: number, payload: Uint8Array): boolean;
+    sendData(connectionId: number, payload: Uint8Array, droppable?: boolean): boolean;
     /** Send OOB_SEND (used for delivering friend requests via TCP relay). */
     sendOob(receiverPublicKey: Uint8Array, payload: Uint8Array): boolean;
     close(reason?: string): void;

package/dist/compat/tcp-relay.js

@@ -37,6 +37,15 @@ import { incrementNonce } from "./net-crypto.js";
 const KEY_SIZE = 32;
 const NONCE_SIZE = 24;
 const MAC_SIZE = 16;
+// Max bytes we let pile up in the relay socket's write buffer before we start
+// DROPPING droppable (bulk IP) frames. Node's socket.write() buffers without
+// bound when the kernel send buffer is full, so a congested relay link would
+// otherwise queue SECONDS of IP packets — the multi-second bufferbloat behind
+// the snoopy/lili 13s pings. ~64KB is well under a second of queue even on a
+// slow transpacific relay; past it we behave like a real congested network and
+// drop, letting the inner protocol (TCP/QUIC) retransmit instead of delivering
+// stale packets late. Control frames (droppable=false) always go through.
+const RELAY_SEND_BUFFER_CAP = 64 * 1024;
 /** TCP_HANDSHAKE_PLAIN_SIZE in toxcore — temp pubkey + initial nonce. */
 const TCP_HANDSHAKE_PLAIN_SIZE = KEY_SIZE + NONCE_SIZE;
 /** Outbound handshake: self_dht_pk(32) + nonce(24) + box(plain)(KEY_SIZE+NONCE_SIZE+MAC_SIZE = 72) = 128. */
@@ -276,13 +285,18 @@ export class TcpRelayClient extends EventEmitter {
         return opened;
     }
     /** Encrypt a payload and write it as one framed packet. */
-    #sendFrame(payload) {
+    #sendFrame(payload, droppable = false) {
         if (this.#state !== "connected" || !this.#sessionKey || !this.#sentNonce || !this.#socket) {
             return false;
         }
         if (payload.length === 0 || payload.length > MAX_PACKET_SIZE - MAC_SIZE) {
             return false;
         }
+        // Bound the relay queue: drop bulk IP frames once the socket buffer is
+        // backed up rather than letting Node buffer seconds of packets (bufferbloat).
+        if (droppable && this.#socket.writableLength > RELAY_SEND_BUFFER_CAP) {
+            return false;
+        }
         const cipher = nacl.secretbox(payload, this.#sentNonce, this.#sessionKey);
         incrementNonce(this.#sentNonce);
         // Wire layout: [4-byte iveg][2-byte BE length][cipher].
@@ -418,13 +432,13 @@ export class TcpRelayClient extends EventEmitter {
      * if the relay says they're offline. Caller should treat false as
      * "try another transport".
      */
-    sendToFriend(friendPublicKey, payload) {
+    sendToFriend(friendPublicKey, payload, droppable = false) {
         if (friendPublicKey.length !== KEY_SIZE)
             return false;
         const cid = this.#cidByFriend.get(Buffer.from(friendPublicKey).toString("hex"));
         if (cid === undefined)
             return false;
-        return this.sendData(cid, payload);
+        return this.sendData(cid, payload, droppable);
     }
     /** Send a PING; relay echoes it as PONG. ping_id is opaque 8 bytes. */
     sendPing() {
@@ -432,12 +446,12 @@ export class TcpRelayClient extends EventEmitter {
         return this.#sendFrame(concatBytes([Uint8Array.of(TCP_PACKET_PING), pingId]));
     }
     /** Send DATA payload to the friend at `connectionId`. */
-    sendData(connectionId, payload) {
+    sendData(connectionId, payload, droppable = false) {
         if (connectionId < 16 || connectionId > 0xff)
             return false;
         if (payload.length === 0)
             return false;
-        return this.#sendFrame(concatBytes([Uint8Array.of(connectionId), payload]));
+        return this.#sendFrame(concatBytes([Uint8Array.of(connectionId), payload]), droppable);
     }
     /** Send OOB_SEND (used for delivering friend requests via TCP relay). */
     sendOob(receiverPublicKey, payload) {

package/dist/peer.js

@@ -2775,7 +2775,10 @@ export class Peer {
                 // would silently drop on iPad's side and leave the session
                 // looking healthy on our side while iPad never sees the
                 // packets.
-                const sent = this.#tcpRelays.sendToFriend(tcpKey, packet);
+                // Bulk IP data is droppable over the relay: under backpressure the
+                // relay client drops it (bounded queue) rather than buffering seconds
+                // of packets. Control frames pass isBulkData=false and always queue.
+                const sent = this.#tcpRelays.sendToFriend(tcpKey, packet, isBulkData);
                 if (sent > 0) {
                     tcpOk = true;
                 }
@@ -3055,7 +3058,7 @@ export class Peer {
         // "direct" option we advertise is our srflx (public) address, which the
         // NAT must hairpin back onto the LAN — most don't, so two machines in one
         // office silently fall back to the TURN relay (~260ms for a <1ms hop).
-        const lanIp = getLocalIpv4Addresses().find((ip) => isPrivateAddress(ip));
+        const lanIp = getPhysicalLanAddresses().find((ip) => isPrivateAddress(ip));
         const lanOctets = lanIp ? lanIp.split(".").map((s) => parseInt(s, 10)) : undefined;
         const lanPort = this.#udp.localPort() ?? 0;
         const lanValid = !!lanOctets && lanOctets.length === 4 && !lanOctets.some((o) => Number.isNaN(o)) && lanPort > 0;
@@ -3144,8 +3147,9 @@ export class Peer {
             const lanPort = ((payload[16] << 8) | payload[17]) >>> 0;
             const sameLan = lanPort !== 0 &&
                 isPrivateAddress(lanHost) &&
-                getLocalIpv4Subnets().some((s) => isInIpv4Subnet(lanHost, s)) &&
-                !(getLocalIpv4Addresses().includes(lanHost) && this.#udp.localPort() === lanPort);
+                !isCgnatAddress(lanHost) &&
+                getPhysicalLanSubnets().some((s) => isInIpv4Subnet(lanHost, s)) &&
+                !(getPhysicalLanAddresses().includes(lanHost) && this.#udp.localPort() === lanPort);
             if (sameLan) {
                 this.#rememberEndpointCandidate(session, lanHost, lanPort);
                 this.#debugLog(`udp-endpoint LAN candidate from ${friendId}: ${lanHost}:${lanPort} (same subnet) — punching`);
@@ -4430,6 +4434,72 @@ function isInIpv4Subnet(host, subnet) {
         return false;
     return ((ip & subnet.maskBits) >>> 0) === subnet.networkBits;
 }
+// Interface names that are VIRTUAL / overlay networks, not a physical LAN:
+// Tailscale & utun tunnels (utun* on macOS, tailscale*/tun* on Linux),
+// WireGuard (wg*), ZeroTier (zt*), the decentlan TUN itself (agentnet*), and
+// assorted macOS virtual links (awdl/llw/gif/stf/bridge). A LAN-direct host
+// candidate MUST be a physical-LAN address: advertising/punching an overlay
+// address (e.g. Tailscale 100.x, or our own 10.86.x mesh IP) sends the "direct"
+// path onto the overlay or loops into our own mesh, then silently falls back to
+// the relay — the snoopy/lili "lastUdpRecv=never -> bufferbloat" path. (lili
+// runs Tailscale; that's exactly this.)
+const VIRTUAL_IFACE_RE = /^(utun|tun|tap|wg|tailscale|zt|ham|agentnet|awdl|llw|gif|stf|bridge|vnic|vmnet|veth|docker)/i;
+/** True for RFC 6598 carrier-grade-NAT space 100.64.0.0/10 (Tailscale's range). */
+function isCgnatAddress(host) {
+    const o = host.split(".");
+    if (o.length !== 4)
+        return false;
+    const a = Number(o[0]);
+    const b = Number(o[1]);
+    return a === 100 && b >= 64 && b <= 127;
+}
+/** Local IPv4 addresses on PHYSICAL interfaces only (excludes overlay/virtual
+ *  interfaces by name and the CGNAT range). Used for LAN-direct host candidates. */
+function getPhysicalLanAddresses() {
+    const out = [];
+    try {
+        for (const [name, list] of Object.entries(networkInterfaces())) {
+            if (!list || VIRTUAL_IFACE_RE.test(name))
+                continue;
+            for (const info of list) {
+                if (info.family !== "IPv4" || info.internal)
+                    continue;
+                if (isCgnatAddress(info.address))
+                    continue;
+                out.push(info.address);
+            }
+        }
+    }
+    catch {
+        // best-effort
+    }
+    return out;
+}
+/** Subnets of PHYSICAL interfaces only — for matching a peer's host candidate
+ *  to OUR real LAN (so we never match a peer's Tailscale/TUN address against our
+ *  own overlay subnet). */
+function getPhysicalLanSubnets() {
+    const out = [];
+    try {
+        for (const [name, list] of Object.entries(networkInterfaces())) {
+            if (!list || VIRTUAL_IFACE_RE.test(name))
+                continue;
+            for (const info of list) {
+                if (info.family !== "IPv4" || info.internal || isCgnatAddress(info.address))
+                    continue;
+                const addr = ipv4ToInt(info.address);
+                const mask = netmaskToInt(info.netmask);
+                if (addr === undefined || mask === undefined || mask === 0)
+                    continue;
+                out.push({ networkBits: (addr & mask) >>> 0, maskBits: mask });
+            }
+        }
+    }
+    catch {
+        // best-effort
+    }
+    return out;
+}
 function isPrivateAddress(host) {
     // RFC1918 IPv4: 10/8, 172.16/12, 192.168/16; loopback 127/8;
     // link-local 169.254/16; carrier-grade NAT 100.64/10. IPv6 link-local fe80::/10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",