@decentnetwork/peer 0.1.127 → 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.
@@ -3095,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());

package/package.json

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