@decentnetwork/peer 0.1.144 → 0.1.146

package/dist/compat/express.d.ts

@@ -12,6 +12,7 @@ export declare class LegacyExpressClient {
         selfUserId: string;
         selfAddress: string;
         callbacks: PullCallbacks;
+        debug?: boolean;
     });
     hasNodes(): boolean;
     sendOfflineFriendRequest(address: string, hello: Uint8Array): Promise<void>;

package/dist/compat/express.js

@@ -12,8 +12,13 @@ export class LegacyExpressClient {
     #selfAddress;
     #currNode = 0;
     #callbacks;
+    // Own gate, and env-only until now — so in a browser this client was mute
+    // whatever the peer's debug setting was. That is why a stalled pull looked
+    // identical to a pull that never ran.
     #debug = process.env.DECENT_DEBUG === "1";
     constructor(opts) {
+        if (opts.debug)
+            this.#debug = true;
         this.#selfKeyPair = opts.selfKeyPair;
         this.#selfUserId = opts.selfUserId;
         this.#selfAddress = opts.selfAddress;
@@ -63,8 +68,12 @@ export class LegacyExpressClient {
             try {
                 body = await this.#http(node, "GET", encodeURIComponent(this.#selfUserId));
             }
-            catch {
-                continue; // relay unreachable right now — try the next
+            catch (error) {
+                // Say so. Swallowing this made an unreachable relay indistinguishable
+                // from an empty inbox, and offline mail piled up on the server with
+                // nothing anywhere reporting why.
+                this.#debugLog(`pull from ${node.host}:${node.port} failed: ${error?.message ?? error}`);
+                continue;
             }
             const messages = parseExpressResponseFrames(body);
             if (messages.length === 0) {

package/dist/peer.js

@@ -598,6 +598,7 @@ export class Peer {
                 selfKeyPair: this.#keyPair,
                 selfUserId: this.userid(),
                 selfAddress: this.address(),
+                debug: this.#debug,
                 callbacks: {
                     onOfflineFriendRequest: (fromUserId, packet) => {
                         this.#emitOfflineFriendRequest(fromUserId, packet);
@@ -6873,6 +6874,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";
@@ -6923,7 +6959,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}`));
@@ -6972,13 +7011,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/package.json

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