@decentnetwork/peer 0.1.45 → 0.1.46

package/dist/peer.js

@@ -3814,6 +3814,27 @@ export class Peer {
         if (typeof this.#dhtMaintenanceTimer.unref === "function")
             this.#dhtMaintenanceTimer.unref();
         void this.#doDhtMaintenance().catch(() => undefined); // become findable right after join
+        // Fast initial population. The steady 15s cadence converges far too
+        // slowly from a cold table — a fresh peer sat at ~14 known nodes, which
+        // is too sparse for the onion announce to store on the nodes truly
+        // closest to our key (the ones native clients query when searching for
+        // us). Run a few quick rounds up front to fill the table within seconds
+        // so the announce can reach storing nodes and we become discoverable.
+        for (const delay of [1200, 3000, 5500, 9000, 13000]) {
+            const t = setTimeout(() => void this.#doDhtMaintenance().catch(() => undefined), delay);
+            if (typeof t.unref === "function")
+                t.unref();
+        }
+        // The join-time announce ran against a near-empty table, so it stored on
+        // few/no nodes. Re-announce once the burst above has populated the table
+        // (~10s) so our FIRST useful announce lands on the genuinely-closest
+        // nodes — the difference between "discoverable within seconds" and "not
+        // until the 20s steady-state timer happens to converge".
+        for (const delay of [10000, 18000]) {
+            const a = setTimeout(() => void this.#runSelfAnnounce(true, Date.now() + 8000).catch(() => undefined), delay);
+            if (typeof a.unref === "function")
+                a.unref();
+        }
     }
     async #doDhtMaintenance() {
         if (!this.#keyPair)
@@ -3824,6 +3845,22 @@ export class Peer {
         for (const node of this.#closestKnownNodes(selfPk, 8)) {
             void this.#sendDhtGetNodes(node, selfPk);
         }
+        // 1b. Fill the routing table ACROSS the keyspace via random-target
+        //     searches. toxcore keeps random DHT search slots so the table isn't
+        //     clustered only near self; without this a JS peer's table stayed tiny
+        //     (~14-97 nodes) and the onion announce could only store on a sparse,
+        //     far-from-closest subset that native searchers never query — so they
+        //     couldn't discover the JS peer by address. A fuller table lets the
+        //     announce reach the genuinely-closest nodes. Search harder while the
+        //     table is small, then taper to a steady refresh.
+        const small = this.#knownNodes.length < 150;
+        const randomSearches = this.#knownNodes.length < 60 ? 6 : small ? 4 : 2;
+        for (let i = 0; i < randomSearches; i++) {
+            const target = randomBytes(32);
+            for (const node of this.#closestKnownNodes(target, small ? 6 : 4)) {
+                void this.#sendDhtGetNodes(node, target);
+            }
+        }
         // 2. For each friend not on a confirmed UDP path, get_nodes toward THEIR
         //    DHT key → learn their UDP endpoint → punch from our side.
         for (const [, session] of this.#friendSessions.entries()) {

package/package.json

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