@decentnetwork/peer 0.1.34 → 0.1.36

package/dist/peer.js

@@ -332,6 +332,14 @@ export class Peer {
                 session.friendRealPublicKey ??= new Uint8Array(friendKey);
                 this.#friendSessions.set(friendId, session);
                 if (!session.established) {
+                    // A fresh relay-online signal means the peer just (re)connected —
+                    // almost always a restart. Clear any accumulated cookie backoff so
+                    // the connection loop retries the handshake at the 8s base cadence
+                    // instead of the 120s cap it had grown to while the peer was gone.
+                    // Without this, a peer that restarts after a long outage sits
+                    // "online but not established" for up to 2 minutes before the next
+                    // handshake attempt — the exact cn/callpass post-restart wedge.
+                    this.#cookieRetryCount.delete(friendId);
                     void this.#initiateSession(friendId).catch(() => { });
                 }
             });
@@ -1763,6 +1771,14 @@ export class Peer {
             this.#cacheFriendRemote(senderId, knownMatch.host, knownMatch.port, senderPublicKey, friendDhtPublicKey);
             this.#debugLog(`onion dhtpk matched known node for ${senderId} at ${knownMatch.host}:${knownMatch.port}`);
         }
+        // A dhtpk_update is proof the friend is announcing and reachable. If our
+        // session to them isn't established, clear the accumulated cookie backoff
+        // so the connection loop retries the handshake at the base cadence rather
+        // than the up-to-120s cap (mirrors the relay friendOnline reset; covers the
+        // UDP/onion reconnect path after a restart).
+        if (!this.#friendSessions.get(senderId)?.established) {
+            this.#cookieRetryCount.delete(senderId);
+        }
         this.#debugLog(`dhtpk_update friend=${senderId} noReplay=${noReplay.toString()} ` +
             `dhtpk=${carrierIdFromPublicKey(friendDhtPublicKey)} extraLen=${extra.length} ` +
             `extraNodes=${extraNodes.length} extraPreviewHex=${extraPreview}`);
@@ -3025,19 +3041,37 @@ export class Peer {
         const relay = await this.#ensureTurnRelay().catch(() => undefined);
         const relayOctets = relay ? relay.host.split(".").map((s) => parseInt(s, 10)) : undefined;
         const relayValid = relayOctets && relayOctets.length === 4 && !relayOctets.some((o) => Number.isNaN(o));
-        const payload = new Uint8Array(relayValid ? 12 : 6);
+        // Third candidate (bytes 12-17): our primary private LAN address + local
+        // UDP port. A same-LAN peer can punch this directly; without it the only
+        // "direct" option we advertise is our srflx (public) address, which the
+        // NAT must hairpin back onto the LAN — most don't, so two machines in one
+        // office silently fall back to the TURN relay (~260ms for a <1ms hop).
+        const lanIp = getLocalIpv4Addresses().find((ip) => isPrivateAddress(ip));
+        const lanOctets = lanIp ? lanIp.split(".").map((s) => parseInt(s, 10)) : undefined;
+        const lanPort = this.#udp.localPort() ?? 0;
+        const lanValid = !!lanOctets && lanOctets.length === 4 && !lanOctets.some((o) => Number.isNaN(o)) && lanPort > 0;
+        const size = lanValid ? 18 : relayValid ? 12 : 6;
+        const payload = new Uint8Array(size);
         payload.set(octets, 0);
         payload[4] = (srflx.port >> 8) & 0xff;
         payload[5] = srflx.port & 0xff;
-        if (relayValid && relay) {
+        // relay slot (bytes 6-11): filled when we have a relay, else left zero
+        // (receiver skips port 0) so the host candidate can still occupy 12-17.
+        if (relayValid && relay && size >= 12) {
             payload.set(relayOctets, 6);
             payload[10] = (relay.port >> 8) & 0xff;
             payload[11] = relay.port & 0xff;
         }
+        if (lanValid) {
+            payload.set(lanOctets, 12);
+            payload[16] = (lanPort >> 8) & 0xff;
+            payload[17] = lanPort & 0xff;
+        }
         try {
             await this.#sendMessengerPacket(friendId, PACKET_ID_UDP_ENDPOINT, payload);
             this.#debugLog(`udp-endpoint offer sent to ${friendId}: direct=${srflx.host}:${srflx.port}` +
-                (relayValid && relay ? ` relay=${relay.host}:${relay.port}` : ""));
+                (relayValid && relay ? ` relay=${relay.host}:${relay.port}` : "") +
+                (lanValid ? ` lan=${lanIp}:${lanPort}` : ""));
         }
         catch {
             // best-effort — the retry loop will try again
@@ -3088,6 +3122,43 @@ export class Peer {
                 }
             }
         }
+        // LAN host candidate (bytes 12-17): the peer's private LAN address. Only
+        // safe to try when it falls in OUR subnet — same physical LAN — otherwise
+        // a peer's 192.168.1.x could collide with an unrelated host on our own
+        // network. When it matches it's the fastest possible path (direct, no NAT,
+        // no relay), so punch it and add it as a same-LAN endpoint candidate, which
+        // #collectSessionEndpointCandidates prioritises for the session path. We
+        // prefer it as session.remote (when we have no confirmed real UDP yet) so
+        // the very next keepalive upgrades the path off the relay.
+        if (payload.length >= 18) {
+            const lanHost = `${payload[12]}.${payload[13]}.${payload[14]}.${payload[15]}`;
+            const lanPort = ((payload[16] << 8) | payload[17]) >>> 0;
+            const sameLan = lanPort !== 0 &&
+                isPrivateAddress(lanHost) &&
+                getLocalIpv4Subnets().some((s) => isInIpv4Subnet(lanHost, s)) &&
+                !(getLocalIpv4Addresses().includes(lanHost) && this.#udp.localPort() === lanPort);
+            if (sameLan) {
+                this.#rememberEndpointCandidate(session, lanHost, lanPort);
+                this.#debugLog(`udp-endpoint LAN candidate from ${friendId}: ${lanHost}:${lanPort} (same subnet) — punching`);
+                const lanPunch = Uint8Array.of(0xf2);
+                let ln = 0;
+                const lanTimer = setInterval(() => {
+                    this.#udp.sendDirectSync(Buffer.from(lanPunch), lanHost, lanPort);
+                    if (++ln >= 6)
+                        clearInterval(lanTimer);
+                }, 120);
+                const haveRealUdp = session.remote && !session.remote.host?.startsWith("tcp:") && session.remote.port !== 0;
+                if (!haveRealUdp) {
+                    session.remote = { host: lanHost, port: lanPort };
+                }
+                if (session.established) {
+                    void this.#sendMessengerPacket(friendId, PACKET_ID_ALIVE, new Uint8Array()).catch(() => undefined);
+                }
+                else {
+                    void this.#initiateSession(friendId).catch(() => undefined);
+                }
+            }
+        }
         // Don't punch toward ourselves.
         if (getLocalIpv4Addresses().includes(host) && this.#udp.localPort() === port)
             return;

package/package.json

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