@decentnetwork/peer 0.1.93 → 0.1.94

package/dist/peer.js

@@ -1760,10 +1760,19 @@ export class Peer {
                 const now = Date.now();
                 const peerSendingUndecryptable = state.undecryptableRecvMs !== undefined &&
                     now - state.undecryptableRecvMs < FRIEND_TIMEOUT_MS;
+                // A duplicate handshake can also be the first packet from a freshly
+                // restarted peer whose KILL notice was lost during shutdown. The
+                // holder still has the peer's old accepted session shell, while the
+                // restarted process needs our handshake reply before it can derive the
+                // shared key. Re-send our CURRENT handshake (same key, so no local
+                // reset) even if we also initiated a cookie chain: after a blackout
+                // both sides commonly initiate at once, so `weInitiated` cannot tell a
+                // request from a reply here. The 2s rate limit bounds duplicate traffic;
+                // the immediate reply cannot bounce because it arrives inside the
+                // limit. This is also the normal lost-reply recovery path.
                 const resyncDue = now - (state.lastResyncHandshakeMs ?? 0) > 2000;
-                if (peerSendingUndecryptable && resyncDue) {
+                if (resyncDue) {
                     state.lastResyncHandshakeMs = now;
-                    state.lastPingRecvMs = now;
                     const reply = createCryptoHandshake({
                         recipientCookie: hs.embeddedCookie,
                         baseNonce: state.ourBaseNonce,
@@ -1779,11 +1788,16 @@ export class Peer {
                         ? 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}`))
+                        .then(() => this.#debugLog(`hs_recv duplicate — re-sent our handshake to resync friend=${friendId} ` +
+                        `reason=${peerSendingUndecryptable ? "undecryptable-data" : "duplicate-handshake"}`))
                         .catch((error) => this.#debugLog(`resync handshake failed for ${friendId}: ${error.message}`));
                     return;
                 }
-                state.lastPingRecvMs = now;
+                // A handshake proves reachability, not that this net_crypto session can
+                // decrypt data.  Refreshing lastPingRecvMs here kept a stale session
+                // immortal: the restarted peer retransmitted handshakes every second,
+                // and each retransmit postponed the 32s dead-session breaker forever.
+                // Only successfully decrypted CRYPTO_DATA may refresh liveness.
                 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.93",
+  "version": "0.1.94",
   "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",