@decentnetwork/peer 0.1.98 → 0.1.100

package/dist/compat/filetransfer.js

@@ -108,6 +108,8 @@ const LAN_SAMPLE_MAX_GAIN = 1.25;
 const LAN_STARTUP_MAX_GAIN = 1.15;
 const LAN_STARTUP_DELIVERY_GAIN = 1.5; // never probe above 1.5x recently delivered goodput
 const LAN_STARTUP_QUEUE_MS = 500; // unmistakable raw queue spike; smaller app-level RTT outliers are normal on Windows
+const LAN_STARTUP_HARD_QUEUE_MS = 2000; // one multi-second queue sample is unsafe
+const LAN_STARTUP_QUEUE_ROUNDS = 2; // tolerate one scheduler/session-handover outlier on LAN
 const LAN_STARTUP_KEEPUP = 0.70; // delivered goodput below 70% of pace means the receiver is no longer keeping up
 const LAN_STARTUP_SLOW_ROUNDS = 5; // require sustained saturation across Windows scheduler/ACK jitter
 // FILE ACKs are coalesced and handled by the remote JS event loop. On Windows
@@ -250,7 +252,7 @@ export class FileTransferManager {
             cwnd: CWND_INIT_CHUNKS, stalls: 0, parityHighBlock: -1, lastLossMs: 0, lossEwma: 0,
             minRttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
             paceRateBps: PACE_INIT_BPS, paceTokens: 0, lastPaceMs: nowMs(),
-            btlBwBps: 0, bwSamples: [], fullBwRounds: 0, bbrPhase: 0, roundCount: 0,
+            btlBwBps: 0, bwSamples: [], fullBwRounds: 0, startupQueueRounds: 0, bbrPhase: 0, roundCount: 0,
             rateMarkMs: nowMs(), rateMarkAcked: 0, lowRttCount: 0, lowRttMinMs: Infinity, lastCcLogMs: 0,
             lanPath: this.isLanPath(friendId),
         };
@@ -787,6 +789,7 @@ export class FileTransferManager {
                             // physical-LAN endpoint. Restart STARTUP from the measured rate.
                             st.bbrPhase = 0;
                             st.fullBwRounds = 0;
+                            st.startupQueueRounds = 0;
                         }
                         st.lanPath = lanNow;
                         if (!lanNow) {
@@ -817,7 +820,19 @@ export class FileTransferManager {
                                 st.fullBwRounds++;
                             }
                             const rawQueue = st.minRttMs !== Infinity ? acceptedRtt - st.minRttMs : 0;
-                            const startupOvershot = rawQueue > LAN_STARTUP_QUEUE_MS;
+                            if (rawQueue > LAN_STARTUP_QUEUE_MS) {
+                                st.startupQueueRounds++;
+                            }
+                            else {
+                                st.startupQueueRounds = 0;
+                            }
+                            // File acceptance, an event-loop pause, or a relay-to-LAN
+                            // handover can produce one 500-1000 ms ACK on Windows/macOS.
+                            // One such sample is not evidence that a paced LAN is full.
+                            // Require persistence, while retaining an immediate brake for
+                            // a genuinely dangerous multi-second queue.
+                            const startupOvershot = rawQueue > LAN_STARTUP_HARD_QUEUE_MS ||
+                                st.startupQueueRounds >= LAN_STARTUP_QUEUE_ROUNDS;
                             const startupUnderDelivering = st.fullBwRounds >= LAN_STARTUP_SLOW_ROUNDS;
                             if (startupUnderDelivering || startupOvershot) {
                                 st.bbrPhase = 2;
@@ -828,6 +843,7 @@ export class FileTransferManager {
                                 // the sender continue flooding for ~2 s and collapse cwnd.
                                 st.bwSamples = measuredRate > 0 ? [measuredRate] : [];
                                 st.btlBwBps = measuredRate > 0 ? measuredRate : PACE_INIT_BPS;
+                                st.startupQueueRounds = 0;
                                 st.paceRateBps = Math.max(PACE_INIT_BPS, Math.min(st.paceRateBps * 0.8, st.btlBwBps * 1.1));
                             }
                             else if (st.bbrPhase === 0) {

package/dist/peer.js

@@ -1893,10 +1893,33 @@ export class Peer {
                 // breaker" churned because it accepted new keys with NO such evidence).
                 const peerReKeyed = state.undecryptableRecvMs !== undefined &&
                     state.undecryptableRecvMs > (state.lastPingRecvMs ?? 0);
-                if (sinceEstablished > 1000 && currentSessionAlive && !peerReKeyed) {
-                    this.#debugVerboseLog(`hs_recv ignored friend=${friendId} (new session pubkey on live established session, ${sinceEstablished}ms after establish)`);
+                const now = Date.now();
+                const sameRehsKey = state.rehsSessionPublicKey !== undefined &&
+                    bytesEqual(state.rehsSessionPublicKey, hs.sessionPublicKey);
+                const rehsWindowExpired = state.rehsLastMs === undefined ||
+                    now - state.rehsLastMs > REHS_WINDOW_MS;
+                if (!sameRehsKey || rehsWindowExpired) {
+                    state.rehsSessionPublicKey = hs.sessionPublicKey.slice();
+                    state.rehsCount = 1;
+                    state.rehsFirstMs = now;
+                }
+                else {
+                    state.rehsCount = (state.rehsCount ?? 0) + 1;
+                }
+                state.rehsLastMs = now;
+                const rehsElapsed = now - (state.rehsFirstMs ?? now);
+                const persistentRehs = (state.rehsCount ?? 0) >= REHS_ACCEPT_COUNT &&
+                    rehsElapsed >= REHS_ACCEPT_MS &&
+                    rehsElapsed <= REHS_WINDOW_MS;
+                if (sinceEstablished > 1000 && currentSessionAlive && !peerReKeyed && !persistentRehs) {
+                    this.#debugVerboseLog(`hs_recv ignored friend=${friendId} (new session pubkey on live established session, ` +
+                        `${sinceEstablished}ms after establish, attempts=${state.rehsCount ?? 0})`);
                     return;
                 }
+                if (persistentRehs) {
+                    this.#debugLog(`hs_recv accepting persistent re-handshake friend=${friendId} ` +
+                        `(attempts=${state.rehsCount}, elapsed=${rehsElapsed}ms)`);
+                }
                 if (peerReKeyed) {
                     this.#debugLog(`hs_recv accepting re-handshake friend=${friendId} (peer re-keyed: undecryptable data since last good packet)`);
                 }
@@ -1908,6 +1931,10 @@ export class Peer {
             state.sessionSharedKey = nacl.box.before(hs.sessionPublicKey, state.ourSessionKeyPair.secretKey);
             state.established = true;
             state.sessionEstablishedAtMs = Date.now();
+            state.rehsCount = undefined;
+            state.rehsFirstMs = undefined;
+            state.rehsLastMs = undefined;
+            state.rehsSessionPublicKey = undefined;
             // Fresh session up — reset the higher-pubkey defer window for the
             // next outage (see #initiateSession).
             this.#initiateDeferSinceMs.delete(friendId);
@@ -1936,7 +1963,13 @@ export class Peer {
                 state.sendPacketNumber ??= 0;
                 state.receiveBufferStart ??= 0;
             }
-            state.lastPingRecvMs = Date.now();
+            // A handshake authenticates identities and proposes keys, but it does not
+            // prove that CRYPTO_DATA encrypted under those keys works in both
+            // directions. Keep a fresh session "unproven" until the first packet is
+            // actually decrypted; otherwise a half-open session receives the 180s
+            // proven-session blackout grace instead of the 32s recovery deadline.
+            if (isNewSession)
+                state.lastPingRecvMs = undefined;
             state.pendingEcho = undefined;
             state.pendingCookiePeerDhtPublicKey = undefined;
             this.#debugLog(`hs_recv friend=${friendId} initiated=${weInitiated ? 1 : 0} remote=${remote.address}:${remote.port}`);
@@ -2084,6 +2117,13 @@ export class Peer {
                 // stays unset → udpFresh false → bulk data (files) never ride the LAN
                 // even when LAN UDP is flowing both ways (the snoopy slow-file bug).
                 state.lastPingRecvMs = Date.now();
+                // Any successfully decrypted packet proves the current session is
+                // healthy. Forget rejected new-key proposals so late/replayed
+                // handshakes can never accumulate across healthy traffic.
+                state.rehsCount = undefined;
+                state.rehsFirstMs = undefined;
+                state.rehsLastMs = undefined;
+                state.rehsSessionPublicKey = undefined;
                 if (this.#remoteIsTcp(remote)) {
                     state.hasTcpRoute = true;
                 }
@@ -2932,6 +2972,18 @@ export class Peer {
                 // sessions a long grace so a blackout doesn't churn them via re-handshake;
                 // unproven sessions still time out fast to self-heal a wedged handshake.
                 const proven = session.lastPingRecvMs !== undefined;
+                // A proven session normally gets a long blackout grace: if the network
+                // disappears, keeping the known-good keys avoids unnecessary churn.
+                // A restarted peer is different. Once our last good decrypt goes quiet
+                // while fresh packets from that same friend keep failing authentication,
+                // the transport is alive but the keys are not. Waiting the full proven
+                // timeout turns every peer restart into a multi-minute wedge. Require a
+                // sustained good-packet silence plus recent desync evidence so a single
+                // late relay duplicate can never tear down a healthy session.
+                const recentUndecryptable = session.undecryptableRecvMs !== undefined &&
+                    session.undecryptableRecvMs > lastAlive &&
+                    now - session.undecryptableRecvMs <= REINIT_STUCK_MS;
+                const rekeyStuck = recentUndecryptable && silentFor > REINIT_ON_DESYNC_MS;
                 // A relay-only session (synthetic tcp: remote, no UDP path) whose
                 // relay route is gone has NO transport at all — nothing can arrive
                 // and nothing we send leaves. The proven-session blackout grace
@@ -2942,7 +2994,23 @@ export class Peer {
                 const relayOnly = !session.remote || session.remote.host.startsWith("tcp:");
                 const pathless = relayOnly && !session.hasTcpRoute;
                 const deadline = proven && !pathless ? PROVEN_SESSION_HARD_TIMEOUT_MS : FRIEND_TIMEOUT_MS;
-                if (proven && !pathless && silentFor > FRIEND_TIMEOUT_MS && silentFor <= deadline) {
+                if (rekeyStuck) {
+                    this.#debugLog(`session re-key desync for ${friendId} (no good decrypt in ${silentFor}ms; ` +
+                        `undecryptable packets still arriving) — tearing down to re-handshake`);
+                    this.#friendSessions.delete(friendId);
+                    this.#setFriendOffline(friendId);
+                    try {
+                        const pk = base58ToBytes(friend.pubkey);
+                        if (pk.length === 32)
+                            this.#tcpRelays?.requestRoute(pk);
+                        const dhtPk = this.#friendDhtKeys.get(friendId);
+                        if (dhtPk && dhtPk.length === 32)
+                            this.#tcpRelays?.requestRoute(dhtPk);
+                    }
+                    catch { /* skip malformed */ }
+                    continue;
+                }
+                else if (proven && !pathless && silentFor > FRIEND_TIMEOUT_MS && silentFor <= deadline) {
                     // Blackout grace: keep the proven session and keep probing (the
                     // keepalive + UDP re-punch + relay-keepalive below all still run). Do
                     // NOT delete or re-handshake — that's what desyncs and churns. The peer,

package/package.json

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