@decentnetwork/peer 0.1.28 → 0.1.30

package/dist/peer.js

@@ -193,6 +193,10 @@ export class Peer {
     // unconnected friend (the "accepted friend that never connects" wedge —
     // requestRoute only fired once at startup and was never retried).
     #routeRequestCooldown = new Map();
+    // Per-friend cooldown for RE-SENDING the friend-request to a friend that's
+    // never been accepted (still "requested"). On reconnect / restart we must
+    // re-offer — the original request can be lost while the friend was offline.
+    #friendRequestResendCooldown = new Map();
     // Per-friend consecutive "no routes available" count for DHT-PK so the
     // backoff grows if a friend stays unreachable, instead of retrying every
     // 25s forever for stale persisted entries.
@@ -652,7 +656,7 @@ export class Peer {
                 throw new Error(`friend request dispatch failed: ${errors.join("; ")}`);
             }
             this.#lastFriendRequestDispatch = {
-                transport: sent > 0 ? "onion" : "express",
+                transport: sent > 0 ? "onion" : "direct",
                 routes: routes.length,
                 targets: sent
             };
@@ -2077,46 +2081,67 @@ export class Peer {
         }
         this.#lastSelfAnnounceMs = now;
         const storedNodes = [];
-        const targets = 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}`))
-            .slice(0, MAX_SELF_ANNOUNCE_TARGETS);
+        // An onion announce only STORES on the nodes whose key is closest to OURS,
+        // and toxcore reaches them by following the "here are closer nodes" lists
+        // each node returns — a converging walk. The old code instead sorted by
+        // reliability score and did a single pass, so it announced to far-but-
+        // reliable nodes that just replied isStored=0; it never iterated toward the
+        // closest nodes, so nothing ever stored us (selfAnnounceStoredOn=0) and we
+        // were unreachable in real time. Walk a distance-ordered queue toward our
+        // own key, feeding back the closer nodes each wave discovers.
+        const selfPk = this.#keyPair.publicKey;
         const zeroPing = new Uint8Array(32);
-        const candidates = [];
-        for (const node of targets) {
-            if (!node.pk)
-                continue;
-            let nodePk;
-            try {
-                nodePk = base58ToBytes(node.pk);
-            }
-            catch {
-                continue;
+        const visited = new Set();
+        const queue = [];
+        const enqueueNodes = (nodes) => {
+            for (const node of nodes) {
+                if (!node.pk)
+                    continue;
+                const id = `${node.host}:${node.port}`;
+                if (visited.has(id) || this.#isNodeBlacklisted(id))
+                    continue;
+                if (queue.some((q) => `${q.node.host}:${q.node.port}` === id))
+                    continue;
+                let nodePk;
+                try {
+                    nodePk = base58ToBytes(node.pk);
+                }
+                catch {
+                    continue;
+                }
+                if (nodePk.length !== 32)
+                    continue;
+                queue.push({ node, nodePk, sendBack: randomBytes(8) });
             }
-            if (nodePk.length !== 32)
-                continue;
-            candidates.push({ node, nodePk, sendBack: randomBytes(8) });
-        }
-        // Walk in waves — fire SELF_ANNOUNCE_BATCH_SIZE step1+step2 sequences
-        // in parallel per wave, then process. Toxcore's onion_client.c does
-        // up to MAX_ONION_CLIENTS_ANNOUNCE = 12 simultaneously, which lets it
-        // stabilize self-announce in ~10s on a healthy network. Old serial
-        // walk took (per-node-timeout × N targets × 2 steps) ≈ 16 × 5s × 2
-        // = 160s worst case before a single isStored=2 response.
+            // Closest-to-self first, so each wave hits the nodes most likely to store
+            // us or to point at even-closer ones.
+            queue.sort((x, y) => xorCloser(selfPk, x.nodePk, y.nodePk));
+        };
+        enqueueNodes(this.#knownNodes.length > 0 ? this.#knownNodes : this.#opts.bootstrapNodes);
         // Reset counter at start so dhtHealth can distinguish "never ran" (-1)
-        // from "ran but stored on 0 nodes" (0). The latter means our UDP
-        // path is reaching bootstrap nodes but they're refusing to store
-        // us — that's a wire-level problem (auth, network) we want to see.
+        // from "ran but stored on 0 nodes" (0).
         this.#lastSelfAnnounceStoredCount = 0;
-        for (let i = 0; i < candidates.length; i += SELF_ANNOUNCE_BATCH_SIZE) {
+        const STORE_TARGET = 4;
+        let waves = 0;
+        while (queue.length > 0 && storedNodes.length < STORE_TARGET && waves < 16) {
             if (Date.now() >= deadlineMs) {
                 this.#debugLog("self announce stopped at deadline");
-                // Even on early return, the count is live: storedNodes is what
-                // we got so far.
                 this.#lastSelfAnnounceStoredCount = storedNodes.length;
                 return storedNodes;
             }
-            const wave = candidates.slice(i, i + SELF_ANNOUNCE_BATCH_SIZE);
+            waves += 1;
+            // Pull the closest unvisited candidates for this wave.
+            const wave = [];
+            while (queue.length > 0 && wave.length < SELF_ANNOUNCE_BATCH_SIZE) {
+                const c = queue.shift();
+                const id = `${c.node.host}:${c.node.port}`;
+                if (visited.has(id))
+                    continue;
+                visited.add(id);
+                wave.push(c);
+            }
+            if (wave.length === 0)
+                break;
             // Fire all step1 requests in parallel.
             const step1Settled = await Promise.allSettled(wave.map((c) => this.#sendAnnounceAndWait({
                 node: c.node,
@@ -2184,6 +2209,9 @@ export class Peer {
                 const discovered = parsePackedNodes(final.nodes);
                 if (discovered.length > 0) {
                     this.#knownNodes = dedupeNodes([...this.#knownNodes, ...discovered]);
+                    // Feed the closer nodes this node pointed us at back into the walk —
+                    // this is the convergence that actually reaches a storing node.
+                    enqueueNodes(discovered);
                 }
             }
         }
@@ -2482,6 +2510,22 @@ export class Peer {
                     }
                     catch { /* skip malformed pubkey */ }
                 }
+                // Re-SEND the friend-request to a friend we've never had accepted
+                // (still "requested"). The original can be lost — the friend was
+                // offline/restarting, a relay blipped, or onion had no return path.
+                // When WE'RE online and they still haven't accepted, re-offer over the
+                // live path (onion, then express fallback) on a cooldown. This is how
+                // an always-online server (a dora, an exit) finally gets our request
+                // after either side restarted, without anyone re-running a command.
+                if (!friend.acceptedAt && friend.address) {
+                    const lastFr = this.#friendRequestResendCooldown.get(friendId) ?? 0;
+                    if (now - lastFr > 60_000) {
+                        this.#friendRequestResendCooldown.set(friendId, now);
+                        void this.sendFriendRequest(friend.address, friend.hello).catch((error) => {
+                            this.#debugLog(`re-send friend-request to ${friendId} failed: ${error.message}`);
+                        });
+                    }
+                }
                 const dhtPk = session?.friendDhtPublicKey;
                 if (dhtPk) {
                     const found = await this.#discoverAndCacheFriendEndpoint(friendId, dhtPk).catch(() => false);
@@ -4123,6 +4167,24 @@ function bytesEqual(a, b) {
 function createEphemeralKeyPair() {
     return nacl.box.keyPair();
 }
+/**
+ * Toxcore DHT XOR-distance comparator: returns <0 if node pubkey `a` is CLOSER
+ * to `target` than `b` (so an ascending sort puts the closest nodes first).
+ * Onion announces only store on the nodes closest to your own key, and onion
+ * lookups converge toward the nodes closest to the searched key — so candidate
+ * selection MUST be by XOR distance, not by reliability score. Compares the
+ * 32-byte keys big-endian-wise (most significant differing byte decides).
+ */
+function xorCloser(target, a, b) {
+    const n = Math.min(target.length, a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        const da = (a[i] ^ target[i]) & 0xff;
+        const db = (b[i] ^ target[i]) & 0xff;
+        if (da !== db)
+            return da - db;
+    }
+    return 0;
+}
 function isAllZero(bytes) {
     for (let i = 0; i < bytes.length; i++) {
         if (bytes[i] !== 0) {

package/package.json

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