@decentnetwork/peer 0.1.42 → 0.1.44

package/dist/compat/filetransfer.d.ts

@@ -0,0 +1,58 @@
+export declare const PACKET_ID_FILE_SENDREQUEST = 80;
+export declare const PACKET_ID_FILE_CONTROL = 81;
+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 FILECONTROL: {
+    readonly ACCEPT: 0;
+    readonly PAUSE: 1;
+    readonly KILL: 2;
+    readonly SEEK: 3;
+};
+export declare const FILEKIND: {
+    readonly DATA: 0;
+    readonly AVATAR: 1;
+};
+export declare function encodeFileSendRequest(fileNumber: number, fileType: number, fileSize: bigint, fileId: Uint8Array, filename: string): Uint8Array;
+export declare function parseFileSendRequest(p: Uint8Array): {
+    fileNumber: number;
+    fileType: number;
+    fileSize: bigint;
+    fileId: Uint8Array;
+    filename: string;
+} | undefined;
+export declare function encodeFileControl(sendReceive: number, fileNumber: number, controlType: number, data?: Uint8Array): Uint8Array;
+export declare function parseFileControl(p: Uint8Array): {
+    sendReceive: number;
+    fileNumber: number;
+    controlType: number;
+    data: Uint8Array;
+} | undefined;
+export declare function encodeFileData(fileNumber: number, data: Uint8Array): Uint8Array;
+export declare function parseFileData(p: Uint8Array): {
+    fileNumber: number;
+    data: Uint8Array;
+} | undefined;
+export type FtSend = (friendId: string, packetId: number, payload: Uint8Array) => Promise<unknown>;
+export type FtEmit = (event: string, payload: Record<string, unknown>) => void;
+export declare class FileTransferManager {
+    #private;
+    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

@@ -0,0 +1,240 @@
+// 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.
+//
+// Wire (messenger packet payloads):
+//   FILE_SENDREQUEST(80): [filenum(1)][file_type u32 BE][file_size u64 BE][file_id(32)][filename(≤255)]
+//   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)
+// send_receive: 1 ⇒ filenum is in the RECIPIENT's *sending* table, 0 ⇒ *receiving*.
+import { concatBytes, randomBytes } from "../utils/bytes.js";
+export const PACKET_ID_FILE_SENDREQUEST = 80;
+export const PACKET_ID_FILE_CONTROL = 81;
+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 };
+export const FILEKIND = { DATA: 0, AVATAR: 1 };
+function u32be(n) {
+    const b = new Uint8Array(4);
+    b[0] = (n >>> 24) & 0xff;
+    b[1] = (n >>> 16) & 0xff;
+    b[2] = (n >>> 8) & 0xff;
+    b[3] = n & 0xff;
+    return b;
+}
+function u64be(n) {
+    const b = new Uint8Array(8);
+    let v = n;
+    for (let i = 7; i >= 0; i--) {
+        b[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return b;
+}
+function readU32be(b, o) {
+    return ((b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]) >>> 0;
+}
+function readU64be(b, o) {
+    let v = 0n;
+    for (let i = 0; i < 8; i++)
+        v = (v << 8n) | BigInt(b[o + i]);
+    return v;
+}
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+export function encodeFileSendRequest(fileNumber, fileType, fileSize, fileId, filename) {
+    const nameBytes = enc.encode(filename).slice(0, MAX_FILENAME_LENGTH);
+    return concatBytes([Uint8Array.of(fileNumber & 0xff), u32be(fileType), u64be(fileSize), fileId.slice(0, FILE_ID_LENGTH), nameBytes]);
+}
+export function parseFileSendRequest(p) {
+    if (p.length < 1 + 4 + 8 + FILE_ID_LENGTH)
+        return undefined;
+    return {
+        fileNumber: p[0],
+        fileType: readU32be(p, 1),
+        fileSize: readU64be(p, 5),
+        fileId: p.slice(13, 13 + FILE_ID_LENGTH),
+        filename: dec.decode(p.slice(13 + FILE_ID_LENGTH)),
+    };
+}
+export function encodeFileControl(sendReceive, fileNumber, controlType, data) {
+    const head = Uint8Array.of(sendReceive & 1, fileNumber & 0xff, controlType & 0xff);
+    return data && data.length ? concatBytes([head, data]) : head;
+}
+export function parseFileControl(p) {
+    if (p.length < 3)
+        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 parseFileData(p) {
+    if (p.length < 1)
+        return undefined;
+    return { fileNumber: p[0], data: p.slice(1) };
+}
+const hex = (b) => Buffer.from(b).toString("hex");
+export class FileTransferManager {
+    send;
+    emit;
+    // per friend → per fileNumber
+    #sending = new Map();
+    #receiving = new Map();
+    constructor(send, emit) {
+        this.send = send;
+        this.emit = emit;
+    }
+    #map(m, friendId) {
+        let inner = m.get(friendId);
+        if (!inner) {
+            inner = new Map();
+            m.set(friendId, inner);
+        }
+        return inner;
+    }
+    #freeNumber(friendId) {
+        const inner = this.#map(this.#sending, friendId);
+        for (let i = 0; i < MAX_CONCURRENT_FILE_PIPES; i++)
+            if (!inner.has(i))
+                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 };
+        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)
+            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);
+    }
+    /** 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);
+    }
+    /** 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);
+            return true;
+        }
+        if (packetId === PACKET_ID_FILE_CONTROL) {
+            this.#onControl(friendId, payload);
+            return true;
+        }
+        if (packetId === PACKET_ID_FILE_DATA) {
+            this.#onData(friendId, payload);
+            return true;
+        }
+        return false;
+    }
+    #onSendRequest(friendId, payload) {
+        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 };
+        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 });
+    }
+    #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) {
+            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.KILL) {
+                this.#map(this.#sending, friendId).delete(c.fileNumber);
+                this.emit("file-cancel", { friendId, fileId: hex(st.fileId), sending: true });
+            }
+        }
+        else {
+            const st = this.#map(this.#receiving, friendId).get(c.fileNumber);
+            if (!st)
+                return;
+            if (c.controlType === FILECONTROL.KILL) {
+                this.#map(this.#receiving, friendId).delete(c.fileNumber);
+                this.emit("file-cancel", { friendId, fileId: hex(st.fileId), sending: false });
+            }
+        }
+    }
+    #onData(friendId, payload) {
+        const d = parseFileData(payload);
+        if (!d)
+            return;
+        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 });
+            return;
+        }
+        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 });
+        }
+    }
+    // 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;
+        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
+            }
+            // 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 });
+        }
+        catch {
+            this.#map(this.#sending, friendId).delete(st.fileNumber);
+        }
+    }
+    /** Drop all transfers for a friend (e.g. on disconnect). */
+    clearFriend(friendId) {
+        this.#sending.delete(friendId);
+        this.#receiving.delete(friendId);
+    }
+}

package/dist/peer.d.ts

@@ -90,6 +90,51 @@ export declare class Peer {
      * {@link sendCustomPacket}.
      */
     onCustomPacket(cb: (evt: CustomPacketEvent) => void): void;
+    /**
+     * Offer a file to a friend (by userid). Returns the fileId (hex) or null if
+     * the friend has no free transfer slot. The recipient gets an `onFile` offer;
+     * once they `acceptFile`, chunks stream over the reliable net_crypto channel.
+     */
+    sendFile(userid: string, data: Uint8Array, opts: {
+        name: string;
+        kind?: number;
+    }): string | null;
+    /** Accept an incoming file offer (the `fileNumber` from the onFile event). */
+    acceptFile(userid: string, fileNumber: number): void;
+    /** Cancel a transfer (isSending = true if we're the sender). */
+    cancelFile(userid: string, fileNumber: number, isSending?: boolean): void;
+    /** Incoming file offer: { friendId, fileNumber, fileId, name, size, kind }. */
+    onFile(cb: (offer: {
+        friendId: string;
+        fileNumber: number;
+        fileId: string;
+        name: string;
+        size: number;
+        kind: number;
+    }) => void): void;
+    /** Transfer progress: { friendId, fileId, received, total, sending? }. */
+    onFileProgress(cb: (p: {
+        friendId: string;
+        fileId: string;
+        received: number;
+        total: number;
+        sending?: boolean;
+    }) => void): void;
+    /** Transfer complete: { friendId, fileId, name, size, data?, sending? } (data present on the receiver). */
+    onFileComplete(cb: (p: {
+        friendId: string;
+        fileId: string;
+        name: string;
+        size: number;
+        data?: Uint8Array;
+        sending?: boolean;
+    }) => void): void;
+    /** Transfer cancelled by the peer: { friendId, fileId, sending }. */
+    onFileCancel(cb: (p: {
+        friendId: string;
+        fileId: string;
+        sending: boolean;
+    }) => void): void;
     onFriendConnection(cb: (ev: FriendConnectionEvent) => void): void;
     onFriendInfo(cb: (ev: FriendInfoEvent) => void): void;
     friends(): FriendRecord[];

package/dist/peer.js

@@ -9,6 +9,7 @@ import { PACKET_TYPE_MESSAGE, PACKET_TYPE_FRIEND_REQUEST, PACKET_TYPE_USERINFO,
 import { NET_PACKET_ONION_ANNOUNCE_RESPONSE, NET_PACKET_ONION_DATA_RESPONSE, ONION_FRIEND_REQUEST_ID, createOnionAnnounceRequest, createOnionDataPacket, createOnionDataRequest, createOnionRequest0, openOnionAnnounceResponse, openOnionDataPacket, openOnionDataResponse } from "./compat/tox-onion.js";
 import { CRYPTO_PACKET_DHTPK, CRYPTO_PACKET_FRIEND_REQ, NET_PACKET_CRYPTO, createToxDhtCryptoRequest, openToxDhtCryptoRequest } from "./compat/tox-dht-crypto.js";
 import { NET_PACKET_PING_REQUEST, NET_PACKET_PING_RESPONSE, NET_PACKET_GET_NODES, NET_PACKET_SEND_NODES, encodeDhtRpc, decodeDhtRpc, buildPingPlain, parsePingPlain, buildGetNodesPlain, parseGetNodesPlain, buildSendNodesPlain, parseSendNodesNodeBytes, packUdpNodeV4 } from "./compat/dht-rpc.js";
+import { FileTransferManager } from "./compat/filetransfer.js";
 import { NET_PACKET_CRYPTO_DATA, NET_PACKET_CRYPTO_HS, NET_PACKET_COOKIE_REQUEST, NET_PACKET_COOKIE_RESPONSE, createCookieRequest, createCookieResponse, createCryptoDataPacket, createCryptoHandshake, openCookieRequest, openCookieResponse, openCryptoDataPacket, openCryptoHandshake, incrementNonce } from "./compat/net-crypto.js";
 import { LegacyExpressClient } from "./compat/express.js";
 import { TcpRelayPool } from "./compat/tcp-relay-pool.js";
@@ -149,6 +150,8 @@ const PACKET_ID_UDP_ENDPOINT = 160;
 export class Peer {
     #opts;
     #events = new EventEmitter();
+    // Toxcore-standard file transfer (wire-compatible with native Carrier/toxcore).
+    #fileTransfer = new FileTransferManager((friendId, packetId, payload) => this.#sendMessengerPacket(friendId, packetId, payload), (event, payload) => { this.#events.emit(event, payload); });
     #keyPair;
     #udp = new UdpTransport();
     // TURN relay (stable fallback path). One node-level allocation on its own
@@ -945,6 +948,29 @@ export class Peer {
     onCustomPacket(cb) {
         this.#events.on("customPacket", cb);
     }
+    // ───────────────────── file transfer (toxcore-standard, native-ready) ─────
+    /**
+     * Offer a file to a friend (by userid). Returns the fileId (hex) or null if
+     * the friend has no free transfer slot. The recipient gets an `onFile` offer;
+     * once they `acceptFile`, chunks stream over the reliable net_crypto channel.
+     */
+    sendFile(userid, data, opts) {
+        if (!this.#friends.get(userid))
+            throw new Error(`Not a friend: ${userid}`);
+        return this.#fileTransfer.sendFile(userid, data, opts);
+    }
+    /** Accept an incoming file offer (the `fileNumber` from the onFile event). */
+    acceptFile(userid, fileNumber) { this.#fileTransfer.accept(userid, fileNumber); }
+    /** Cancel a transfer (isSending = true if we're the sender). */
+    cancelFile(userid, fileNumber, isSending = false) { this.#fileTransfer.cancel(userid, fileNumber, isSending); }
+    /** Incoming file offer: { friendId, fileNumber, fileId, name, size, kind }. */
+    onFile(cb) { this.#events.on("file-offer", cb); }
+    /** Transfer progress: { friendId, fileId, received, total, sending? }. */
+    onFileProgress(cb) { this.#events.on("file-progress", cb); }
+    /** Transfer complete: { friendId, fileId, name, size, data?, sending? } (data present on the receiver). */
+    onFileComplete(cb) { this.#events.on("file-complete", cb); }
+    /** Transfer cancelled by the peer: { friendId, fileId, sending }. */
+    onFileCancel(cb) { this.#events.on("file-cancel", cb); }
     onFriendConnection(cb) {
         this.#events.on("friendConnection", cb);
     }
@@ -1511,6 +1537,16 @@ export class Peer {
                 if (!opened) {
                     continue;
                 }
+                // De-duplicate. The dual-send path delivers each lossless packet over
+                // BOTH the UDP and relay transports with the SAME packet number, so
+                // without this guard every chat message (and every file-data chunk) is
+                // dispatched — and stored / shown / appended — twice. Drop anything at or
+                // below the receive low-water mark, like toxcore net_crypto drops packets
+                // below buffer_start. Must run BEFORE the nonce advance below so a
+                // duplicate doesn't desync the receive nonce.
+                if (opened.packetNumber < (state.receiveBufferStart ?? 0)) {
+                    continue;
+                }
                 state.peerBaseNonce[state.peerBaseNonce.length - 2] = packet[1];
                 state.peerBaseNonce[state.peerBaseNonce.length - 1] = packet[2];
                 incrementNonce(state.peerBaseNonce);
@@ -1539,6 +1575,9 @@ export class Peer {
                 state.receiveBufferStart = Math.max(state.receiveBufferStart ?? 0, (opened.packetNumber + 1) >>> 0);
                 const kind = opened.payload[0];
                 const inner = opened.payload.slice(1);
+                // Toxcore file transfer (FILE_SENDREQUEST/CONTROL/DATA = 80/81/82).
+                if (this.#fileTransfer.handlePacket(friendId, kind, inner))
+                    return;
                 if (kind === PACKET_ID_ONLINE) {
                     this.#setFriendOnline(friendId, remote.address, remote.port);
                     this.#debugLog(`crypto online packet received from ${friendId}`);

package/package.json

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