@decentnetwork/peer 0.1.49 → 0.1.50

package/dist/compat/filetransfer.d.ts

@@ -4,12 +4,13 @@ export declare const PACKET_ID_FILE_DATA = 82;
 export declare const FILE_ID_LENGTH = 32;
 export declare const MAX_FILENAME_LENGTH = 255;
 export declare const MAX_CONCURRENT_FILE_PIPES = 256;
-export declare const MAX_FILE_DATA_SIZE = 1371;
+export declare const MAX_FILE_DATA_SIZE = 1367;
 export declare const FILECONTROL: {
     readonly ACCEPT: 0;
     readonly PAUSE: 1;
     readonly KILL: 2;
     readonly SEEK: 3;
+    readonly ACK: 4;
 };
 export declare const FILEKIND: {
     readonly DATA: 0;
@@ -30,9 +31,10 @@ export declare function parseFileControl(p: Uint8Array): {
     controlType: number;
     data: Uint8Array;
 } | undefined;
-export declare function encodeFileData(fileNumber: number, data: Uint8Array): Uint8Array;
+export declare function encodeFileData(fileNumber: number, offset: number, data: Uint8Array): Uint8Array;
 export declare function parseFileData(p: Uint8Array): {
     fileNumber: number;
+    offset: number;
     data: Uint8Array;
 } | undefined;
 export type FtSend = (friendId: string, packetId: number, payload: Uint8Array) => Promise<unknown>;
@@ -42,17 +44,12 @@ export declare class FileTransferManager {
     private readonly send;
     private readonly emit;
     constructor(send: FtSend, emit: FtEmit);
-    /** Offer a file to a friend. Returns the fileId (hex) or null if no slot. */
     sendFile(friendId: string, data: Uint8Array, opts: {
         name: string;
         kind?: number;
     }): string | null;
-    /** Accept an incoming offer (by the friend + the offered fileNumber). */
     accept(friendId: string, fileNumber: number): void;
-    /** Cancel a transfer (sending or receiving). */
     cancel(friendId: string, fileNumber: number, isSending: boolean): void;
-    /** Route an inbound messenger packet. Returns true if it was a file packet. */
     handlePacket(friendId: string, packetId: number, payload: Uint8Array): boolean;
-    /** Drop all transfers for a friend (e.g. on disconnect). */
     clearFriend(friendId: string): void;
 }

package/dist/compat/filetransfer.js

@@ -1,13 +1,24 @@
-// Toxcore-standard file transfer (Method "B") — wire-compatible with the file
-// transfer already implemented in the C++ Carrier SDK's bundled toxcore
-// (tox_file_send / file_recv*). Rides the messenger / net_crypto lossless
-// channel; reassembled sequentially. No express, no 5 MB cap.
+// Reliable file transfer over the messenger / net_crypto channel.
+//
+// The JS net_crypto layer is best-effort (no retransmit queue), so a file
+// CANNOT just be streamed over it — any UDP-lost chunk would be a permanent
+// gap (observed: a 4.1 MB mp4 arriving as 3.9 MB, corrupt). This module adds
+// its own TCP-like reliability ON TOP: every chunk carries an explicit byte
+// offset, the receiver buffers by offset + acks the highest contiguous offset,
+// and the sender uses a sliding window with timeout retransmission. That gives
+// fast (windowed, UDP-speed) AND correct (byte-exact) transfers without the
+// relay, and real progress/completion based on actual receipt (the sender only
+// completes when the receiver has acked every byte).
 //
 // Wire (messenger packet payloads):
-//   FILE_SENDREQUEST(80): [filenum(1)][file_type u32 BE][file_size u64 BE][file_id(32)][filename(≤255)]
+//   FILE_SENDREQUEST(80): [filenum(1)][file_type u32 BE][file_size u64 BE][file_id(32)][filename]
 //   FILE_CONTROL(81):     [send_receive(1)][filenum(1)][control_type(1)][optional data]
-//   FILE_DATA(82):        [filenum(1)][data ≤ MAX_FILE_DATA_SIZE]  (position implicit; empty = EOF)
+//                         ACK(4) data = [acked_offset u32 BE] (highest contiguous byte received)
+//   FILE_DATA(82):        [filenum(1)][offset u32 BE][data]   (offset = byte position)
 // send_receive: 1 ⇒ filenum is in the RECIPIENT's *sending* table, 0 ⇒ *receiving*.
+// NOTE: the offset makes FILE_DATA differ from upstream toxcore (which has an
+// implicit position); both ends here are the JS SDK. A native-interop mode
+// (Phase 2) can negotiate the plain format via the send-request.
 import { concatBytes, randomBytes } from "../utils/bytes.js";
 export const PACKET_ID_FILE_SENDREQUEST = 80;
 export const PACKET_ID_FILE_CONTROL = 81;
@@ -15,10 +26,15 @@ export const PACKET_ID_FILE_DATA = 82;
 export const FILE_ID_LENGTH = 32;
 export const MAX_FILENAME_LENGTH = 255;
 export const MAX_CONCURRENT_FILE_PIPES = 256;
-// MAX_CRYPTO_DATA_SIZE (1373) − 2; conservative so a chunk always fits one packet.
-export const MAX_FILE_DATA_SIZE = 1371;
-export const FILECONTROL = { ACCEPT: 0, PAUSE: 1, KILL: 2, SEEK: 3 };
+// MAX_CRYPTO_DATA_SIZE (1373) − 1 (kind) − 1 (filenum) − 4 (offset).
+export const MAX_FILE_DATA_SIZE = 1367;
+export const FILECONTROL = { ACCEPT: 0, PAUSE: 1, KILL: 2, SEEK: 3, ACK: 4 };
 export const FILEKIND = { DATA: 0, AVATAR: 1 };
+// Reliability tuning.
+const WINDOW_CHUNKS = 192; // chunks in flight (≈ 256 KB) for throughput on high-BDP paths
+const RETRANSMIT_MS = 600; // resend window from the ack point if no progress in this long
+const ACK_THROTTLE_MS = 25; // coalesce receiver acks
+const SEND_GIVEUP_MS = 60000; // abandon a send after this long with no ack progress (peer gone)
 function u32be(n) {
     const b = new Uint8Array(4);
     b[0] = (n >>> 24) & 0xff;
@@ -71,19 +87,20 @@ export function parseFileControl(p) {
         return undefined;
     return { sendReceive: p[0], fileNumber: p[1], controlType: p[2], data: p.slice(3) };
 }
-export function encodeFileData(fileNumber, data) {
-    return concatBytes([Uint8Array.of(fileNumber & 0xff), data]);
+export function encodeFileData(fileNumber, offset, data) {
+    return concatBytes([Uint8Array.of(fileNumber & 0xff), u32be(offset), data]);
 }
 export function parseFileData(p) {
-    if (p.length < 1)
+    if (p.length < 5)
         return undefined;
-    return { fileNumber: p[0], data: p.slice(1) };
+    return { fileNumber: p[0], offset: readU32be(p, 1), data: p.slice(5) };
 }
 const hex = (b) => Buffer.from(b).toString("hex");
+const nowMs = () => Date.now();
+const chunkCount = (size) => (size <= 0 ? 0 : Math.ceil(size / MAX_FILE_DATA_SIZE));
 export class FileTransferManager {
     send;
     emit;
-    // per friend → per fileNumber
     #sending = new Map();
     #receiving = new Map();
     constructor(send, emit) {
@@ -105,34 +122,52 @@ export class FileTransferManager {
                 return i;
         return -1;
     }
-    /** Offer a file to a friend. Returns the fileId (hex) or null if no slot. */
     sendFile(friendId, data, opts) {
         const fileNumber = this.#freeNumber(friendId);
         if (fileNumber < 0)
             return null;
         const fileId = randomBytes(FILE_ID_LENGTH);
-        const st = { fileNumber, fileId, name: opts.name, data, size: data.length, transferred: 0, accepted: false, pumping: false };
+        const st = {
+            fileNumber, fileId, name: opts.name, data, size: data.length,
+            acked: 0, pumping: false, lastProgressAcked: 0, lastAckAdvanceMs: nowMs(),
+        };
         this.#map(this.#sending, friendId).set(fileNumber, st);
         const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
         void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, req).catch(() => undefined);
         return hex(fileId);
     }
-    /** Accept an incoming offer (by the friend + the offered fileNumber). */
     accept(friendId, fileNumber) {
         const st = this.#map(this.#receiving, friendId).get(fileNumber);
-        if (!st || st.accepted)
+        if (!st || st.done)
             return;
-        st.accepted = true;
-        // send_receive=1 → the filenumber lives in the SENDER's sending table.
         void this.send(friendId, PACKET_ID_FILE_CONTROL, encodeFileControl(1, fileNumber, FILECONTROL.ACCEPT)).catch(() => undefined);
+        this.#sendAck(friendId, st); // prime the sender's window with offset 0
+        // Periodic re-ack: if the ACCEPT (or an ack) is lost, the sender would
+        // never start / would stall; re-sending our cumulative ack restarts its
+        // pump and keeps it informed until the transfer finishes.
+        if (!st.reackTimer) {
+            st.reackTimer = setInterval(() => {
+                const cur = this.#map(this.#receiving, friendId).get(fileNumber);
+                if (!cur || cur.done) {
+                    if (st.reackTimer)
+                        clearInterval(st.reackTimer);
+                    st.reackTimer = undefined;
+                    return;
+                }
+                this.#sendAck(friendId, cur);
+            }, RETRANSMIT_MS);
+            if (typeof st.reackTimer.unref === "function")
+                st.reackTimer.unref();
+        }
     }
-    /** Cancel a transfer (sending or receiving). */
     cancel(friendId, fileNumber, isSending) {
         const sr = isSending ? 0 : 1;
         void this.send(friendId, PACKET_ID_FILE_CONTROL, encodeFileControl(sr, fileNumber, FILECONTROL.KILL)).catch(() => undefined);
-        (isSending ? this.#map(this.#sending, friendId) : this.#map(this.#receiving, friendId)).delete(fileNumber);
+        if (isSending)
+            this.#endSend(friendId, fileNumber);
+        else
+            this.#endRecv(friendId, fileNumber);
     }
-    /** Route an inbound messenger packet. Returns true if it was a file packet. */
     handlePacket(friendId, packetId, payload) {
         if (packetId === PACKET_ID_FILE_SENDREQUEST) {
             this.#onSendRequest(friendId, payload);
@@ -152,25 +187,37 @@ export class FileTransferManager {
         const r = parseFileSendRequest(payload);
         if (!r)
             return;
-        const st = { fileNumber: r.fileNumber, fileId: r.fileId, name: r.filename, size: Number(r.fileSize), chunks: [], received: 0, accepted: false };
+        const size = Number(r.fileSize);
+        const existing = this.#map(this.#receiving, friendId).get(r.fileNumber);
+        if (existing && !existing.done)
+            return; // active transfer already on this slot
+        const st = {
+            fileNumber: r.fileNumber, fileId: r.fileId, name: r.filename, size,
+            buf: new Uint8Array(size), got: new Uint8Array(chunkCount(size)),
+            contiguous: 0, done: false, ackDirty: false,
+        };
         this.#map(this.#receiving, friendId).set(r.fileNumber, st);
-        this.emit("file-offer", { friendId, fileNumber: r.fileNumber, fileId: hex(r.fileId), name: r.filename, size: st.size, kind: r.fileType });
+        this.emit("file-offer", { friendId, fileNumber: r.fileNumber, fileId: hex(r.fileId), name: r.filename, size, kind: r.fileType });
+        if (size === 0)
+            this.#finishRecv(friendId, st);
     }
     #onControl(friendId, payload) {
         const c = parseFileControl(payload);
         if (!c)
             return;
-        // send_receive=1 → refers to a file WE are sending; 0 → a file we are receiving.
         if (c.sendReceive === 1) {
+            // Refers to a file WE are sending.
             const st = this.#map(this.#sending, friendId).get(c.fileNumber);
             if (!st)
                 return;
             if (c.controlType === FILECONTROL.ACCEPT) {
-                st.accepted = true;
                 void this.#pump(friendId, st);
             }
+            else if (c.controlType === FILECONTROL.ACK) {
+                this.#onAck(friendId, st, c.data);
+            }
             else if (c.controlType === FILECONTROL.KILL) {
-                this.#map(this.#sending, friendId).delete(c.fileNumber);
+                this.#endSend(friendId, c.fileNumber);
                 this.emit("file-cancel", { friendId, fileId: hex(st.fileId), sending: true });
             }
         }
@@ -179,11 +226,12 @@ export class FileTransferManager {
             if (!st)
                 return;
             if (c.controlType === FILECONTROL.KILL) {
-                this.#map(this.#receiving, friendId).delete(c.fileNumber);
+                this.#endRecv(friendId, c.fileNumber);
                 this.emit("file-cancel", { friendId, fileId: hex(st.fileId), sending: false });
             }
         }
     }
+    // ── receiver ──────────────────────────────────────────────────────
     #onData(friendId, payload) {
         const d = parseFileData(payload);
         if (!d)
@@ -191,49 +239,190 @@ export class FileTransferManager {
         const st = this.#map(this.#receiving, friendId).get(d.fileNumber);
         if (!st)
             return;
-        if (d.data.length === 0 || (st.size !== 0 && st.received >= st.size)) {
-            // EOF (empty final chunk) or all bytes in.
-            const full = concatBytes(st.chunks);
-            this.#map(this.#receiving, friendId).delete(d.fileNumber);
-            this.emit("file-complete", { friendId, fileId: hex(st.fileId), name: st.name, size: st.size, data: full });
+        if (st.done) {
+            this.#sendAck(friendId, st);
+            return;
+        } // re-ack: recover a lost final ack
+        const { offset, data } = d;
+        if (data.length === 0 || offset + data.length > st.size)
+            return; // malformed/stale
+        const idx = Math.floor(offset / MAX_FILE_DATA_SIZE);
+        if (offset % MAX_FILE_DATA_SIZE !== 0 || idx >= st.got.length)
+            return; // not a chunk boundary
+        if (!st.got[idx]) {
+            st.buf.set(data, offset);
+            st.got[idx] = 1;
+            // Advance the contiguous prefix.
+            let i = Math.floor(st.contiguous / MAX_FILE_DATA_SIZE);
+            while (i < st.got.length && st.got[i])
+                i++;
+            st.contiguous = Math.min(i * MAX_FILE_DATA_SIZE, st.size);
+            this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.contiguous, total: st.size });
+        }
+        if (st.contiguous >= st.size) {
+            this.#finishRecv(friendId, st);
+            return;
+        }
+        this.#scheduleAck(friendId, st);
+    }
+    #finishRecv(friendId, st) {
+        st.done = true;
+        if (st.ackTimer) {
+            clearTimeout(st.ackTimer);
+            st.ackTimer = undefined;
+        }
+        if (st.reackTimer) {
+            clearInterval(st.reackTimer);
+            st.reackTimer = undefined;
+        }
+        this.#sendAck(friendId, st); // final ack so the sender completes
+        const data = st.buf;
+        this.emit("file-complete", { friendId, fileId: hex(st.fileId), name: st.name, size: st.size, data });
+        // Keep a lightweight done-marker (st.contiguous == size) so a LOST final
+        // ack can be recovered: any further FILE_DATA for this slot re-acks. Free
+        // the big buffers now; drop the marker after a grace window.
+        st.buf = new Uint8Array(0);
+        st.got = new Uint8Array(0);
+        const t = setTimeout(() => {
+            const cur = this.#map(this.#receiving, friendId).get(st.fileNumber);
+            if (cur === st)
+                this.#map(this.#receiving, friendId).delete(st.fileNumber);
+        }, 10000);
+        if (typeof t.unref === "function")
+            t.unref();
+    }
+    #scheduleAck(friendId, st) {
+        st.ackDirty = true;
+        if (st.ackTimer)
+            return;
+        st.ackTimer = setTimeout(() => {
+            st.ackTimer = undefined;
+            if (st.ackDirty && !st.done)
+                this.#sendAck(friendId, st);
+        }, ACK_THROTTLE_MS);
+    }
+    #sendAck(friendId, st) {
+        st.ackDirty = false;
+        // send_receive=1: the ACK refers to a file the PEER is SENDING (it lives in
+        // the peer's #sending table), so its #onControl routes it there.
+        void this.send(friendId, PACKET_ID_FILE_CONTROL, encodeFileControl(1, st.fileNumber, FILECONTROL.ACK, u32be(st.contiguous))).catch(() => undefined);
+    }
+    // ── sender ────────────────────────────────────────────────────────
+    #onAck(friendId, st, data) {
+        if (data.length < 4)
             return;
+        const ackedOffset = readU32be(data, 0);
+        if (ackedOffset > st.acked) {
+            st.acked = Math.min(ackedOffset, st.size);
+            st.lastAckAdvanceMs = nowMs();
+            if (st.acked - st.lastProgressAcked >= 64 * 1024 || st.acked >= st.size) {
+                st.lastProgressAcked = st.acked;
+                this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.acked, total: st.size, sending: true });
+            }
         }
-        st.chunks.push(d.data);
-        st.received += d.data.length;
-        this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.received, total: st.size });
-        if (st.size !== 0 && st.received >= st.size) {
-            const full = concatBytes(st.chunks);
-            this.#map(this.#receiving, friendId).delete(d.fileNumber);
-            this.emit("file-complete", { friendId, fileId: hex(st.fileId), name: st.name, size: st.size, data: full });
+        if (st.acked >= st.size) {
+            this.#completeSend(friendId, st);
+            return;
         }
+        void this.#pump(friendId, st); // window slid → send more
     }
-    // Pump chunks over the lossless messenger channel. net_crypto applies its own
-    // congestion control, so awaiting each send gives natural backpressure.
     async #pump(friendId, st) {
         if (st.pumping)
             return;
         st.pumping = true;
+        // Retransmit watchdog: if the ack hasn't advanced within RETRANSMIT_MS,
+        // rewind the send cursor to the ack point (go-back-N) so the lost chunk and
+        // anything after it are re-sent. Cumulative acks make this self-correcting.
+        if (!st.timer) {
+            let stalledSinceMs = nowMs();
+            st.timer = setInterval(() => {
+                const cur = this.#map(this.#sending, friendId).get(st.fileNumber);
+                if (!cur) {
+                    if (st.timer)
+                        clearInterval(st.timer);
+                    st.timer = undefined;
+                    return;
+                }
+                if (st.acked >= st.size)
+                    return;
+                const sinceAck = nowMs() - st.lastAckAdvanceMs;
+                if (sinceAck < RETRANSMIT_MS) {
+                    stalledSinceMs = nowMs();
+                    return;
+                }
+                // Give up if the receiver has gone silent for too long (disconnected /
+                // closed the app) rather than retransmitting forever.
+                if (nowMs() - stalledSinceMs >= SEND_GIVEUP_MS) {
+                    this.#endSend(friendId, st.fileNumber);
+                    this.emit("file-cancel", { friendId, fileId: hex(st.fileId), sending: true, reason: "timeout" });
+                    return;
+                }
+                st.lastAckAdvanceMs = nowMs();
+                void this.#pumpFrom(friendId, st, st.acked);
+            }, Math.ceil(RETRANSMIT_MS / 2));
+            if (typeof st.timer.unref === "function")
+                st.timer.unref();
+        }
         try {
-            while (st.transferred < st.size) {
-                const end = Math.min(st.transferred + MAX_FILE_DATA_SIZE, st.size);
-                const chunk = st.data.subarray(st.transferred, end);
-                await this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, chunk));
-                st.transferred = end;
-                this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.transferred, total: st.size, sending: true });
-                if (!this.#map(this.#sending, friendId).has(st.fileNumber))
-                    return; // cancelled
+            await this.#pumpFrom(friendId, st, st.acked);
+        }
+        finally {
+            st.pumping = false;
+        }
+    }
+    // Send chunks from `from` up to the window edge (acked + window).
+    async #pumpFrom(friendId, st, from) {
+        const windowEnd = Math.min(st.acked + WINDOW_CHUNKS * MAX_FILE_DATA_SIZE, st.size);
+        let off = from;
+        while (off < windowEnd) {
+            if (!this.#map(this.#sending, friendId).has(st.fileNumber))
+                return; // cancelled
+            const end = Math.min(off + MAX_FILE_DATA_SIZE, st.size);
+            const chunk = st.data.subarray(off, end);
+            try {
+                await this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, off, chunk));
+            }
+            catch {
+                return; // transport down; the watchdog will retry from the ack point
             }
-            // Empty final chunk marks EOF for the receiver.
-            await this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, new Uint8Array(0)));
-            this.#map(this.#sending, friendId).delete(st.fileNumber);
-            this.emit("file-complete", { friendId, fileId: hex(st.fileId), name: st.name, size: st.size, sending: true });
+            off = end;
         }
-        catch {
-            this.#map(this.#sending, friendId).delete(st.fileNumber);
+    }
+    #completeSend(friendId, st) {
+        this.#endSend(friendId, st.fileNumber);
+        this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.size, total: st.size, sending: true });
+        this.emit("file-complete", { friendId, fileId: hex(st.fileId), name: st.name, size: st.size, sending: true });
+    }
+    #endSend(friendId, fileNumber) {
+        const st = this.#map(this.#sending, friendId).get(fileNumber);
+        if (st?.timer) {
+            clearInterval(st.timer);
+            st.timer = undefined;
         }
+        this.#map(this.#sending, friendId).delete(fileNumber);
+    }
+    #endRecv(friendId, fileNumber) {
+        const st = this.#map(this.#receiving, friendId).get(fileNumber);
+        if (st?.ackTimer) {
+            clearTimeout(st.ackTimer);
+            st.ackTimer = undefined;
+        }
+        if (st?.reackTimer) {
+            clearInterval(st.reackTimer);
+            st.reackTimer = undefined;
+        }
+        this.#map(this.#receiving, friendId).delete(fileNumber);
     }
-    /** Drop all transfers for a friend (e.g. on disconnect). */
     clearFriend(friendId) {
+        for (const st of this.#map(this.#sending, friendId).values())
+            if (st.timer)
+                clearInterval(st.timer);
+        for (const st of this.#map(this.#receiving, friendId).values()) {
+            if (st.ackTimer)
+                clearTimeout(st.ackTimer);
+            if (st.reackTimer)
+                clearInterval(st.reackTimer);
+        }
         this.#sending.delete(friendId);
         this.#receiving.delete(friendId);
     }

package/dist/peer.js

@@ -51,6 +51,10 @@ const SELF_ANNOUNCE_INTERVAL_MS = readEnvInt("DECENT_SELF_ANNOUNCE_INTERVAL_MS",
 // (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).
 const DHT_MAINTENANCE_INTERVAL_MS = readEnvInt("DECENT_DHT_MAINTENANCE_INTERVAL_MS", 15000);
+// Hard bound on the DHT routing table. Enough to stay findable + announce on the
+// closest nodes; prevents the aggressive population from growing it (and the hot
+// distance-sort it feeds) without limit — which starved CCTV forwarding over time.
+const MAX_KNOWN_NODES = readEnvInt("DECENT_MAX_KNOWN_NODES", 400);
 const MAX_SELF_ANNOUNCE_TARGETS = readEnvInt("DECENT_SELF_ANNOUNCE_TARGETS", 16);
 const SELF_ANNOUNCE_ATTEMPTS = readEnvInt("DECENT_SELF_ANNOUNCE_ATTEMPTS", 3);
 // Self-announce batch size — number of step1 / step2 requests to fan out
@@ -561,7 +565,12 @@ export class Peer {
         };
     }
     addKnownNodes(nodes) {
-        this.#knownNodes = dedupeNodes([...nodes, ...this.#knownNodes]);
+        // Newest first (dedupeNodes keeps order), then bound the table. Unbounded
+        // growth (the aggressive DHT population feeds this on every get_nodes
+        // reply) makes the hot distance-sort + memory grow without limit; a few
+        // hundred nodes is plenty to stay findable and to announce on the closest.
+        const merged = dedupeNodes([...nodes, ...this.#knownNodes]);
+        this.#knownNodes = merged.length > MAX_KNOWN_NODES ? merged.slice(0, MAX_KNOWN_NODES) : merged;
     }
     knownNodes() {
         return [...this.#knownNodes];
@@ -3715,12 +3724,23 @@ export class Peer {
         for (const node of this.#knownNodes) {
             if (!node.pk || node.isTcp)
                 continue;
-            try {
-                const pk = base58ToBytes(node.pk);
-                if (pk.length === 32)
-                    withPk.push({ node, pk });
+            // Cache the base58 decode on the node — this runs on every inbound
+            // get_nodes (as a DHT node we answer many), so decoding the whole table
+            // each time was burning CPU that grew with the table and starved the
+            // packet-forwarding loop (CCTV jitter that worsened over time).
+            let pk = node.pkBytes;
+            if (!pk) {
+                try {
+                    pk = base58ToBytes(node.pk);
+                }
+                catch {
+                    continue;
+                }
+                if (pk.length !== 32)
+                    continue;
+                node.pkBytes = pk;
             }
-            catch { /* skip malformed */ }
+            withPk.push({ node, pk });
         }
         withPk.sort((a, b) => xorCloser(target, a.pk, b.pk));
         return withPk.slice(0, limit).map((e) => e.node);

package/dist/types/peer.d.ts

@@ -11,6 +11,10 @@ export type NetworkNode = {
      * relays this way in DHT-PK extras.
      */
     isTcp?: boolean;
+    /** Decoded 32-byte form of `pk`, cached lazily on first use so the hot
+     *  DHT-distance sort (#closestKnownNodes, run on every get_nodes we answer)
+     *  doesn't base58-decode the whole table on every call. */
+    pkBytes?: Uint8Array;
 };
 export type PeerOptions = {
     keyFile: string;

package/package.json

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