@decentnetwork/peer 0.1.126 → 0.1.128

package/dist/peer.js

@@ -118,6 +118,10 @@ const FRIEND_CONNECTION_LOOP_MS = readEnvInt("DECENT_FRIEND_CONNECTION_LOOP_MS",
  *  enclosing 3s re-punch cadence), and the cheap one silently set the pace for
  *  the expensive one. Shared here so they cannot diverge again. */
 const DHT_PK_ANNOUNCE_COOLDOWN_MS = readEnvInt("DECENT_DHT_PK_ANNOUNCE_COOLDOWN_MS", 25_000);
+/** Ceiling on the endpoint-lookup interval for a friend that keeps failing to
+ *  resolve. This IS the worst-case time to notice a peer coming back, so it
+ *  stays small — the sweep itself remains full width. */
+const ONION_LOOKUP_MAX_BACKOFF_MS = readEnvInt("DECENT_ONION_LOOKUP_MAX_BACKOFF_MS", 120_000);
 const FRIEND_TIMEOUT_MS = readEnvInt("DECENT_FRIEND_TIMEOUT_MS", 32000);
 // A session whose keys we've PROVEN (decrypted ≥1 real packet from the peer) is
 // NOT torn down at FRIEND_TIMEOUT_MS. A transient all-transport blackout — e.g.
@@ -393,8 +397,9 @@ export class Peer {
      *  same friend, and sharing one timestamp would let whichever ran first
      *  suppress the other for a full budget. */
     #onionLookupCooldown = new Map();
-    /** Consecutive failed endpoint lookups per (friend,target) — drives how wide
-     *  the next fan-out goes. Cleared on success. */
+    /** Consecutive failed endpoint lookups per (friend,target). Kept for
+     *  diagnostics — it no longer narrows the sweep (see the width comment in
+     *  #discoverAndCacheFriendEndpoint for why that was reverted). */
     #onionLookupMisses = new Map();
     // Per-friend cooldown for re-asserting the TCP-relay route toward an
     // unconnected friend (the "accepted friend that never connects" wedge —
@@ -3094,9 +3099,26 @@ export class Peer {
         const budgetKey = `${friendId}:${targetId}`;
         const lastLookup = this.#onionLookupCooldown.get(budgetKey) ?? 0;
         const sinceLast = Date.now() - lastLookup;
-        if (sinceLast < DHT_PK_ANNOUNCE_COOLDOWN_MS) {
+        // Back off in TIME, never in width.
+        //
+        // Width is what finds iOS peers — narrowing it lost them entirely once
+        // already (see the width comment below). Interval is free to grow: a
+        // friend that has failed to resolve twenty times running is not about to
+        // resolve on the twenty-first attempt 25s later, and every one of those
+        // sweeps costs 24 nodes x 2 round trips x 3 X25519 layers.
+        //
+        // Measured on cn (2 cores, 14 friends of which ~5 unreachable): the flat
+        // 25s interval left the daemon at 21.7% of a core purely on lookups for
+        // peers that were simply not there.
+        //
+        // The cap is deliberately small. A peer that comes back online is found by
+        // the next sweep, so the cap IS the worst-case discovery delay — 2 minutes
+        // at full width, against the 200s-at-quarter-width that broke iOS.
+        const misses = this.#onionLookupMisses.get(budgetKey) ?? 0;
+        const budget = Math.min(DHT_PK_ANNOUNCE_COOLDOWN_MS * Math.max(1, misses), ONION_LOOKUP_MAX_BACKOFF_MS);
+        if (sinceLast < budget) {
             this.#debugLog(`endpoint lookup for ${friendId} skipped: ${Math.round(sinceLast / 1000)}s since last ` +
-                `(budget ${DHT_PK_ANNOUNCE_COOLDOWN_MS / 1000}s)`);
+                `(budget ${Math.round(budget / 1000)}s, misses ${misses})`);
             return false;
         }
         this.#onionLookupCooldown.set(budgetKey, Date.now());
@@ -3114,9 +3136,18 @@ export class Peer {
         // peer that only just came back is still found without waiting for a
         // restart. Widening beats a permanently narrow sweep: the failure we must
         // not introduce is "never discovers", not "discovers a bit later".
-        const misses = this.#onionLookupMisses.get(budgetKey) ?? 0;
-        const fullWidth = Math.max(8, Math.min(24, MAX_FRIEND_ROUTE_ATTEMPTS));
-        const width = misses === 0 || misses % 8 === 0 ? fullWidth : 4;
+        // Width stays FULL. An earlier cut narrowed repeats to 4 nodes and only
+        // went wide every 8th attempt — with the 25s budget that put 200s between
+        // full sweeps, and iOS peers (which come online in short windows and are
+        // the hardest to find at the best of times) stopped being seen at all.
+        // Reported from the field the same day: weili.beagles.eth went offline and
+        // stayed offline.
+        //
+        // Cost here is width x frequency, and the frequency gate above already
+        // took 3s -> 25s, an 8x cut on its own. Narrowing width bought another 6x
+        // and paid for it with the one property this code exists to provide.
+        // Keep the cheap half, drop the expensive one.
+        const width = Math.max(8, Math.min(24, MAX_FRIEND_ROUTE_ATTEMPTS));
         const queue = dedupeNodes(this.#knownNodes.length > 0 ? this.#knownNodes : this.#opts.bootstrapNodes)
             .filter((n) => !this.#isNodeBlacklisted(`${n.host}:${n.port}`))
             .sort((a, b) => this.#nodeScore(`${b.host}:${b.port}`) - this.#nodeScore(`${a.host}:${a.port}`))
@@ -3186,9 +3217,8 @@ export class Peer {
                 return true;
             }
         }
-        // Nothing found: remember, so the next sweep for this target probes
-        // narrowly instead of paying the full 24-node price again.
-        this.#onionLookupMisses.set(budgetKey, misses + 1);
+        // Nothing found: count it, for diagnostics only.
+        this.#onionLookupMisses.set(budgetKey, (this.#onionLookupMisses.get(budgetKey) ?? 0) + 1);
         return false;
     }
     async #announceSelfBestEffort(force = false, deadlineMs = Number.POSITIVE_INFINITY) {

package/package.json

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