@decentnetwork/peer 0.1.91 → 0.1.93

package/dist/peer.js

@@ -593,10 +593,8 @@ export class Peer {
         };
     }
     async stop() {
-        if (this.#tcpRelays) {
-            await this.#tcpRelays.stop().catch(() => { });
-            this.#tcpRelays = undefined;
-        }
+        // Stop background producers first so no keepalive/profile packet can race
+        // behind the shutdown notice and make the remote session look live again.
         if (this.#expressPollTimer) {
             clearInterval(this.#expressPollTimer);
             this.#expressPollTimer = undefined;
@@ -613,6 +611,28 @@ export class Peer {
             clearInterval(this.#friendConnectionTimer);
             this.#friendConnectionTimer = undefined;
         }
+        // Gracefully retire every established net_crypto session before closing
+        // UDP/TCP. The identity key survives an AgentNet restart but the ephemeral
+        // session key does not. Without PACKET_ID_KILL, a service node keeps the old
+        // established session and rejects the restarted daemon's new-key handshake
+        // until its liveness timeout expires (or the service node is restarted).
+        // Carrier/toxcore peers already handle KILL by deleting that one session, so
+        // this is wire-compatible with older holders and does not disturb any other
+        // friend served by an exit node.
+        const establishedFriends = [...this.#friendSessions.entries()]
+            .filter(([, session]) => session.established)
+            .map(([friendId]) => friendId);
+        if (establishedFriends.length > 0) {
+            await Promise.allSettled(establishedFriends.map((friendId) => this.#sendMessengerPacket(friendId, PACKET_ID_KILL, new Uint8Array())));
+            // TcpRelayClient.close() destroys its socket. Give queued relay writes a
+            // brief chance to reach the relay before tearing transports down. UDP and
+            // TURN sends have already been handed to their sockets at this point.
+            await sleep(250);
+        }
+        if (this.#tcpRelays) {
+            await this.#tcpRelays.stop().catch(() => { });
+            this.#tcpRelays = undefined;
+        }
         this.#udp.off("datagram", this.#onDatagram);
         await this.#udp.stop();
         // Release the TURN allocation + its dedicated socket.
@@ -1725,7 +1745,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;
             }

package/package.json

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