@decentnetwork/peer 0.1.90 → 0.1.92

package/dist/peer.js

@@ -174,7 +174,7 @@ const AGENTNET_PROTO_VERSION = 1;
 // Peer package version, advertised as the default appVersion when the embedder
 // doesn't override it. Read lazily so a bundler that inlines this file doesn't
 // need the package.json at runtime.
-const PEER_PKG_VERSION = "0.1.90";
+const PEER_PKG_VERSION = "0.1.91";
 // Toxcore Messenger.h packet IDs (live inside encrypted 0x1b crypto data plain payload)
 const PACKET_ID_PADDING = 0;
 const PACKET_ID_REQUEST = 1; // request retransmission of unreceived packets
@@ -1725,7 +1725,45 @@ export class Peer {
                 else {
                     this.#adoptRemote(state, remote.address, remote.port);
                 }
-                state.lastPingRecvMs = Date.now();
+                // CONVERGENCE RESYNC: the peer is retransmitting the SAME session pubkey
+                // we already hold, so OUR view of the session looks fine. But if we've
+                // been receiving crypto data from this peer we CANNOT decrypt, the peer
+                // is holding a STALE copy of OUR session pubkey (it re-keyed, or we did,
+                // and our reply handshake never reached it) — it encrypts to a key we no
+                // longer have, so every data packet is "no session matched" and it keeps
+                // retransmitting its handshake forever. Silently preserving deadlocks the
+                // session PERMANENTLY (observed callpass↔mac: 11h, 20k undecryptable, IP
+                // + messages both dead while presence shows "online"). Re-send our reply
+                // handshake so the peer re-derives its shared key against our CURRENT
+                // session pubkey. Rate-limited (peer retransmits ~1/s); a healthy session
+                // never sets undecryptableRecvMs, so this can NEVER churn a working one.
+                const now = Date.now();
+                const peerSendingUndecryptable = state.undecryptableRecvMs !== undefined &&
+                    now - state.undecryptableRecvMs < FRIEND_TIMEOUT_MS;
+                const resyncDue = now - (state.lastResyncHandshakeMs ?? 0) > 2000;
+                if (peerSendingUndecryptable && resyncDue) {
+                    state.lastResyncHandshakeMs = now;
+                    state.lastPingRecvMs = now;
+                    const reply = createCryptoHandshake({
+                        recipientCookie: hs.embeddedCookie,
+                        baseNonce: state.ourBaseNonce,
+                        sessionPublicKey: state.ourSessionKeyPair.publicKey,
+                        senderRealSecretKey: this.#keyPair.secretKey,
+                        senderRealPublicKey: this.#keyPair.publicKey,
+                        senderDhtPublicKey: this.#keyPair.publicKey,
+                        receiverRealPublicKey: hs.senderRealPublicKey,
+                        receiverDhtPublicKey: hs.senderDhtPublicKey,
+                        localCookieSymmetricKey: this.#cookieSymmetricKey
+                    });
+                    const sendResync = () => this.#remoteIsTcp(remote)
+                        ? Promise.resolve(this.#tcpRelays?.sendOobToFriend(hs.senderDhtPublicKey, reply) ?? 0)
+                        : this.#sendPacket(reply, { host: remote.address, port: remote.port });
+                    void sendResync()
+                        .then(() => this.#debugLog(`hs_recv duplicate but peer sent undecryptable data — re-sent our handshake to resync friend=${friendId}`))
+                        .catch((error) => this.#debugLog(`resync handshake failed for ${friendId}: ${error.message}`));
+                    return;
+                }
+                state.lastPingRecvMs = now;
                 this.#debugVerboseLog(`hs_recv duplicate friend=${friendId} remote=${remote.address}:${remote.port} (session preserved)`);
                 return;
             }
@@ -2033,23 +2071,25 @@ export class Peer {
                 // packet number. The transport confirmation above already ran, so a
                 // duplicate still keeps the path fresh.
                 //
-                // EXCEPTION: a BULKMSG fragment (inline file from a native peer) can
-                // arrive REORDERED — the C SDK puts totalsz on the FIRST fragment, but
+                // EXCEPTION: multi-fragment reliable messages that reassemble by tid —
+                // BULKMSG (inline files) and INVITE_REQUEST/RESPONSE (WebRTC call SDPs) —
+                // can arrive REORDERED. The C SDK puts totalsz on the FIRST fragment, but
                 // over a dual/UDP path a later fragment can land first, advancing the
-                // low-water past the first fragment's number. Dropping the first
-                // fragment here makes every fragment read totalsz 0 → the whole file is
-                // lost (the classic "bulkmsg totalsz 0 — dropped"). Let bulkmsg through;
-                // #assembleBulkMsg dedups AND orders fragments by packet number, so a
-                // reordered/duplicate fragment is handled correctly there instead.
+                // low-water past the first fragment's number. Dropping the first fragment
+                // here makes every fragment read totalsz 0 → the message is lost or (for
+                // an SDP) scrambled, so a call gets stuck "connecting" and files vanish
+                // ("bulkmsg totalsz 0 — dropped"). Let those through; #assembleBulkMsg /
+                // #assembleInvite dedup AND order fragments by packet number.
                 if (!isSingleTransportKind && opened.packetNumber < (state.receiveBufferStart ?? 0)) {
-                    let isBulk = false;
+                    let reorderable = false;
                     if (innerKind === PACKET_ID_MESSAGE) {
                         try {
-                            isBulk = decodeCarrierPacket(opened.payload.slice(1)).type === PACKET_TYPE_BULKMSG;
+                            const t = decodeCarrierPacket(opened.payload.slice(1)).type;
+                            reorderable = t === PACKET_TYPE_BULKMSG || t === PACKET_TYPE_INVITE_REQUEST || t === PACKET_TYPE_INVITE_RESPONSE;
                         }
                         catch { /* not a carrier packet */ }
                     }
-                    if (!isBulk)
+                    if (!reorderable)
                         continue;
                 }
                 // Track the receive nonce from the EXACT nonce this packet used
@@ -3346,7 +3386,7 @@ export class Peer {
             // signals (SDP offers) fragment by tid like bulkmsg; reassemble then
             // surface as an "invite" event (NOT chat text).
             if (carrier?.type === PACKET_TYPE_INVITE_REQUEST) {
-                const complete = this.#assembleInvite(friendId, carrier);
+                const complete = this.#assembleInvite(friendId, carrier, packetNumber);
                 if (!complete)
                     return; // more fragments pending
                 this.#events.emit("invite", {
@@ -3359,7 +3399,7 @@ export class Peer {
                 return;
             }
             if (carrier?.type === PACKET_TYPE_INVITE_RESPONSE) {
-                const complete = carrier.status === 0 ? this.#assembleInvite(friendId, carrier) : new Uint8Array();
+                const complete = carrier.status === 0 ? this.#assembleInvite(friendId, carrier, packetNumber) : new Uint8Array();
                 if (carrier.status === 0 && !complete)
                     return; // more fragments pending
                 this.#events.emit("inviteResponse", {
@@ -3556,12 +3596,14 @@ export class Peer {
         const nums = [...entry.frags.keys()].sort((a, b) => a - b);
         return concatBytes(nums.map((n) => entry.frags.get(n)));
     }
-    /** Append a Carrier invite fragment (INVITE_REQUEST/RESPONSE); returns the
-     *  full reassembled payload when the last fragment lands, undefined while
-     *  pending. Mirrors #assembleBulkMsg but caps at CARRIER_MAX_INVITE_DATA_LEN
-     *  (8192) and uses a separate buffer. Single-fragment invites (the common
-     *  case for small WebRTC signals) complete on the first call. */
-    #assembleInvite(friendId, frag) {
+    /** Append a Carrier invite fragment (INVITE_REQUEST/RESPONSE) and return the
+     *  full reassembled payload once every fragment has landed. Like
+     *  #assembleBulkMsg, fragments are keyed + ordered by PACKET NUMBER so a
+     *  reordered multi-fragment WebRTC SDP (offer/answer >1280 bytes) reassembles
+     *  correctly instead of scrambling — a scrambled SDP left calls stuck
+     *  "connecting". Caps at CARRIER_MAX_INVITE_DATA_LEN (8192). Single-fragment
+     *  invites (the common case) complete on the first call. */
+    #assembleInvite(friendId, frag, packetNumber) {
         const now = Date.now();
         for (const [key, entry] of this.#inviteAssembly) {
             if (entry.expireAtMs < now)
@@ -3570,26 +3612,31 @@ export class Peer {
         const key = `${friendId}:${frag.tid.toString()}`;
         let entry = this.#inviteAssembly.get(key);
         if (!entry) {
-            // First fragment carries totalsz. A lone fragment whose data already
-            // equals totalsz completes immediately below.
-            if (!frag.totalsz || frag.totalsz > CARRIER_MAX_INVITE_DATA_LEN) {
-                this.#debugLog(`invite from ${friendId} with invalid/missing totalsz ${frag.totalsz} — dropped`);
+            entry = { total: 0, frags: new Map(), got: 0, expireAtMs: now + 60_000 };
+            this.#inviteAssembly.set(key, entry);
+        }
+        // The first fragment carries totalsz; it may arrive out of order.
+        if (frag.totalsz > 0) {
+            if (frag.totalsz > CARRIER_MAX_INVITE_DATA_LEN) {
+                this.#debugLog(`invite from ${friendId} totalsz ${frag.totalsz} exceeds cap — dropped`);
+                this.#inviteAssembly.delete(key);
                 return undefined;
             }
-            entry = { total: frag.totalsz, chunks: [], got: 0, expireAtMs: now + 60_000 };
-            this.#inviteAssembly.set(key, entry);
+            entry.total = frag.totalsz;
         }
-        if (frag.data.length === 0 || entry.got + frag.data.length > entry.total) {
-            this.#debugLog(`invite fragment from ${friendId} overflows totalsz — dropped`);
-            this.#inviteAssembly.delete(key);
-            return undefined;
+        if (frag.data.length > 0 && !entry.frags.has(packetNumber)) {
+            entry.frags.set(packetNumber, frag.data);
+            entry.got += frag.data.length;
         }
-        entry.chunks.push(frag.data);
-        entry.got += frag.data.length;
-        if (entry.got < entry.total)
+        if (entry.total === 0 || entry.got < entry.total)
             return undefined;
         this.#inviteAssembly.delete(key);
-        return concatBytes(entry.chunks);
+        if (entry.got > entry.total) {
+            this.#debugLog(`invite from ${friendId} got ${entry.got} > total ${entry.total} — dropped`);
+            return undefined;
+        }
+        const nums = [...entry.frags.keys()].sort((a, b) => a - b);
+        return concatBytes(nums.map((n) => entry.frags.get(n)));
     }
     /** iOS Beagle sends files inline as a JSON envelope over (bulk)messages:
      *  {"data":"<base64>","fileExtension":".jpg","fileName":"…","type":"image"}.

package/package.json

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