@decentnetwork/peer 0.1.121 → 0.1.123

package/dist/peer.d.ts

@@ -307,4 +307,27 @@ export declare class Peer {
         name: string;
         description: string;
     };
+    /**
+     * Tell a friend our public UDP endpoint over the (already-working,
+     * possibly tcp-relay) messenger channel, so they can hole-punch to us.
+     * This is the out-of-band substitute for the broken DHT/onion-announce
+     * endpoint discovery. Both peers do this symmetrically; on receipt each
+     * feeds the other's endpoint into endpointCandidates and punches.
+     */
+    /**
+     * Lazily allocate our node-level TURN relay on its own dedicated UDP
+     * socket. Returns our public relay address (on the TURN server) which we
+     * advertise to peers so they can reach us via the relay even when direct
+     * UDP can't be punched. Relayed data is injected into #onDatagram tagged
+     * `viaRelay` so it updates the relay freshness, not the direct endpoint.
+     */
+    /**
+     * Test-only seam for scripts/turn-socket-leak-selftest.mjs: drive one TURN
+     * allocation attempt directly instead of waiting out the 120s-per-friend
+     * relay keepalive that reaches this path in production. Not public API.
+     */
+    __testForceTurnAllocation(): Promise<{
+        host: string;
+        port: number;
+    } | undefined>;
 }

package/dist/peer.js

@@ -23,14 +23,35 @@ import { UdpTransport } from "./transport/udp.js";
 import { bytesToHex, concatBytes, randomBytes } from "./utils/bytes.js";
 import { buildBindingRequest, decodeStun, decodeXorMappedAddress, findAttr, STUN_ATTR_XOR_MAPPED_ADDRESS, STUN_BINDING_SUCCESS } from "./stun.js";
 import { TurnClient } from "./turn.js";
-import { createSocket as createDgramSocket } from "dgram";
+import { createBoundUdp4Socket, closeDgramSocket } from "./transport/dgram-lifecycle.js";
 // Dedicated TURN relay servers — fixed public relays used as a stable
 // fallback path when direct UDP hole-punch fails or flaps (symmetric NAT,
 // NAT remaps, lossy direct path). A relay endpoint never NAT-flaps, so the
 // path stays put even when the peers' NATs churn. Static long-term creds.
-const TURN_RELAY_SERVERS = [
-    { host: "tokyo.fi.chat", port: 3478, username: "allcom", password: "allcompass" }
-];
+// DECENT_TURN_SERVERS overrides the list ("host:port,host:port"). Used by the
+// socket-leak selftest to point allocation at an unroutable address so every
+// attempt fails deterministically; also lets ops repoint TURN without a build.
+const TURN_RELAY_SERVERS = (() => {
+    const raw = process.env.DECENT_TURN_SERVERS?.trim();
+    if (!raw) {
+        return [{ host: "tokyo.fi.chat", port: 3478, username: "allcom", password: "allcompass" }];
+    }
+    return raw
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map((entry) => {
+        const idx = entry.lastIndexOf(":");
+        const host = idx === -1 ? entry : entry.slice(0, idx);
+        const port = idx === -1 ? 3478 : Number.parseInt(entry.slice(idx + 1), 10);
+        return {
+            host,
+            port: Number.isFinite(port) && port > 0 ? port : 3478,
+            username: "allcom",
+            password: "allcompass"
+        };
+    });
+})();
 const ANNOUNCE_WAIT_TIMEOUT_MS = readEnvInt("DECENT_ANNOUNCE_WAIT_TIMEOUT_MS", 4000);
 // 24 (was 12): with distance-ordered walking a lookup needs headroom to
 // recurse past a first wave of dead close-in-XOR-space entries.
@@ -60,7 +81,10 @@ const DHT_MAINTENANCE_INTERVAL_MS = readEnvInt("DECENT_DHT_MAINTENANCE_INTERVAL_
 // distance-sort it feeds) without limit — which starved CCTV forwarding over time.
 const MAX_KNOWN_NODES = readEnvInt("DECENT_MAX_KNOWN_NODES", 400);
 const MAX_SELF_ANNOUNCE_TARGETS = readEnvInt("DECENT_SELF_ANNOUNCE_TARGETS", 16);
-const SELF_ANNOUNCE_ATTEMPTS = readEnvInt("DECENT_SELF_ANNOUNCE_ATTEMPTS", 3);
+// 1 (was 3): a dead node cost attempts×ANNOUNCE_WAIT = 12s — one wave of
+// dead nodes ate the entire per-cycle deadline, so the walk never got past
+// wave 1 and stored on ~1 node per DAY. The 12s cycle itself is the retry.
+const SELF_ANNOUNCE_ATTEMPTS = readEnvInt("DECENT_SELF_ANNOUNCE_ATTEMPTS", 1);
 // Self-announce batch size — number of step1 / step2 requests to fan out
 // at once. Toxcore's onion_client.c::do_announce keeps up to
 // MAX_ONION_CLIENTS_ANNOUNCE (12) in flight. Configurable via env.
@@ -733,13 +757,8 @@ export class Peer {
         this.#udp.off("datagram", this.#onDatagram);
         await this.#udp.stop();
         // Release the TURN allocation + its dedicated socket.
-        try {
-            this.#turnClient?.close();
-            this.#turnSocket?.close();
-        }
-        catch {
-            // best-effort
-        }
+        this.#turnClient?.close();
+        await closeDgramSocket(this.#turnSocket);
         this.#turnClient = undefined;
         this.#turnSocket = undefined;
         this.#ourRelayAddr = undefined;
@@ -4762,6 +4781,14 @@ export class Peer {
      * UDP can't be punched. Relayed data is injected into #onDatagram tagged
      * `viaRelay` so it updates the relay freshness, not the direct endpoint.
      */
+    /**
+     * Test-only seam for scripts/turn-socket-leak-selftest.mjs: drive one TURN
+     * allocation attempt directly instead of waiting out the 120s-per-friend
+     * relay keepalive that reaches this path in production. Not public API.
+     */
+    async __testForceTurnAllocation() {
+        return this.#ensureTurnRelay().catch(() => undefined);
+    }
     async #ensureTurnRelay() {
         if (this.#ourRelayAddr)
             return this.#ourRelayAddr;
@@ -4769,15 +4796,10 @@ export class Peer {
             return this.#turnAllocating;
         this.#turnAllocating = (async () => {
             for (const srv of TURN_RELAY_SERVERS) {
+                let sock;
+                let client;
                 try {
-                    const sock = createDgramSocket("udp4");
-                    await new Promise((resolve, reject) => {
-                        sock.once("error", reject);
-                        sock.bind(0, () => {
-                            sock.off("error", reject);
-                            resolve();
-                        });
-                    });
+                    sock = await createBoundUdp4Socket();
                     // CRITICAL: a persistent 'error' listener. A TURN send to an
                     // unresolvable host (DNS NXDOMAIN — e.g. tokyo.fi.chat on a box whose
                     // resolver doesn't know it) emits an 'error' on this dgram socket;
@@ -4786,7 +4808,7 @@ export class Peer {
                     // "getaddrinfo ENOTFOUND tokyo.fi.chat", which churned every session).
                     // Swallow it — the relay simply won't allocate/relay over this server.
                     sock.on("error", (e) => this.#debugLog(`turn socket error (${srv.host}): ${e.message}`));
-                    const client = new TurnClient({
+                    client = new TurnClient({
                         sock,
                         creds: { host: srv.host, port: srv.port, realm: "", username: srv.username, password: srv.password }
                     });
@@ -4802,12 +4824,16 @@ export class Peer {
                     });
                     this.#turnSocket = sock;
                     this.#turnClient = client;
+                    sock = undefined;
+                    client = undefined;
                     this.#ourRelayAddr = { host: alloc.relayedAddress.address, port: alloc.relayedAddress.port };
                     this.#debugLog(`turn relay allocated on ${srv.host}: ${this.#ourRelayAddr.host}:${this.#ourRelayAddr.port}`);
                     return this.#ourRelayAddr;
                 }
                 catch (error) {
                     this.#debugLog(`turn relay allocate failed on ${srv.host}: ${error.message}`);
+                    client?.close();
+                    await closeDgramSocket(sock);
                 }
             }
             return undefined;

package/dist/transport/dgram-lifecycle.d.ts

@@ -0,0 +1,14 @@
+import { type Socket as DgramSocket } from "dgram";
+export type DgramSocketFactory = () => DgramSocket;
+export declare function createBoundUdp4Socket(createSocket?: DgramSocketFactory): Promise<DgramSocket>;
+/**
+ * Close a dgram socket and wait for the fd to actually be released.
+ *
+ * Never rejects and never hangs: `close()` throws ERR_SOCKET_DGRAM_NOT_RUNNING
+ * on an already-closed socket, and a socket caught mid-teardown may never run
+ * the close callback at all. Both must settle, because callers await this on
+ * the TURN failure path — a hang there would leave `#turnAllocating` pending
+ * forever and wedge every later caller awaiting that same promise, and would
+ * also block `Peer.stop()`.
+ */
+export declare function closeDgramSocket(sock: DgramSocket | undefined, timeoutMs?: number): Promise<void>;

package/dist/transport/dgram-lifecycle.js

@@ -0,0 +1,64 @@
+import { createSocket as createDgramSocket } from "dgram";
+export async function createBoundUdp4Socket(createSocket = () => createDgramSocket("udp4")) {
+    const sock = createSocket();
+    try {
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                sock.off("error", onError);
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            sock.once("error", onError);
+            sock.bind(0, () => {
+                cleanup();
+                resolve();
+            });
+        });
+        return sock;
+    }
+    catch (error) {
+        await closeDgramSocket(sock);
+        throw error;
+    }
+}
+/**
+ * Close a dgram socket and wait for the fd to actually be released.
+ *
+ * Never rejects and never hangs: `close()` throws ERR_SOCKET_DGRAM_NOT_RUNNING
+ * on an already-closed socket, and a socket caught mid-teardown may never run
+ * the close callback at all. Both must settle, because callers await this on
+ * the TURN failure path — a hang there would leave `#turnAllocating` pending
+ * forever and wedge every later caller awaiting that same promise, and would
+ * also block `Peer.stop()`.
+ */
+export async function closeDgramSocket(sock, timeoutMs = 2000) {
+    if (!sock)
+        return;
+    await new Promise((resolve) => {
+        let done = false;
+        let timer;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            if (timer)
+                clearTimeout(timer);
+            sock.off("close", finish);
+            resolve();
+        };
+        // Belt and braces: the callback, the 'close' event, or the timer —
+        // whichever comes first releases the caller.
+        timer = setTimeout(finish, timeoutMs);
+        // Don't keep the event loop alive just to observe a close.
+        timer.unref?.();
+        try {
+            sock.once("close", finish);
+            sock.close(finish);
+        }
+        catch {
+            finish();
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.121",
+  "version": "0.1.123",
   "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",