@decentnetwork/peer 0.1.3 → 0.1.5

package/dist/peer.d.ts

@@ -71,6 +71,28 @@ export declare class Peer {
         hasTcpRoute: boolean;
         transport: "udp" | "tcp-relay" | "both" | "none";
         lastPingRecvMs: number | null;
+        /** OS-assigned UDP port THIS node is listening on. Useful to confirm
+         *  we even have a UDP socket bound. */
+        ourLocalUdpPort: number | null;
+        /** Cached UDP endpoint for the peer from a previous online state
+         *  (persisted across restarts). Set != null means UDP holepunch
+         *  has succeeded at some point — but null when we've only ever
+         *  reached them via TCP-relay. Tells us whether discovery has
+         *  ever found a usable UDP endpoint. */
+        friendUdpEndpoint: {
+            host: string;
+            port: number;
+        } | null;
+        /** UDP endpoints picked up by recent DHT discovery for this peer,
+         *  whether or not the cookie exchange has succeeded yet. If this
+         *  is empty AND friendUdpEndpoint is null AND we keep getting
+         *  tcp-relay, discovery itself is broken — we don't even know
+         *  where to send a cookie request. */
+        endpointCandidatesCount: number;
+        /** Last time we sent an outbound cookie request via UDP for this
+         *  peer (null = never). Used to confirm Phase 1.2 retries are
+         *  actually firing. */
+        cookieRequestSentMs: number | null;
     } | null;
     waitForFriendRequest(timeoutMs?: number): Promise<FriendRequest>;
 }

package/dist/peer.js

@@ -772,6 +772,7 @@ export class Peer {
         const s = this.#friendSessions.get(pubkey);
         if (!s)
             return null;
+        const friend = this.#friends.get(pubkey);
         // session.remote can be a synthetic `tcp:<dhtpk>:0` placeholder
         // when the TCP relay path reports an endpoint with no real UDP
         // address; treat those as no-UDP for reporting.
@@ -785,12 +786,22 @@ export class Peer {
             : s.hasTcpRoute
                 ? "tcp-relay"
                 : "none";
+        const friendUdp = friend?.remoteHost &&
+            friend.remotePort &&
+            !friend.remoteHost.startsWith("tcp:") &&
+            friend.remotePort !== 0
+            ? { host: friend.remoteHost, port: friend.remotePort }
+            : null;
         return {
             established: s.established === true,
             udpRemote: realUdp,
             hasTcpRoute: s.hasTcpRoute === true,
             transport,
             lastPingRecvMs: s.lastPingRecvMs ?? null,
+            ourLocalUdpPort: this.#udp?.localPort() ?? null,
+            friendUdpEndpoint: friendUdp,
+            endpointCandidatesCount: s.endpointCandidates?.length ?? 0,
+            cookieRequestSentMs: s.cookieRequestSentMs ?? null,
         };
     }
     waitForFriendRequest(timeoutMs = 30000) {
@@ -2777,10 +2788,73 @@ export class Peer {
         // residential ISPs where self-announce doesn't propagate).
         // Mirrors toxcore's send_dht_pk_packet which calls
         // tcp_copy_connected_relays to fill extras.
-        let extras = new Uint8Array(0);
+        // Also pack OUR OWN UDP endpoint(s) as extras (family 0x02 =
+        // UDP_FAMILY_IPV4). Without this, peers receiving our DHT-PK push
+        // learn our TCP relays but have NO IDEA where to send UDP cookie
+        // requests — so they never even try UDP holepunch and every
+        // session stays on tcp-relay (~500ms+ RTT) instead of the
+        // ~80ms UDP path. Observed in the wild: even same-LAN peers
+        // (snoopy and mac-dev on the same /24) stuck on tcp-relay
+        // forever because neither side ever announces a UDP endpoint
+        // to the other.
+        //
+        // For peers behind NAT, the LAN address we advertise is
+        // reachable by same-LAN peers and harmless for WAN peers
+        // (they fall through to tcp-relay as before). For peers with
+        // a public IP (e.g. a Vultr VPS), the LAN address IS the
+        // reachable one; same-format works. STUN-style reflexive
+        // discovery is the next layer but isn't required to fix the
+        // LAN case immediately.
+        const packed = [];
+        const ourUdpPort = this.#udp?.localPort();
+        if (ourUdpPort && ourUdpPort > 0) {
+            const ourDhtPk = this.#keyPair?.publicKey;
+            if (ourDhtPk && ourDhtPk.length === 32) {
+                // Enumerate non-loopback IPv4 addresses on this host.
+                // We use os.networkInterfaces() rather than guessing — this
+                // covers a multi-homed peer with several reachable IPs.
+                try {
+                    const ifaces = (await import("os")).networkInterfaces();
+                    const seenIps = new Set();
+                    for (const iface of Object.values(ifaces)) {
+                        if (!iface)
+                            continue;
+                        for (const addr of iface) {
+                            if (addr.family !== "IPv4")
+                                continue;
+                            if (addr.internal)
+                                continue;
+                            if (addr.address === "0.0.0.0")
+                                continue;
+                            if (seenIps.has(addr.address))
+                                continue;
+                            seenIps.add(addr.address);
+                            const parts = addr.address
+                                .split(".")
+                                .map((p) => Number.parseInt(p, 10));
+                            if (parts.length !== 4 || parts.some((n) => !(n >= 0 && n <= 255)))
+                                continue;
+                            const entry = new Uint8Array(1 + 4 + 2 + 32);
+                            entry[0] = 0x02; // UDP_FAMILY_IPV4
+                            entry[1] = parts[0];
+                            entry[2] = parts[1];
+                            entry[3] = parts[2];
+                            entry[4] = parts[3];
+                            entry[5] = (ourUdpPort >> 8) & 0xff;
+                            entry[6] = ourUdpPort & 0xff;
+                            entry.set(ourDhtPk, 7);
+                            packed.push(entry);
+                        }
+                    }
+                }
+                catch {
+                    // os import or interface enumeration failed; skip UDP extras
+                    // and let TCP relay carry the session as before.
+                }
+            }
+        }
         if (this.#tcpRelays) {
             const relays = this.#tcpRelays.connectedRelays(3); // MAX_SHARED_RELAYS
-            const packed = [];
             for (const r of relays) {
                 // Only IPv4 TCP entries supported here; matches what we parse.
                 // Format per packed-nodes spec: family(1) + ipv4(4) + port(2 BE) + pk(32)
@@ -2798,10 +2872,8 @@ export class Peer {
                 entry.set(r.serverPublicKey, 7);
                 packed.push(entry);
             }
-            if (packed.length > 0) {
-                extras = concatBytes(packed);
-            }
         }
+        const extras = packed.length > 0 ? concatBytes(packed) : new Uint8Array(0);
         const innerPayload = concatBytes([
             noReplayBytes,
             this.#keyPair.publicKey,

package/package.json

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