@decentnetwork/peer 0.1.44 → 0.1.46

package/dist/peer.js

@@ -2812,9 +2812,23 @@ export class Peer {
                 firstError = error;
             }
         }
-        // Fresh direct path → send over UDP only: no relay fan-out, no
-        // duplicates, no relay backlog. Applies to both data and control.
-        if (udpFresh && udpOk) {
+        // Fresh direct path → send over UDP only — but ONLY for bulk data.
+        // Bulk is high-volume and must avoid relay fan-out / backlog, so once
+        // the direct path is fresh it rides UDP exclusively.
+        //
+        // Low-volume traffic (chat 64 + control keepalives / endpoint offers /
+        // profile) instead ALSO goes over the relay even when the direct path
+        // looks fresh, because `udpFresh` is derived from INBOUND UDP
+        // (lastUdpRecvMs) and inbound reachability does NOT imply outbound
+        // reachability. On a symmetric / CGNAT peer (e.g. cellular T-Mobile
+        // 172.56.x) the peer's pings keep arriving — so udpFresh stays true —
+        // while our packets to the source port we observed are silently
+        // black-holed: the peer never received from us on that port, so its NAT
+        // has no inbound mapping for our endpoint. Returning UDP-only here would
+        // fire chat into a dead endpoint forever — the exact "peer can send to us
+        // but can't receive from us" one-way failure. net_crypto dedups by packet
+        // number, so the extra relay copy is harmless for sparse chat / control.
+        if (isBulkData && udpFresh && udpOk) {
             return;
         }
         // Tier 2: TURN relay (tokyo) — a fast (~280ms) stable fallback that
@@ -3800,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)
@@ -3810,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.44",
+  "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",