@decentnetwork/peer 0.1.114 → 0.1.115

package/dist/peer.js

@@ -1808,6 +1808,20 @@ export class Peer {
             if (!fromTcp) {
                 this.#cacheFriendRemote(senderId, remote.address, remote.port, request.senderRealPublicKey, request.senderDhtPublicKey);
             }
+            else if (request.senderDhtPublicKey && request.senderDhtPublicKey.length === 32) {
+                // TCP arrival: skip the endpoint, but STILL learn the sender's DHT
+                // key. Natives rotate it every app restart and the relay routes
+                // CRYPTO_DATA by it — a relay-only native (its UDP unreachable to
+                // us) otherwise kept its stale key here, every routed send went to
+                // a key the relay didn't know, and the peer — never receiving our
+                // data — re-keyed every 8s forever (the iPhone churn loop).
+                const session = this.#friendSessions.get(senderId);
+                if (session && !(session.friendDhtPublicKey && Buffer.from(session.friendDhtPublicKey).equals(Buffer.from(request.senderDhtPublicKey)))) {
+                    this.#debugLog(`dht_key_from_tcp_cookie friend=${senderId} new=${carrierIdFromPublicKey(request.senderDhtPublicKey)}`);
+                    session.friendDhtPublicKey = request.senderDhtPublicKey;
+                }
+                this.#learnFriendDhtKey(senderId, request.senderDhtPublicKey);
+            }
             const response = createCookieResponse({
                 request,
                 receiverDhtSecretKey: this.#keyPair.secretKey,
@@ -2071,8 +2085,18 @@ export class Peer {
             else {
                 if (!state.friendRealPublicKey)
                     state.friendRealPublicKey = hs.senderRealPublicKey;
-                if (!state.friendDhtPublicKey)
+                // ALWAYS take the handshake's DHT key, not only when empty: the
+                // handshake authenticates the sender's real key, and natives rotate
+                // their DHT key every restart. Keeping a stale key here sent every
+                // relay-routed CRYPTO_DATA packet to a key the relay didn't know —
+                // silent drop, peer re-keys every 8s (iPhone churn loop).
+                if (hs.senderDhtPublicKey && hs.senderDhtPublicKey.length === 32 &&
+                    !(state.friendDhtPublicKey && Buffer.from(state.friendDhtPublicKey).equals(Buffer.from(hs.senderDhtPublicKey)))) {
+                    if (state.friendDhtPublicKey) {
+                        this.#debugLog(`dht_key_from_hs friend=${friendId} new=${carrierIdFromPublicKey(hs.senderDhtPublicKey)}`);
+                    }
                     state.friendDhtPublicKey = hs.senderDhtPublicKey;
+                }
             }
             if (hs.senderDhtPublicKey && hs.senderDhtPublicKey.length === 32) {
                 this.#learnFriendDhtKey(friendId, hs.senderDhtPublicKey);
@@ -5512,6 +5536,17 @@ export class Peer {
         }
         if (!friendId)
             return;
+        // If ANY established session already uses this DHT key, the key's owner
+        // is known and it is not `friendId` — a shared own-host target (the
+        // simulator) answers EVERY prober's probe, and without this check each
+        // stranded friend in turn "adopted" the sim's key during its slot,
+        // endlessly poisoning its own routing.
+        for (const [fid, s] of this.#friendSessions) {
+            if (fid === friendId || !s.established || !s.friendDhtPublicKey)
+                continue;
+            if (Buffer.from(s.friendDhtPublicKey).equals(Buffer.from(senderDhtPk)))
+                return;
+        }
         // The sender pk currently maps to a DIFFERENT friend. If that friend's
         // session is ESTABLISHED, the key genuinely belongs to them — don't
         // cross-wire. If it is NOT established, the mapping itself may be a

package/package.json

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