@decentnetwork/peer 0.1.117 → 0.1.119

package/dist/peer.js

@@ -32,7 +32,9 @@ const TURN_RELAY_SERVERS = [
     { host: "tokyo.fi.chat", port: 3478, username: "allcom", password: "allcompass" }
 ];
 const ANNOUNCE_WAIT_TIMEOUT_MS = readEnvInt("DECENT_ANNOUNCE_WAIT_TIMEOUT_MS", 4000);
-const MAX_FRIEND_ROUTE_ATTEMPTS = readEnvInt("DECENT_FRIEND_ROUTE_MAX_ATTEMPTS", 12);
+// 24 (was 12): with distance-ordered walking a lookup needs headroom to
+// recurse past a first wave of dead close-in-XOR-space entries.
+const MAX_FRIEND_ROUTE_ATTEMPTS = readEnvInt("DECENT_FRIEND_ROUTE_MAX_ATTEMPTS", 24);
 // How many in-flight announce step1 requests to fan out at once. Toxcore
 // pipelines all 12 of its onion clients in parallel; we batch up to this
 // many concurrent #sendAnnounceAndWait calls so the worst-case walk drops
@@ -2886,9 +2888,53 @@ export class Peer {
         const searchKey = createEphemeralKeyPair();
         const routes = [];
         const routeSeen = new Set();
+        // The friend's announce lives on the ~8 nodes XOR-CLOSEST to their key
+        // (toxcore onion_client). The old queue order (nodeScore) never converged
+        // toward those nodes in our mostly-NAT'd table — 12 attempts burned on
+        // responsive-but-far nodes, so lookups for native friends returned 0
+        // routes and DHTPK could never be delivered. Sort by XOR distance to the
+        // target; per-wave we still guarantee a couple of bootstraps so at least
+        // one responder returns closer nodes to recurse on.
+        const pkCache = new Map();
+        const nodePkBytes = (node) => {
+            if (!node.pk)
+                return null;
+            let v = pkCache.get(node.pk);
+            if (v === undefined) {
+                try {
+                    const b = base58ToBytes(node.pk);
+                    v = b.length === 32 ? b : null;
+                }
+                catch {
+                    v = null;
+                }
+                pkCache.set(node.pk, v);
+            }
+            return v;
+        };
+        const xorCloser = (a, b) => {
+            for (let i = 0; i < 32; i++) {
+                const da = a[i] ^ friendPublicKey[i];
+                const db = b[i] ^ friendPublicKey[i];
+                if (da !== db)
+                    return da - db;
+            }
+            return 0;
+        };
+        const byDistance = (x, y) => {
+            const px = nodePkBytes(x);
+            const py = nodePkBytes(y);
+            if (!px || !py)
+                return px ? -1 : py ? 1 : 0;
+            const c = xorCloser(px, py);
+            if (c !== 0)
+                return c;
+            return this.#nodeScore(`${y.host}:${y.port}`) - this.#nodeScore(`${x.host}:${x.port}`);
+        };
+        const bootstrapIdSet = new Set(this.#opts.bootstrapNodes.map((n) => `${n.host}:${n.port}`));
         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}`));
+            .sort(byDistance);
         const friendId = carrierIdFromPublicKey(friendPublicKey);
         const visited = new Set();
         let attempts = 0;
@@ -2903,25 +2949,32 @@ export class Peer {
         // 4-10s parallel waves).
         while (queue.length > 0 && attempts < maxAttempts && routes.length < 8) {
             const batch = [];
-            while (queue.length > 0 && batch.length < FRIEND_ROUTE_BATCH_SIZE && attempts < maxAttempts) {
-                const node = queue.shift();
+            const takeInto = (node) => {
                 const nodeId = `${node.host}:${node.port}`;
-                if (visited.has(nodeId) || !node.pk) {
-                    continue;
+                if (visited.has(nodeId))
+                    return false;
+                const nodePk = nodePkBytes(node);
+                if (!nodePk) {
+                    visited.add(nodeId);
+                    return false;
                 }
                 visited.add(nodeId);
-                let nodePk;
-                try {
-                    nodePk = base58ToBytes(node.pk);
-                }
-                catch {
-                    continue;
-                }
-                if (nodePk.length !== 32) {
-                    continue;
-                }
                 attempts += 1;
                 batch.push({ node, nodePk, sendBack: randomBytes(8) });
+                return true;
+            };
+            if (attempts === 0) {
+                let bootstrapsTaken = 0;
+                for (const node of queue) {
+                    if (bootstrapsTaken >= 2 || attempts >= maxAttempts)
+                        break;
+                    if (bootstrapIdSet.has(`${node.host}:${node.port}`) && takeInto(node))
+                        bootstrapsTaken++;
+                }
+            }
+            queue.sort(byDistance);
+            while (queue.length > 0 && batch.length < FRIEND_ROUTE_BATCH_SIZE && attempts < maxAttempts) {
+                takeInto(queue.shift());
             }
             if (batch.length === 0) {
                 break;
@@ -3110,8 +3163,30 @@ export class Peer {
                 return storedNodes;
             }
             waves += 1;
-            // Pull the closest unvisited candidates for this wave.
+            // Pull the closest unvisited candidates for this wave. Wave 1 reserves
+            // slots for the BOOTSTRAP nodes: XOR-closest entries in our table are
+            // mostly dead NAT'd peers, so a purely distance-ordered walk burned its
+            // whole deadline before ever asking the only guaranteed-public,
+            // always-on nodes. Announce storage capacity is large (toxcore keeps
+            // ~160 entries, evicting furthest), so in this small network the fleet
+            // WILL store us when asked — and every peer's lookup walk reaches the
+            // fleet, so an announce stored there is universally findable.
             const wave = [];
+            if (waves === 1) {
+                const bootstrapIdSet = new Set(this.#opts.bootstrapNodes.map((n) => `${n.host}:${n.port}`));
+                for (let qi = 0; qi < queue.length && wave.length < 4;) {
+                    const c = queue[qi];
+                    const id = `${c.node.host}:${c.node.port}`;
+                    if (bootstrapIdSet.has(id) && !visited.has(id)) {
+                        visited.add(id);
+                        wave.push(c);
+                        queue.splice(qi, 1);
+                    }
+                    else {
+                        qi++;
+                    }
+                }
+            }
             while (queue.length > 0 && wave.length < SELF_ANNOUNCE_BATCH_SIZE) {
                 const c = queue.shift();
                 const id = `${c.node.host}:${c.node.port}`;

package/package.json

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