@decentnetwork/peer 0.1.103 → 0.1.105

package/dist/compat/filetransfer.js

@@ -239,17 +239,23 @@ export class FileTransferManager {
         }
         return inner;
     }
-    #freeNumber(friendId) {
+    #freeNumber(friendId, preferred = 0) {
         const inner = this.#map(this.#sending, friendId);
-        for (let i = 0; i < MAX_CONCURRENT_FILE_PIPES; i++)
+        // Start at a content-derived slot. Older receivers retain an incomplete
+        // receive slot in memory until it finishes or is killed. After the sender
+        // restarts, always reusing slot 0 makes a DIFFERENT new file look like a
+        // retransmitted offer for that stale slot, so the receiver silently ACKs
+        // the old file and the new UI stays at 0%. The same content keeps the same
+        // preferred slot (resume), while different content naturally avoids stale
+        // collisions; circular search still supports concurrent transfers.
+        for (let n = 0; n < MAX_CONCURRENT_FILE_PIPES; n++) {
+            const i = (preferred + n) % MAX_CONCURRENT_FILE_PIPES;
             if (!inner.has(i))
                 return i;
+        }
         return -1;
     }
     sendFile(friendId, data, opts) {
-        const fileNumber = this.#freeNumber(friendId);
-        if (fileNumber < 0)
-            return null;
         // Content-addressed fileId (sha256): re-sending the SAME file after a
         // restart or a dropped peer yields the SAME id, so the receiver can match
         // it against its persisted partial and resume from where it left off — the
@@ -257,6 +263,9 @@ export class FileTransferManager {
         const fileId = data.length > 0
             ? new Uint8Array(createHash("sha256").update(data).digest()).slice(0, FILE_ID_LENGTH)
             : randomBytes(FILE_ID_LENGTH);
+        const fileNumber = this.#freeNumber(friendId, fileId[0] ?? 0);
+        if (fileNumber < 0)
+            return null;
         const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
         const lanPath = this.isLanPath(friendId);
         const st = {

package/dist/peer.js

@@ -210,8 +210,22 @@ const RECV_REQUEST_MIN_INTERVAL_MS = 200;
 export class Peer {
     #opts;
     #events = new EventEmitter();
+    /** While negotiating a non-LAN file, temporarily stop sending this friend
+     *  UDP control traffic. Peer <=0.1.94 routes FILE_CONTROL UDP-only whenever
+     *  it has seen recent inbound UDP, even when that public/NAT path is one-way.
+     *  Repeated relay-only offers let that 4s freshness expire, after which the
+     *  old peer returns ACCEPT/ACK over its reliable TCP relay. */
+    #fileRelayNegotiationUntil = new Map();
     // Toxcore-standard file transfer (wire-compatible with native Carrier/toxcore).
-    #fileTransfer = new FileTransferManager((friendId, packetId, payload) => this.#sendMessengerPacket(friendId, packetId, payload), (event, payload) => { this.#events.emit(event, payload); }, (friendId) => {
+    #fileTransfer = new FileTransferManager((friendId, packetId, payload) => {
+        if (packetId === PACKET_ID_FILE_SENDREQUEST) {
+            const session = this.#friendSessions.get(friendId);
+            const lan = !!session?.lanRemoteHost && session.remote?.host === session.lanRemoteHost;
+            if (!lan)
+                this.#fileRelayNegotiationUntil.set(friendId, Date.now() + 6_000);
+        }
+        return this.#sendMessengerPacket(friendId, packetId, payload);
+    }, (event, payload) => { this.#events.emit(event, payload); }, (friendId) => {
         const session = this.#friendSessions.get(friendId);
         return !!session?.lanRemoteHost && session.remote?.host === session.lanRemoteHost;
     });
@@ -604,6 +618,7 @@ export class Peer {
             clearTimeout(timer);
         this.#profileRetryTimers.clear();
         this.#profileRetryAttempts.clear();
+        this.#fileRelayNegotiationUntil.clear();
         if (this.#expressPollTimer) {
             clearInterval(this.#expressPollTimer);
             this.#expressPollTimer = undefined;
@@ -980,6 +995,7 @@ export class Peer {
         }
         const existed = this.#friends.delete(friendId);
         this.#friendSessions.delete(friendId);
+        this.#fileRelayNegotiationUntil.delete(friendId);
         this.#pendingFriendRequests.delete(friendId);
         this.#cookieRetryCount.delete(friendId);
         this.#lastCookieSentKey.delete(friendId);
@@ -2147,6 +2163,21 @@ export class Peer {
                     // syscall (that was the CCTV CPU regression) — safe at CCTV packet
                     // rates.
                     this.#adoptRemote(state, remote.address, remote.port);
+                    // A successfully decrypted packet arriving from a private address in
+                    // one of our physical subnets is stronger LAN proof than an endpoint
+                    // hint: it demonstrates that this exact host:port already reaches us.
+                    // Lock it immediately. Without this, duplicate public/relay copies
+                    // arriving a moment later overwrite `remote`, so file DATA travels on
+                    // the LAN but ACKs hairpin through the public Internet (observed as
+                    // ~38KB/s between mac-dev and WSL on the same 10.0.0.0/24).
+                    if (!state.lanRemoteHost &&
+                        isPrivateAddress(remote.address) &&
+                        !isCgnatAddress(remote.address) &&
+                        getPhysicalLanSubnets().some((s) => isInIpv4Subnet(remote.address, s))) {
+                        state.lanRemoteHost = remote.address;
+                        this.#rememberEndpointCandidate(state, remote.address, remote.port);
+                        this.#debugLog(`lan_lock_confirmed friend=${friendId} host=${remote.address}:${remote.port} (decrypted UDP source)`);
+                    }
                     if (!state.lastUdpRecvMs) {
                         this.#debugLog(`udp_confirmed friend=${friendId} via=${remote.address}:${remote.port} (direct UDP path live)`);
                     }
@@ -3345,6 +3376,11 @@ export class Peer {
      *  buffered packets through the exact same dispatch. `kind` is the first
      *  payload byte (never undefined here — the caller defaults it). */
     #deliverLosslessPayload(friendId, state, kind, inner, remote, packetNumber = 0) {
+        // Any file response proves the receiver can hear this session. Release the
+        // old-peer relay-only negotiation guard before the data pump chooses its
+        // normal LAN/reliable-public path.
+        if (kind === PACKET_ID_FILE_CONTROL)
+            this.#fileRelayNegotiationUntil.delete(friendId);
         // Toxcore file transfer (FILE_SENDREQUEST/CONTROL/DATA = 80/81/82).
         if (this.#fileTransfer.handlePacket(friendId, kind, inner))
             return;
@@ -3964,6 +4000,8 @@ export class Peer {
         const udpFresh = !!realUdpRemote &&
             s?.lastUdpRecvMs !== undefined &&
             Date.now() - s.lastUdpRecvMs < 4_000;
+        const forceFileRelay = (this.#fileRelayNegotiationUntil.get(friendId) ?? 0) > Date.now() &&
+            !(s?.lanRemoteHost && s.remote?.host === s.lanRemoteHost);
         // A freshly-received UDP packet proves only the peer -> us direction.
         // That is enough for lossy IP/video bulk, whose inner TCP stream can
         // recover a dropped packet, but not for reliable file data: returning
@@ -3980,7 +4018,8 @@ export class Peer {
         // lastUdpRecvMs). This converts a multi-second blackout into a few
         // seconds of higher relay latency. Control packets always probe UDP
         // (to keep the NAT mapping warm) so we still try UDP for them.
-        const tryUdp = realUdpRemote &&
+        const tryUdp = !forceFileRelay &&
+            realUdpRemote &&
             (isBulkData ? udpFresh && fileUdpOnlyConfirmed : true);
         if (tryUdp && s?.remote) {
             try {
@@ -4535,10 +4574,17 @@ export class Peer {
         if (payload.length >= 18) {
             const lanHost = `${payload[12]}.${payload[13]}.${payload[14]}.${payload[15]}`;
             const lanPort = ((payload[16] << 8) | payload[17]) >>> 0;
+            // WSL sees only its 172.x virtual NIC, not the Windows host's physical
+            // 10.x subnet. In that topology a peer on the same real LAN is still
+            // safely identifiable because its server-reflexive address equals ours.
+            // Permit the advertised private candidate when both peers share the same
+            // public NAT; if it is a CGNAT/private collision and never validates, the
+            // normal 12s stale-LAN-lock breaker restores the public/relay path.
+            const samePublicNat = !!this.#srflxCache?.addr.host && this.#srflxCache.addr.host === host;
             const sameLan = lanPort !== 0 &&
                 isPrivateAddress(lanHost) &&
                 !isCgnatAddress(lanHost) &&
-                getPhysicalLanSubnets().some((s) => isInIpv4Subnet(lanHost, s)) &&
+                (getPhysicalLanSubnets().some((s) => isInIpv4Subnet(lanHost, s)) || samePublicNat) &&
                 !(getPhysicalLanAddresses().includes(lanHost) && this.#udp.localPort() === lanPort);
             if (sameLan) {
                 this.#rememberEndpointCandidate(session, lanHost, lanPort);

package/package.json

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