@decentnetwork/peer 0.1.93 → 0.1.95

package/dist/peer.js

@@ -358,6 +358,8 @@ export class Peer {
     // Per-friend tracking sets so we send our nickname/status/greeting once
     // per session rather than on every PACKET_ID_ONLINE arrival.
     #profileSentTo = new Set();
+    #profileRetryAttempts = new Map();
+    #profileRetryTimers = new Map();
     #greetingSentTo = new Set();
     #selfAnnouncePromise;
     #selfAnnouncePauseDepth = 0;
@@ -595,6 +597,10 @@ export class Peer {
     async stop() {
         // Stop background producers first so no keepalive/profile packet can race
         // behind the shutdown notice and make the remote session look live again.
+        for (const timer of this.#profileRetryTimers.values())
+            clearTimeout(timer);
+        this.#profileRetryTimers.clear();
+        this.#profileRetryAttempts.clear();
         if (this.#expressPollTimer) {
             clearInterval(this.#expressPollTimer);
             this.#expressPollTimer = undefined;
@@ -981,6 +987,11 @@ export class Peer {
         this.#tcpOnlyWarningShown.delete(friendId);
         this.#noEndpointWarned.delete(friendId);
         this.#profileSentTo.delete(friendId);
+        const profileRetry = this.#profileRetryTimers.get(friendId);
+        if (profileRetry)
+            clearTimeout(profileRetry);
+        this.#profileRetryTimers.delete(friendId);
+        this.#profileRetryAttempts.delete(friendId);
         this.#greetingSentTo.delete(friendId);
         if (existed) {
             this.#persistFriends();
@@ -1760,10 +1771,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 +1799,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;
             }
@@ -3978,6 +4003,10 @@ export class Peer {
         if (info.description !== undefined)
             opts.statusMessage = info.description;
         this.#profileSentTo.clear();
+        for (const timer of this.#profileRetryTimers.values())
+            clearTimeout(timer);
+        this.#profileRetryTimers.clear();
+        this.#profileRetryAttempts.clear();
         for (const [friendId, s] of this.#friendSessions.entries()) {
             if (s.established)
                 this.#sendProfileAndGreeting(friendId);
@@ -3991,6 +4020,25 @@ export class Peer {
             description: opts.statusMessage ?? PEER_STATUS_MESSAGE,
         };
     }
+    #scheduleProfileRetry(friendId) {
+        if (this.#profileRetryTimers.has(friendId))
+            return;
+        const session = this.#friendSessions.get(friendId);
+        if (!this.#started || !session?.established)
+            return;
+        const attempt = (this.#profileRetryAttempts.get(friendId) ?? 0) + 1;
+        this.#profileRetryAttempts.set(friendId, attempt);
+        const delayMs = Math.min(30_000, 1_000 * (2 ** Math.min(attempt - 1, 5)));
+        const timer = setTimeout(() => {
+            this.#profileRetryTimers.delete(friendId);
+            if (this.#started && this.#friendSessions.get(friendId)?.established) {
+                this.#sendProfileAndGreeting(friendId);
+            }
+        }, delayMs);
+        timer.unref?.();
+        this.#profileRetryTimers.set(friendId, timer);
+        this.#debugLog(`profile retry ${attempt} for ${friendId} scheduled in ${delayMs}ms`);
+    }
     #sendProfileAndGreeting(friendId) {
         if (!this.#profileSentTo.has(friendId)) {
             this.#profileSentTo.add(friendId);
@@ -4030,9 +4078,16 @@ export class Peer {
                     });
                     await this.#sendMessengerPacket(friendId, PACKET_ID_STATUSMESSAGE, userInfo);
                     this.#debugLog(`userinfo sent to ${friendId} (name="${nick}", descr="${descr}", proto=${AGENTNET_PROTO_VERSION}, platform=${this.#opts.platform ?? process.platform})`);
+                    this.#profileRetryAttempts.delete(friendId);
                 }
                 catch (error) {
+                    // PACKET_ID_ONLINE can arrive a fraction before every transport is
+                    // ready to accept messenger packets. Do not leave the optimistic
+                    // "sent" marker wedged after that race: re-arm it and retry with
+                    // bounded backoff while this same session remains established.
+                    this.#profileSentTo.delete(friendId);
                     this.#debugLog(`send profile failed for ${friendId}: ${error.message}`);
+                    this.#scheduleProfileRetry(friendId);
                 }
             })();
         }
@@ -5364,6 +5419,11 @@ export class Peer {
         // transitions prevents the user from seeing the same greeting message
         // repeated each time the session bounces.
         this.#profileSentTo.delete(friendId);
+        const profileRetry = this.#profileRetryTimers.get(friendId);
+        if (profileRetry)
+            clearTimeout(profileRetry);
+        this.#profileRetryTimers.delete(friendId);
+        this.#profileRetryAttempts.delete(friendId);
         const friend = this.#friends.get(friendId);
         if (!friend) {
             return;

package/package.json

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