@decentnetwork/peer 0.1.152 → 0.1.155

package/dist/compat/express.js

@@ -2,6 +2,7 @@ import { ByteBuffer, Encoding } from "flatbuffers";
 import nacl from "tweetnacl";
 import { base58ToBytes, bytesToBase58 } from "../utils/base58.js";
 import { randomBytes } from "../utils/bytes.js";
+import { sharedKey as sharedKeyFor } from "../crypto/shared-key.js";
 const EXPRESS_MAGIC = 0xca6ee595;
 const NONCE_SIZE = 24;
 const HTTP_TIMEOUT_MS = 15000;
@@ -34,7 +35,7 @@ export class LegacyExpressClient {
                 host: node.host,
                 port: node.port,
                 tls: node.tls !== false, // default HTTPS; opt into HTTP with tls:false
-                sharedKey: nacl.box.before(expressPk, this.#selfKeyPair.secretKey)
+                sharedKey: sharedKeyFor(expressPk, this.#selfKeyPair.secretKey)
             };
         });
     }
@@ -49,7 +50,7 @@ export class LegacyExpressClient {
         if (friendPk.length !== 32) {
             throw new Error("friend user id must decode to 32-byte public key");
         }
-        const friendSharedKey = nacl.box.before(friendPk, this.#selfKeyPair.secretKey);
+        const friendSharedKey = sharedKeyFor(friendPk, this.#selfKeyPair.secretKey);
         const friendEncrypted = encrypt(friendSharedKey, carrierPacket);
         await this.#postEncrypted(friendUserId, friendEncrypted);
     }
@@ -112,7 +113,7 @@ export class LegacyExpressClient {
                         if (friendPk.length !== 32) {
                             continue;
                         }
-                        const friendSharedKey = nacl.box.before(friendPk, this.#selfKeyPair.secretKey);
+                        const friendSharedKey = sharedKeyFor(friendPk, this.#selfKeyPair.secretKey);
                         const packet = decrypt(friendSharedKey, msg.payload);
                         if (!packet) {
                             continue;

package/dist/compat/net-crypto.js

@@ -1,6 +1,7 @@
 import nacl from "tweetnacl";
 import { createHash } from "node:crypto";
 import { concatBytes, randomBytes } from "../utils/bytes.js";
+import { sharedKey as sharedKeyFor } from "../crypto/shared-key.js";
 export const NET_PACKET_COOKIE_REQUEST = 0x18;
 export const NET_PACKET_COOKIE_RESPONSE = 0x19;
 export const NET_PACKET_CRYPTO_HS = 0x1a;
@@ -44,7 +45,7 @@ export function createCookieRequest(opts) {
         throw new Error("cookie request plaintext size mismatch");
     }
     const nonce = randomBytes(NONCE_SIZE);
-    const sharedKey = nacl.box.before(opts.receiverDhtPublicKey, opts.senderDhtSecretKey);
+    const sharedKey = sharedKeyFor(opts.receiverDhtPublicKey, opts.senderDhtSecretKey);
     const cipher = nacl.secretbox(plain, nonce, sharedKey);
     return concatBytes([
         Uint8Array.of(NET_PACKET_COOKIE_REQUEST),
@@ -60,7 +61,7 @@ export function openCookieRequest(packet, opts) {
     const senderDhtPublicKey = packet.slice(1, 1 + KEY_SIZE);
     const nonce = packet.slice(1 + KEY_SIZE, 1 + KEY_SIZE + NONCE_SIZE);
     const cipher = packet.slice(1 + KEY_SIZE + NONCE_SIZE);
-    const sharedKey = nacl.box.before(senderDhtPublicKey, opts.receiverDhtSecretKey);
+    const sharedKey = sharedKeyFor(senderDhtPublicKey, opts.receiverDhtSecretKey);
     const plain = nacl.secretbox.open(cipher, nonce, sharedKey);
     if (!plain || plain.length !== COOKIE_REQUEST_PLAIN_LENGTH) {
         return undefined;
@@ -79,7 +80,7 @@ export function createCookieResponse(opts) {
     });
     const plain = concatBytes([cookie, writeUint64Le(opts.request.echo)]);
     const nonce = randomBytes(NONCE_SIZE);
-    const sharedKey = nacl.box.before(opts.request.senderDhtPublicKey, opts.receiverDhtSecretKey);
+    const sharedKey = sharedKeyFor(opts.request.senderDhtPublicKey, opts.receiverDhtSecretKey);
     const cipher = nacl.secretbox(plain, nonce, sharedKey);
     return concatBytes([Uint8Array.of(NET_PACKET_COOKIE_RESPONSE), nonce, cipher]);
 }
@@ -89,7 +90,7 @@ export function openCookieResponse(packet, opts) {
     }
     const nonce = packet.slice(1, 1 + NONCE_SIZE);
     const cipher = packet.slice(1 + NONCE_SIZE);
-    const sharedKey = nacl.box.before(opts.receiverDhtPublicKey, opts.senderDhtSecretKey);
+    const sharedKey = sharedKeyFor(opts.receiverDhtPublicKey, opts.senderDhtSecretKey);
     const plain = nacl.secretbox.open(cipher, nonce, sharedKey);
     if (!plain || plain.length !== COOKIE_RESPONSE_PLAIN_LENGTH) {
         return undefined;
@@ -135,7 +136,7 @@ export function createCryptoHandshake(opts) {
         sha512(opts.recipientCookie),
         ownCookie
     ]);
-    const sharedKey = nacl.box.before(opts.receiverRealPublicKey, opts.senderRealSecretKey);
+    const sharedKey = sharedKeyFor(opts.receiverRealPublicKey, opts.senderRealSecretKey);
     const innerCipher = nacl.secretbox(innerPlain, innerNonce, sharedKey);
     return concatBytes([Uint8Array.of(NET_PACKET_CRYPTO_HS), opts.recipientCookie, innerNonce, innerCipher]);
 }
@@ -152,7 +153,7 @@ export function openCryptoHandshake(packet, opts) {
     const senderDhtPublicKey = cookieParsed.dhtPublicKey;
     const nonce = packet.slice(1 + COOKIE_LENGTH, 1 + COOKIE_LENGTH + NONCE_SIZE);
     const cipher = packet.slice(1 + COOKIE_LENGTH + NONCE_SIZE);
-    const sharedKey = nacl.box.before(senderRealPublicKey, opts.receiverRealSecretKey);
+    const sharedKey = sharedKeyFor(senderRealPublicKey, opts.receiverRealSecretKey);
     const inner = nacl.secretbox.open(cipher, nonce, sharedKey);
     if (!inner || inner.length !== HANDSHAKE_INNER_LENGTH) {
         return undefined;

package/dist/crypto/shared-key.d.ts

@@ -0,0 +1,4 @@
+export declare function sharedKey(theirPublicKey: Uint8Array, ourSecretKey: Uint8Array): Uint8Array;
+/** Drop everything — for tests, and for a key rotation that reuses the same
+ *  Uint8Array instance. */
+export declare function clearSharedKeyCache(): void;

package/dist/crypto/shared-key.js

@@ -0,0 +1,45 @@
+import nacl from "tweetnacl";
+import { bytesToHex } from "../utils/bytes.js";
+/**
+ * X25519 shared-secret derivation, memoised.
+ *
+ * `nacl.box.before(theirPk, ourSk)` is a scalar multiplication — the single
+ * most expensive thing tweetnacl does, and it is pure JS. Every packet that
+ * derived its key inline paid for one.
+ *
+ * That cost is invisible until a node has friends. Measured with a 53-friend
+ * list against a peer that could reach none of them (the ordinary case: a
+ * laptop whose friends are asleep), the connection loop's cookie requests put
+ *
+ *   60.8%  tweetnacl M            (bignum multiply)
+ *   11.4%  crypto_scalarmult
+ *
+ * of the process on one function — 72% of the CPU, for keys that never change.
+ * A browser tab showed the same shape at 100% of a core for 25 hours.
+ *
+ * The result depends only on (theirPk, ourSk), so it is cached. Keyed on the
+ * public key, with the secret compared by IDENTITY rather than content: a peer
+ * passes the same Uint8Array every time, and a different keypair recomputes
+ * rather than risking a stale hit. Nothing secret is used as a map key.
+ */
+const cache = new Map();
+const MAX_ENTRIES = 1024;
+export function sharedKey(theirPublicKey, ourSecretKey) {
+    const id = bytesToHex(theirPublicKey);
+    const hit = cache.get(id);
+    if (hit && hit.sk === ourSecretKey)
+        return hit.key;
+    const key = nacl.box.before(theirPublicKey, ourSecretKey);
+    if (cache.size >= MAX_ENTRIES) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined)
+            cache.delete(oldest);
+    }
+    cache.set(id, { sk: ourSecretKey, key });
+    return key;
+}
+/** Drop everything — for tests, and for a key rotation that reuses the same
+ *  Uint8Array instance. */
+export function clearSharedKeyCache() {
+    cache.clear();
+}

package/dist/peer.js

@@ -89,6 +89,15 @@ const NODE_BLACKLIST_MAX_TTL_MS = readEnvInt("DECENT_NODE_BLACKLIST_MAX_TTL_MS",
 const FRIEND_ANNOUNCE_ATTEMPTS = readEnvInt("DECENT_FRIEND_ANNOUNCE_ATTEMPTS", 1);
 const JOIN_ANNOUNCE_TIMEOUT_MS = readEnvInt("DECENT_JOIN_ANNOUNCE_TIMEOUT_MS", 12000);
 const SELF_ANNOUNCE_INTERVAL_MS = readEnvInt("DECENT_SELF_ANNOUNCE_INTERVAL_MS", 20000);
+// Slack on top of a run's own deadline before the watchdog abandons it. The
+// abandoned run is left to finish or hang on its own; what matters is that the
+// NEXT tick is allowed to start.
+const SELF_ANNOUNCE_WATCHDOG_MARGIN_MS = readEnvInt("DECENT_SELF_ANNOUNCE_WATCHDOG_MARGIN_MS", 15000);
+// How long a stored announce entry stays useful to someone looking us up.
+// toxcore expires announce entries on roughly this timescale, so a node that
+// acknowledged a store longer ago than this can no longer be counted on.
+const ANNOUNCE_ENTRY_TTL_MS = readEnvInt("DECENT_ANNOUNCE_ENTRY_TTL_MS", 300_000);
+const FAULT_ANNOUNCE_HANG_RUN = readEnvInt("DECENT_FAULT_ANNOUNCE_HANG", 0);
 // Classic-DHT maintenance cadence. Every tick we get_nodes toward our own key
 // (so neighbours store our address and native peers can find our UDP endpoint)
 // and toward each not-yet-UDP friend's key (so we find theirs and punch).
@@ -475,6 +484,11 @@ export class Peer {
     // 25s forever for stale persisted entries.
     #dhtPkConsecutiveFailures = new Map();
     #lastSelfAnnounceStoredCount = -1;
+    // nodeId -> when that node last acknowledged STORING our announce. What
+    // callers actually want to know is "can anyone look me up right now", and
+    // that is a property of live storage across rounds, not of the round in
+    // flight. Counted against ANNOUNCE_ENTRY_TTL_MS on read.
+    #selfAnnounceStoredAt = new Map();
     // Diagnostics for the TCP-relay onion path (announce/discovery over TCP).
     // Surfaced in dhtHealth so `agentnet diag` shows whether it's active without
     // needing verbose logs: sent = onion requests handed to relays, recv = onion
@@ -536,6 +550,13 @@ export class Peer {
     #profileRetryTimers = new Map();
     #greetingSentTo = new Set();
     #selfAnnouncePromise;
+    #selfAnnounceRunCount = 0;
+    // Bumped when the watchdog abandons a run. The abandoned run is still alive
+    // and would otherwise keep writing #announceRouteUsed underneath the round
+    // that replaced it — and step2 rejects a ping_id whose route changed, so
+    // that interference would cost stores. It cannot be killed, but it can be
+    // told to stop at its next wave boundary.
+    #selfAnnounceEpoch = 0;
     #selfAnnouncePauseDepth = 0;
     #started = false;
     constructor(opts) {
@@ -3633,6 +3654,17 @@ export class Peer {
             return [];
         }
         this.#lastSelfAnnounceMs = now;
+        // Fault injection, off unless DECENT_FAULT_ANNOUNCE_HANG names a run
+        // index. Reproduces the browser wedge — a run that never settles — so the
+        // watchdog in #runSelfAnnounce can be tested for real instead of only
+        // reasoned about. Same spirit as DECENT_ANNOUNCE_DEBUG: costs one integer
+        // compare when unset.
+        const myEpoch = this.#selfAnnounceEpoch;
+        this.#selfAnnounceRunCount += 1;
+        if (FAULT_ANNOUNCE_HANG_RUN > 0 && this.#selfAnnounceRunCount === FAULT_ANNOUNCE_HANG_RUN) {
+            this.#debugLog(`FAULT: hanging self-announce run #${this.#selfAnnounceRunCount} forever`);
+            await new Promise(() => { });
+        }
         const storedNodes = [];
         // 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
@@ -3671,15 +3703,27 @@ export class Peer {
             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).
-        this.#lastSelfAnnounceStoredCount = 0;
+        // No reset here. Zeroing at the START of every round is why dhtHealth
+        // read 0 for the first seconds of each round, and why a round cut short by
+        // the deadline published 0 even though ten nodes were still holding our
+        // announce from 10s earlier. Measured before this change: a healthy peer
+        // reported 0 / 10 / 0 / 0 / 10 across a 135s poll. Anyone sampling at the
+        // wrong moment — a user reading the UI, or me reading it and reporting it
+        // as a finding — concluded the peer was unfindable when it was not.
+        // "Never ran" is still distinguishable: #lastSelfAnnounceStoredCount
+        // stays -1 until the first round records something.
+        if (this.#lastSelfAnnounceStoredCount < 0)
+            this.#lastSelfAnnounceStoredCount = 0;
         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");
-                this.#lastSelfAnnounceStoredCount = storedNodes.length;
+                this.#publishSelfAnnounceStoredCount();
+                return storedNodes;
+            }
+            if (this.#selfAnnounceEpoch !== myEpoch) {
+                this.#debugLog("self announce abandoned by watchdog — stopping at wave boundary");
                 return storedNodes;
             }
             waves += 1;
@@ -3784,9 +3828,17 @@ export class Peer {
                 if (final.isStored === 2) {
                     storedNodes.push(c.node);
                     this.#debugLog(`self announce STORED on ${c.node.host}:${c.node.port} (total ${storedNodes.length})`);
-                    // Keep dhtHealth.selfAnnounceStoredOn live within the loop,
-                    // not just at the end, so we see growth in real time.
-                    this.#lastSelfAnnounceStoredCount = storedNodes.length;
+                    // Publish the running count only once it EXCEEDS the last completed
+                    // round's. Each round starts from an empty storedNodes, so writing it
+                    // through unconditionally made dhtHealth read 0 for the first second
+                    // or so of every round — and anyone who polled in that window saw
+                    // "stored on 0 nodes" and concluded the peer was unfindable. That
+                    // reading is what made the Air look permanently broken, and I
+                    // reported it as a finding once before checking whether it settled.
+                    // Measured on this Mac: the same peer alternates 0 / 9 / 10 / 0
+                    // across a two-minute poll while every round stores on ten nodes.
+                    this.#selfAnnounceStoredAt.set(`${c.node.host}:${c.node.port}`, Date.now());
+                    this.#publishSelfAnnounceStoredCount();
                 }
                 const discovered = parsePackedNodes(final.nodes);
                 if (discovered.length > 0) {
@@ -3797,12 +3849,22 @@ export class Peer {
                 }
             }
         }
-        // Track the most recent acknowledged-storage count so dhtHealth()
-        // can surface "DHT discovery layer alive but our announce isn't
-        // landing on any node" vs the normal case.
-        this.#lastSelfAnnounceStoredCount = storedNodes.length;
+        // Track live acknowledged storage so dhtHealth() can still surface "DHT
+        // discovery layer alive but our announce isn't landing anywhere" — that
+        // now shows up as the count DECAYING to 0 as entries age out, instead of
+        // flickering to 0 once per round.
+        this.#publishSelfAnnounceStoredCount();
         return storedNodes;
     }
+    /** Count nodes whose acknowledged store is still within its TTL. */
+    #publishSelfAnnounceStoredCount() {
+        const cutoff = Date.now() - ANNOUNCE_ENTRY_TTL_MS;
+        for (const [id, at] of this.#selfAnnounceStoredAt) {
+            if (at < cutoff)
+                this.#selfAnnounceStoredAt.delete(id);
+        }
+        this.#lastSelfAnnounceStoredCount = this.#selfAnnounceStoredAt.size;
+    }
     #ensureSelfAnnounceLoop() {
         if (this.#selfAnnounceTimer || SELF_ANNOUNCE_INTERVAL_MS <= 0) {
             return;
@@ -6960,7 +7022,41 @@ export class Peer {
         const wrapped = concatBytes([Uint8Array.of(0x69, 0x76, 0x65, 0x67), packet]);
         await this.#udp.send(Buffer.from(wrapped), node.host, node.port);
     }
+    /** Hand an onion request to the connected relays, which stand in for hop A. */
+    #sendOnionOverRelays(nodeB, nodeC, nodeD, payloadForNodeD) {
+        if (!this.#tcpRelays || this.#tcpRelays.connectedCount() === 0)
+            return;
+        try {
+            const tcpPacket = createOnionRequest0Tcp({
+                nodeBHost: nodeB.host,
+                nodeBPort: nodeB.port,
+                nodeBPublicKey: nodeB.publicKey,
+                nodeCHost: nodeC.host,
+                nodeCPort: nodeC.port,
+                nodeCPublicKey: nodeC.publicKey,
+                nodeDHost: nodeD.host,
+                nodeDPort: nodeD.port,
+                payloadForNodeD
+            });
+            const sent = this.#tcpRelays.sendOnionRequest(tcpPacket);
+            if (sent > 0) {
+                this.#diagTcpOnionSent += 1;
+                this.#debugVerboseLog(`tcp onion request sent via ${sent} relay(s) to ${nodeD.host}:${nodeD.port}`);
+            }
+        }
+        catch {
+            /* malformed hop key — nothing to send */
+        }
+    }
     async #sendThroughOnionPath(payloadForNodeD, nodeD, pathOffset = 0, forcedPath) {
+        // Does this host have real UDP? The browser shim binds and drops, and its
+        // socket reports port 0. Building the UDP onion request there is six
+        // scalar multiplications — three ephemeral keypairs and three
+        // Diffie-Hellmans, in pure JS — for a packet that goes nowhere. Measured:
+        // onion construction was 79% of all crypto time, split almost exactly
+        // between the UDP variant and its TCP twin, and a browser tab held a core
+        // at 100% for 25 hours doing it. Decide BEFORE constructing anything.
+        const udpUsable = (this.#udp?.localPort() ?? 0) > 0;
         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
@@ -6971,37 +7067,29 @@ export class Peer {
             // 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 */
-                    }
-                }
+            const hops = this.#tcpRelays && this.#tcpRelays.connectedCount() > 0
+                ? this.#selectTcpOnionHops(nodeD, pathOffset)
+                : undefined;
+            if (hops) {
+                this.#sendOnionOverRelays(hops.nodeB, hops.nodeC, nodeD, payloadForNodeD);
+                return "direct";
+            }
+            if (!udpUsable) {
+                // Nothing can carry it: no relay hops and no UDP. Say so instead of
+                // handing the packet to a socket that drops it silently.
+                this.#debugLog(`no route for ${nodeD.host}:${nodeD.port} — no relay hops and no UDP`);
+                return "direct";
             }
             this.#debugLog(`no onion path for ${nodeD.host}:${nodeD.port}, sending direct`);
             await this.#sendPacket(payloadForNodeD, nodeD);
             return "direct";
         }
+        if (!udpUsable) {
+            // No UDP: go straight to the relay form, which is the only one that can
+            // actually leave this host.
+            this.#sendOnionOverRelays(path.nodeB, path.nodeC, nodeD, payloadForNodeD);
+            return path;
+        }
         this.#debugLog(`sending onion initial via ${path.nodeA.node.host}:${path.nodeA.node.port} to ${nodeD.host}:${nodeD.port}`);
         const packet = createOnionRequest0({
             nodeAPublicKey: path.nodeA.publicKey,
@@ -7269,12 +7357,48 @@ export class Peer {
         if (this.#selfAnnouncePromise) {
             await this.#selfAnnouncePromise.catch(() => { });
         }
-        this.#selfAnnouncePromise = this.#announceSelfBestEffort(force, deadlineMs);
+        // Hard deadline around the WHOLE run, not just the per-node waiter.
+        //
+        // #ensureSelfAnnounceLoop skips a tick while #selfAnnouncePromise is set,
+        // so one run that never settles kills self-announce FOREVER — silently,
+        // and with dhtHealth still reporting the last good numbers. Measured on
+        // app.beagle.chat 2026-08-31: lastSelfAnnounceMs frozen 1731s, stored
+        // stuck at 11, nobody able to look us up. lastSelfAnnounceMs is stamped
+        // on ENTRY, so a frozen value proves the function was never re-entered —
+        // the loop was latched, not failing.
+        //
+        // The hang is in the transport: #sendAnnounceAndWait awaits
+        // #sendThroughOnionPath BEFORE it awaits the timeout-guarded waiter, and
+        // in a browser that send goes over a relay WebSocket. A backgrounded tab
+        // can leave that socket neither open nor errored, so the await never
+        // settles and Promise.allSettled underneath waits forever. Native peers
+        // send over UDP and never hit it, which is why this was browser-only.
+        //
+        // Timing out the specific await would fix today's hang; this fixes the
+        // class. A self-healing loop must not depend on every transport path
+        // being timeout-correct to stay alive.
+        const budgetMs = Math.max(0, deadlineMs - Date.now()) + SELF_ANNOUNCE_WATCHDOG_MARGIN_MS;
+        let watchdog;
+        const guarded = Promise.race([
+            this.#announceSelfBestEffort(force, deadlineMs),
+            new Promise((resolve) => {
+                watchdog = setTimeout(() => {
+                    this.#debugLog(`self announce watchdog fired after ${Math.round(budgetMs / 1000)}s — ` +
+                        `abandoning the run so the loop can retry`);
+                    this.#selfAnnounceEpoch += 1;
+                    resolve([]);
+                }, budgetMs);
+                watchdog.unref?.();
+            }),
+        ]);
+        this.#selfAnnouncePromise = guarded;
         try {
-            const result = await this.#selfAnnouncePromise;
+            const result = await guarded;
             return result ?? [];
         }
         finally {
+            if (watchdog)
+                clearTimeout(watchdog);
             this.#selfAnnouncePromise = undefined;
         }
     }

package/package.json

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