@decentnetwork/peer 0.1.143 → 0.1.145

package/dist/peer.js

@@ -373,6 +373,10 @@ export class Peer {
     #knownNodes;
     #announceDataKey;
     #lastSelfAnnounceMs = 0;
+    // Env vars OR an explicit option. A browser has no process.env, so peer
+    // debugging there was simply unreachable — which is why the browser client
+    // has been a black box every time it misbehaved. The option is the only way
+    // in from a page.
     #debug = process.env.DECENT_DEBUG === "1" || process.env.DECENT_DEBUG_VERBOSE === "1";
     #debugVerbose = process.env.DECENT_DEBUG_VERBOSE === "1";
     #packetTrace = process.env.DECENT_PACKET_TRACE === "1";
@@ -538,6 +542,15 @@ export class Peer {
             ...opts,
             compatibilityMode: opts.compatibilityMode ?? "legacy"
         };
+        // A browser has no process.env, so the env-var switches above can never
+        // be set there and peer debugging was unreachable from a page. That is
+        // why every browser misbehaviour has had to be diagnosed by inference.
+        if (opts.debug)
+            this.#debug = true;
+        if (opts.debugVerbose) {
+            this.#debug = true;
+            this.#debugVerbose = true;
+        }
         this.#knownNodes = [...opts.bootstrapNodes];
         this.#friendStoreFile = opts.friendStoreFile ?? `${opts.keyFile}.friends.json`;
         // Enable resumable (断点续传) receives when the app gives us a directory to
@@ -6860,6 +6873,41 @@ export class Peer {
     async #sendThroughOnionPath(payloadForNodeD, nodeD, pathOffset = 0, forcedPath) {
         const path = forcedPath === "direct" ? undefined : forcedPath ?? this.#selectOnionPath(nodeD, pathOffset);
         if (!path) {
+            // No 3-hop UDP path. "Direct" then meant a plain UDP send — which on a
+            // host with no UDP (a browser, where dgram is a socket that drops) goes
+            // straight into the void, silently, forever. Every announce and every
+            // friend-request lookup died here.
+            //
+            // A RELAYED onion request needs only two hops: the relay is node A. So
+            // try that before giving up, and only fall through to the UDP send when
+            // there are no relays or not even two usable hops.
+            if (this.#tcpRelays && this.#tcpRelays.connectedCount() > 0) {
+                const hops = this.#selectTcpOnionHops(nodeD, pathOffset);
+                if (hops) {
+                    try {
+                        const tcpPacket = createOnionRequest0Tcp({
+                            nodeBHost: hops.nodeB.host,
+                            nodeBPort: hops.nodeB.port,
+                            nodeBPublicKey: hops.nodeB.publicKey,
+                            nodeCHost: hops.nodeC.host,
+                            nodeCPort: hops.nodeC.port,
+                            nodeCPublicKey: hops.nodeC.publicKey,
+                            nodeDHost: nodeD.host,
+                            nodeDPort: nodeD.port,
+                            payloadForNodeD
+                        });
+                        const sent = this.#tcpRelays.sendOnionRequest(tcpPacket);
+                        if (sent > 0) {
+                            this.#diagTcpOnionSent += 1;
+                            this.#debugLog(`no 3-hop path for ${nodeD.host}:${nodeD.port} — relayed 2-hop onion via ${sent} relay(s) (B=${hops.nodeB.host} C=${hops.nodeC.host})`);
+                            return "direct";
+                        }
+                    }
+                    catch {
+                        /* malformed hop key — fall through to the UDP attempt */
+                    }
+                }
+            }
             this.#debugLog(`no onion path for ${nodeD.host}:${nodeD.port}, sending direct`);
             await this.#sendPacket(payloadForNodeD, nodeD);
             return "direct";
@@ -6910,7 +6958,10 @@ export class Peer {
         }
         return path;
     }
-    #selectOnionPath(nodeD, pathOffset = 0) {
+    /** Ranked hop candidates for a path to nodeD. Shared by the 3-hop UDP
+     *  selector and the 2-hop TCP one — a relay stands in for node A, so a
+     *  relayed path needs one fewer usable node than a direct one. */
+    #onionCandidatePool(nodeD) {
         const nodeDId = `${nodeD.host}:${nodeD.port}`;
         const candidates = [];
         const bootstrapIds = new Set(this.#opts.bootstrapNodes.map((node) => `${node.host}:${node.port}`));
@@ -6959,13 +7010,33 @@ export class Peer {
                 // Ignore bad keys.
             }
         }
-        if (candidates.length < 3) {
-            return undefined;
-        }
         candidates.sort((a, b) => b.score - a.score);
         const preferredRelays = candidates.filter((item) => isLikelyStableRelayPort(item.node.port));
         const healthy = preferredRelays.filter((item) => item.score > -2);
-        const pool = healthy.length >= 3 ? healthy : preferredRelays.length >= 3 ? preferredRelays : candidates;
+        return healthy.length >= 3 ? healthy : preferredRelays.length >= 3 ? preferredRelays : candidates;
+    }
+    /** Two hops (B and C) for a relayed onion request. The relay is node A, so
+     *  this succeeds on node sets too thin for a direct 3-hop path — which is
+     *  the browser's normal state, and where every request used to fall through
+     *  to a UDP send that goes nowhere. */
+    #selectTcpOnionHops(nodeD, pathOffset = 0) {
+        const pool = this.#onionCandidatePool(nodeD);
+        if (pool.length < 2)
+            return undefined;
+        const i1 = pathOffset % pool.length;
+        const i2 = (pathOffset + 1) % pool.length;
+        if (i1 === i2)
+            return undefined;
+        const hop = (x) => ({
+            node: x.node, host: x.node.host, port: x.node.port, publicKey: x.publicKey
+        });
+        return { nodeB: hop(pool[i1]), nodeC: hop(pool[i2]) };
+    }
+    #selectOnionPath(nodeD, pathOffset = 0) {
+        const pool = this.#onionCandidatePool(nodeD);
+        if (pool.length < 3) {
+            return undefined;
+        }
         const count = pool.length;
         const i0 = pathOffset % count;
         const i1 = (pathOffset + 1) % count;

package/dist/types/peer.d.ts

@@ -100,6 +100,10 @@ export type PeerOptions = {
      *  of it never runs: self-announce (so nobody can find this peer) and the
      *  express pull loop (so offline messages are never collected). */
     tcpOnlyBootstrap?: boolean;
+    /** Turn on peer debug logging without env vars — the only route in from a
+     *  browser, where process.env does not exist. */
+    debug?: boolean;
+    debugVerbose?: boolean;
     compatibilityMode?: CompatibilityMode;
     debugLabel?: string;
 };

package/package.json

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