@decentnetwork/peer 0.1.33 → 0.1.35

package/dist/peer.js

@@ -2671,7 +2671,12 @@ export class Peer {
         // re-punch survive a UDP outage. Brief UDP gaps just drop a few data
         // packets (the proxied TCP stream retransmits) and the re-punch loop
         // restores the direct path within a few seconds.
-        const isBulkData = kind === PACKET_ID_MESSAGE;
+        // Native chat (64) is always bulk; an app can register one extra custom
+        // id (decentlan's IP channel = 163) via bulkDataPacketId so its
+        // high-volume traffic gets the same single-transport routing instead of
+        // fanning out over UDP + relay + TCP relay (which delivers 3-4 duplicates).
+        const isBulkData = kind === PACKET_ID_MESSAGE ||
+            (this.#opts.bulkDataPacketId !== undefined && kind === this.#opts.bulkDataPacketId);
         await this.#sendToFriend(friendId, encrypted, session, isBulkData);
     }
     /**
@@ -3020,19 +3025,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
@@ -3083,6 +3106,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/dist/types/peer.d.ts

@@ -28,6 +28,18 @@ export type PeerOptions = {
      * apps that genuinely want offline message delivery leave it false.
      */
     expressControlPlaneOnly?: boolean;
+    /**
+     * Custom packet id carrying the app's high-volume "bulk data" stream
+     * (e.g. decentlan's IP-forwarding channel). Packets sent on this id get
+     * the same single-transport routing as native chat (PACKET_ID_MESSAGE):
+     * they ride the fresh direct UDP path exclusively, or bridge over the
+     * relay when it's stale — instead of fanning out over UDP + relay + TCP
+     * relay at once (which delivers 3-4 duplicates of every packet and backs
+     * up the relay). Apps that put bulk traffic on a custom id (decentlan
+     * uses 163) MUST set this so the SDK recognises it; otherwise the bulk
+     * optimisation only applies to packet 64 and custom-id data is duplicated.
+     */
+    bulkDataPacketId?: number;
     compatibilityMode?: CompatibilityMode;
     debugLabel?: string;
 };

package/package.json

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