@decentnetwork/peer 0.1.119 → 0.1.121

package/dist/peer.js

@@ -2566,7 +2566,13 @@ export class Peer {
                 dataSecretKey: this.#announceDataKey.secretKey
             });
             if (!routed) {
-                this.#debugLog("onion data response decrypt failed");
+                // Log enough to distinguish "sender used a stale data pk from an old
+                // announce entry" from "packet framing we mis-parse" — the temp pk
+                // the sender encrypted to sits at bytes [25..57) in toxcore layout.
+                const pkPreview = Buffer.from(packet.slice(25, 57)).toString("hex").slice(0, 16);
+                this.#debugLog(`onion data response decrypt failed from=${remote.address}:${remote.port} ` +
+                    `len=${packet.length} ourDataPk=${Buffer.from(this.#announceDataKey.publicKey).toString("hex").slice(0, 16)} ` +
+                    `pkAt25=${pkPreview}`);
                 return;
             }
             const onionData = openOnionDataPacket(routed.payload, {
@@ -3173,8 +3179,11 @@ export class Peer {
             // fleet, so an announce stored there is universally findable.
             const wave = [];
             if (waves === 1) {
+                // ALL bootstraps, not a distance-picked subset: only a minority of
+                // the fleet still answers UDP DHT (observed: 1 of 9), and a subset
+                // pick chose 4 dead ones while skipping the live one.
                 const bootstrapIdSet = new Set(this.#opts.bootstrapNodes.map((n) => `${n.host}:${n.port}`));
-                for (let qi = 0; qi < queue.length && wave.length < 4;) {
+                for (let qi = 0; qi < queue.length && wave.length < bootstrapIdSet.size;) {
                     const c = queue[qi];
                     const id = `${c.node.host}:${c.node.port}`;
                     if (bootstrapIdSet.has(id) && !visited.has(id)) {
@@ -5204,7 +5213,11 @@ export class Peer {
         // Prefer DHT key learned from DHTPK updates; fallback to real key.
         const friendDhtPk = session?.friendDhtPublicKey ?? friendRealPk;
         const connectCandidates = this.#collectSessionEndpointCandidates(friendId, friend, session);
-        const tcpAvailable = !!this.#tcpRelays?.isFriendOnline(friendRealPk);
+        // Natives are known to the relay by their DHT key, not their identity
+        // key — check both, else tcpAvailable stays false for every native.
+        const dhtKeyForTcp = session?.friendDhtPublicKey ?? this.#friendDhtKeys.get(friendId);
+        const tcpAvailable = !!this.#tcpRelays?.isFriendOnline(friendRealPk) ||
+            (!!dhtKeyForTcp && !!this.#tcpRelays?.isFriendOnline(dhtKeyForTcp));
         if (connectCandidates.length === 0 && !tcpAvailable) {
             this.#debugLog(`initiate session: no known endpoint for ${friendId} yet`);
             return false;
@@ -5345,8 +5358,28 @@ export class Peer {
             }
             // Also send via TCP relay if available, in parallel. Whichever
             // arrives at the friend first triggers their cookie response.
-            if (tcpAvailable && this.#tcpRelays) {
-                tcpSent = this.#tcpRelays.sendToFriend(friendRealPk, packet);
+            // Route/notify state at the relay is keyed by the key the FRIEND
+            // handshook the relay with — for natives that's their (rotated) DHT
+            // key, NOT their identity key. The old real-pk-only calls meant
+            // tcpAvailable was never true for a native and the routed send would
+            // have gone to a key the relay didn't know (tcp=0 forever while both
+            // ends sat on the same relay).
+            if (this.#tcpRelays) {
+                const tcpKey = session.friendDhtPublicKey ?? friendRealPk;
+                if (this.#tcpRelays.isFriendOnline(tcpKey) || this.#tcpRelays.isFriendOnline(friendRealPk)) {
+                    tcpSent = this.#tcpRelays.sendToFriend(tcpKey, packet);
+                    if (tcpSent === 0 && tcpKey !== friendRealPk) {
+                        tcpSent = this.#tcpRelays.sendToFriend(friendRealPk, packet);
+                    }
+                }
+                // OOB fallback: needs no route/cid — the relay forwards to any
+                // connected client by key, and toxcore's oob handler accepts cookie
+                // requests (0x18). This is exactly how the iOS side reaches US when
+                // only a shared relay exists; without the mirror-image our own
+                // initiation had no TCP path until a route linked.
+                if (tcpSent === 0) {
+                    tcpSent = this.#tcpRelays.sendOobToFriend(tcpKey, packet);
+                }
             }
             if (sent === 0 && tcpSent === 0 && selfSent === 0) {
                 throw new Error("no cookie request packet was sent");

package/package.json

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