@decentnetwork/peer 0.1.58 → 0.1.60

package/dist/peer.js

@@ -90,6 +90,9 @@ const FRIEND_TIMEOUT_MS = readEnvInt("DECENT_FRIEND_TIMEOUT_MS", 32000);
 const REHS_ACCEPT_COUNT = readEnvInt("DECENT_REHS_ACCEPT_COUNT", 4);
 const REHS_ACCEPT_MS = readEnvInt("DECENT_REHS_ACCEPT_MS", 2500);
 const REHS_WINDOW_MS = readEnvInt("DECENT_REHS_WINDOW_MS", 8000);
+// Re-handshake when we keep receiving undecryptable crypto data from a known
+// friend's endpoint (desynced sessions), rate-limited per friend.
+const REINIT_ON_DESYNC_MS = readEnvInt("DECENT_REINIT_ON_DESYNC_MS", 2000);
 // How long a relay path stays "confirmed" (carrying bulk data on its own, no
 // tcp-relay fan-out) after the last packet received over it. The relay
 // keepalive refreshes this every ~4s on a healthy path, so a generous window
@@ -1825,7 +1828,27 @@ export class Peer {
                 this.#debugVerboseLog(`unknown messenger packet kind ${kind} from ${friendId}`);
                 return;
             }
-            this.#debugLog(`crypto data received from ${remote.address}:${remote.port} but no session matched`);
+            // We received crypto data we can't decrypt from a KNOWN friend's endpoint:
+            // our two sessions are desynced (different keys) and NEITHER side will
+            // re-handshake on its own, because each believes it is still established
+            // (the half-open breaker can't help — no handshakes are being exchanged).
+            // Kick a fresh handshake so we re-converge. Rate-limited per friend so a
+            // flood of undecryptable packets doesn't spam cookie requests.
+            if (!this.#remoteIsTcp(remote) && !viaRelay) {
+                for (const [fid, st] of this.#friendSessions.entries()) {
+                    const matches = (st.remote?.host === remote.address && st.remote?.port === remote.port) ||
+                        (st.endpointCandidates ?? []).some((c) => c.host === remote.address && c.port === remote.port);
+                    if (!matches)
+                        continue;
+                    if (Date.now() - (st.lastReinitMs ?? 0) > REINIT_ON_DESYNC_MS) {
+                        st.lastReinitMs = Date.now();
+                        this.#debugLog(`no-session-matched from ${remote.address}:${remote.port} (friend ${fid}) — desynced, re-initiating handshake`);
+                        void this.#initiateSession(fid).catch(() => undefined);
+                    }
+                    break;
+                }
+            }
+            this.#debugVerboseLog(`crypto data received from ${remote.address}:${remote.port} but no session matched`);
             return;
         }
         if (packet[0] === NET_PACKET_ONION_DATA_RESPONSE && this.#announceDataKey) {
@@ -4034,8 +4057,22 @@ export class Peer {
                 const r = session.remote;
                 const remoteIsSameLan = !!r && isPrivateAddress(r.host) && !isCgnatAddress(r.host) &&
                     getPhysicalLanSubnets().some((s) => isInIpv4Subnet(r.host, s));
-                if (!remoteIsSameLan)
+                if (!remoteIsSameLan) {
+                    // If we ALREADY hold a same-LAN candidate for this peer (learned from
+                    // an earlier offer), switch the session onto it NOW — don't wait to
+                    // receive yet another offer at exactly the right moment. That delay is
+                    // what kept sessions stuck on the public/Tailscale-hairpin path after
+                    // the staggered restarts. Then send a keepalive over the LAN so the
+                    // peer learns our LAN source and replies over it; the downgrade guard
+                    // keeps us there once it sticks.
+                    const lanCand = (session.endpointCandidates ?? []).find((c) => isPrivateAddress(c.host) && !isCgnatAddress(c.host) &&
+                        getPhysicalLanSubnets().some((s) => isInIpv4Subnet(c.host, s)));
+                    if (lanCand) {
+                        session.remote = { host: lanCand.host, port: lanCand.port };
+                        void this.#sendMessengerPacket(friendId, PACKET_ID_ALIVE, new Uint8Array()).catch(() => undefined);
+                    }
                     void this.#sendUdpEndpointOffer(friendId).catch(() => undefined);
+                }
             }
         }
     }

package/package.json

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