@decentnetwork/peer 0.1.2 → 0.1.4

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) {
@@ -2080,13 +2091,20 @@ export class Peer {
                             void this.#sendOnionDhtPk(friendRealPk).catch((error) => {
                                 this.#debugLog(`UDP retry: dhtpk_send for ${friendId} failed: ${error.message}`);
                             });
-                            // 2. Try to discover the peer's UDP endpoint and kick a fresh
-                            //    cookie request via UDP. If it lands, session.remote
-                            //    becomes a real UDP endpoint and the next outbound
-                            //    packet goes direct.
+                            // 2. Try to discover the peer's UDP endpoint and kick a
+                            //    fresh cookie request via UDP. discoverAndCacheFriend
+                            //    Endpoint accepts EITHER the DHT-PK (preferred —
+                            //    direct DHT lookup) OR the friend's real identity
+                            //    public key (onion-routed lookup). When the session
+                            //    came up via TCP-relay only, neither side has
+                            //    received an onion DHT-PK from the other yet, so
+                            //    session.friendDhtPublicKey is null. Falling back
+                            //    to friendRealPk keeps the retry from being a no-op
+                            //    in exactly the case it was designed to fix.
                             const dhtPk = session.friendDhtPublicKey;
-                            if (dhtPk) {
-                                void this.#discoverAndCacheFriendEndpoint(friendId, dhtPk)
+                            const searchKey = dhtPk ?? friendRealPk;
+                            if (searchKey && searchKey.length === 32) {
+                                void this.#discoverAndCacheFriendEndpoint(friendId, searchKey)
                                     .then((found) => {
                                     if (found) {
                                         return this.#initiateSession(friendId).catch(() => undefined);
@@ -2094,12 +2112,13 @@ export class Peer {
                                 })
                                     .catch(() => undefined);
                             }
-                            else if (friend.remoteHost && friend.remotePort) {
-                                // We already have a real UDP endpoint cached — just
-                                // retry the cookie request to it.
+                            // Always also retry initiate if we have a cached real
+                            // UDP endpoint — covers the case where discovery
+                            // succeeded earlier but the cookie request was lost.
+                            if (friend.remoteHost && friend.remotePort) {
                                 void this.#initiateSession(friendId).catch(() => undefined);
                             }
-                            this.#debugLog(`UDP retry attempt for ${friendId} (currently on TCP relay)`);
+                            this.#debugLog(`UDP retry attempt for ${friendId} (currently on TCP relay, search=${dhtPk ? "dht-pk" : "real-pk"})`);
                         }
                     }
                 }

package/package.json

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