@decentnetwork/peer 0.1.79 → 0.1.82

package/dist/compat/express.js

@@ -28,6 +28,7 @@ export class LegacyExpressClient {
             return {
                 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)
             };
         });
@@ -152,7 +153,8 @@ export class LegacyExpressClient {
         throw lastError instanceof Error ? lastError : new Error(String(lastError));
     }
     async #http(node, method, path, body) {
-        const url = `https://${node.host}:${node.port}/${path}`;
+        const scheme = node.tls ? "https" : "http";
+        const url = `${scheme}://${node.host}:${node.port}/${path}`;
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
         try {

package/dist/compat/net-crypto.d.ts

@@ -80,5 +80,9 @@ export declare function openCryptoDataPacket(packet: Uint8Array, opts: {
     bufferStart: number;
     packetNumber: number;
     nonceLast2: number;
+    /** The exact nonce this packet decrypted with. The caller must track
+     *  recvBaseNonce = usedNonce (+1 for the next expected) — NOT overwrite
+     *  just the low two bytes, which loses the carry into byte 21. */
+    usedNonce: Uint8Array;
 } | undefined;
 export declare function incrementNonce(nonce: Uint8Array): void;

package/dist/compat/net-crypto.js

@@ -191,9 +191,27 @@ export function openCryptoDataPacket(packet, opts) {
     if (packet.length <= CRYPTO_DATA_PACKET_MIN_SIZE || packet[0] !== NET_PACKET_CRYPTO_DATA) {
         return undefined;
     }
+    // The wire carries only the low 16 bits of the sender's nonce counter.
+    // Reconstruct the full nonce like toxcore handle_data_packet: advance a
+    // COPY of our tracked nonce by the uint16 difference WITH CARRY into the
+    // upper bytes. The old code overwrote the two low bytes in place, which
+    // silently dropped the carry whenever packet loss spanned a 64k nonce
+    // wrap — from then on EVERY packet failed to decrypt until re-handshake
+    // (observed as endless "no session matched" from high-rate peers, whose
+    // counters wrap every ~30-60s of CCTV/file traffic).
     const nonce = opts.recvBaseNonce.slice();
-    nonce[nonce.length - 2] = packet[1];
-    nonce[nonce.length - 1] = packet[2];
+    const trackedLow = ((nonce[nonce.length - 2] << 8) | nonce[nonce.length - 1]) >>> 0;
+    const wireLow = ((packet[1] << 8) | packet[2]) >>> 0;
+    const diff = (wireLow - trackedLow) & 0xffff;
+    if (diff < 0x8000) {
+        addToNonceCounter(nonce, diff);
+    }
+    else {
+        // The wire counter is BEHIND our tracked one — a reordered/duplicate
+        // packet from earlier in the stream (dual-path UDP+relay delivery
+        // reorders constantly). Step backward with borrow.
+        subFromNonceCounter(nonce, 0x10000 - diff);
+    }
     const cipher = packet.slice(3);
     const plain = nacl.secretbox.open(cipher, nonce, opts.sessionSharedKey);
     if (!plain || plain.length <= CRYPTO_DATA_PLAIN_HEADER_LENGTH) {
@@ -212,9 +230,29 @@ export function openCryptoDataPacket(packet, opts) {
         payload: plain.slice(payloadOffset),
         bufferStart,
         packetNumber,
-        nonceLast2: ((packet[1] << 8) | packet[2]) >>> 0
+        nonceLast2: ((packet[1] << 8) | packet[2]) >>> 0,
+        usedNonce: nonce
     };
 }
+/** Add `count` to the big-endian nonce counter with carry (toxcore
+ *  increment_nonce_number). */
+function addToNonceCounter(nonce, count) {
+    let carry = count >>> 0;
+    for (let i = nonce.length - 1; i >= 0 && carry > 0; i--) {
+        const sum = nonce[i] + (carry & 0xff);
+        nonce[i] = sum & 0xff;
+        carry = (carry >>> 8) + (sum > 0xff ? 1 : 0);
+    }
+}
+/** Subtract `count` from the big-endian nonce counter with borrow. */
+function subFromNonceCounter(nonce, count) {
+    let borrow = count >>> 0;
+    for (let i = nonce.length - 1; i >= 0 && borrow > 0; i--) {
+        const sub = nonce[i] - (borrow & 0xff);
+        nonce[i] = sub & 0xff;
+        borrow = (borrow >>> 8) + (sub < 0 ? 1 : 0);
+    }
+}
 function createCookie(opts) {
     const timestamp = BigInt(Math.floor(Date.now() / 1000));
     const contents = concatBytes([

package/dist/compat/packet.d.ts

@@ -1,6 +1,9 @@
 export declare const PACKET_TYPE_USERINFO = 3;
 export declare const PACKET_TYPE_FRIEND_REQUEST = 6;
 export declare const PACKET_TYPE_MESSAGE = 33;
+export declare const PACKET_TYPE_BULKMSG = 36;
+export declare const CARRIER_MAX_APP_MESSAGE_LEN = 1024;
+export declare const CARRIER_MAX_APP_BULKMSG_LEN: number;
 export type UserInfoPacket = {
     type: typeof PACKET_TYPE_USERINFO;
     avatar: boolean;
@@ -22,7 +25,16 @@ export type FriendMessagePacket = {
     ext?: string;
     data: Uint8Array;
 };
-export type CarrierPacket = UserInfoPacket | FriendRequestPacket | FriendMessagePacket;
+export type BulkMsgPacket = {
+    type: typeof PACKET_TYPE_BULKMSG;
+    ext?: string;
+    /** Full message length — set on the FIRST fragment only, 0 on the rest. */
+    totalsz: number;
+    /** Shared id linking all fragments of one message. */
+    tid: bigint;
+    data: Uint8Array;
+};
+export type CarrierPacket = UserInfoPacket | FriendRequestPacket | FriendMessagePacket | BulkMsgPacket;
 /**
  * Encode a Carrier `userinfo` packet (FB type 3). The Carrier C SDK sends
  * this every time the local user's name / status message / profile fields
@@ -52,4 +64,15 @@ export declare function encodeFriendRequestPacket(opts: {
     hello?: string;
 }): Uint8Array;
 export declare function encodeFriendMessagePacket(data: Uint8Array | string, ext?: string): Uint8Array;
+/**
+ * Encode one Carrier `bulkmsg` fragment (PACKET_TYPE_BULKMSG = 36). Field
+ * layout per src/carrier/packet.fbs: 0=ext string, 1=totalsz uint,
+ * 2=tid long, 3=data [ubyte]. Mirrors the C SDK's send_bulk_message.
+ */
+export declare function encodeBulkMsgPacket(opts: {
+    ext?: string;
+    totalsz: number;
+    tid: bigint;
+    data: Uint8Array;
+}): Uint8Array;
 export declare function decodeCarrierPacket(bytes: Uint8Array): CarrierPacket;

package/dist/compat/packet.js

@@ -2,12 +2,20 @@ import { Builder, ByteBuffer, Encoding } from "flatbuffers";
 export const PACKET_TYPE_USERINFO = 3;
 export const PACKET_TYPE_FRIEND_REQUEST = 6;
 export const PACKET_TYPE_MESSAGE = 33;
+export const PACKET_TYPE_BULKMSG = 36;
+// Carrier C SDK message-size constants (carrier.h). A single friendmsg may
+// carry at most 1024 bytes; anything larger is split into BULKMSG fragments
+// of <=1024 raw bytes sharing one tid (totalsz set on the FIRST fragment
+// only), reassembled in arrival order by the receiver.
+export const CARRIER_MAX_APP_MESSAGE_LEN = 1024;
+export const CARRIER_MAX_APP_BULKMSG_LEN = 5 * 1024 * 1024;
 // Body type indices into FlatBuffers `anybody` union (carrier/packet.fbs).
 // The .fbs declares: userinfo, friendreq, friendmsg, invitereq, invitersp,
 // bulkmsg — flatbuffers maps those to 1, 2, 3, 4, 5, 6 (NONE = 0).
 const ANYBODY_USERINFO = 1;
 const ANYBODY_FRIENDREQ = 2;
 const ANYBODY_FRIENDMSG = 3;
+const ANYBODY_BULKMSG = 6;
 /**
  * Encode a Carrier `userinfo` packet (FB type 3). The Carrier C SDK sends
  * this every time the local user's name / status message / profile fields
@@ -69,6 +77,29 @@ export function encodeFriendMessagePacket(data, ext) {
     const friendMsg = builder.endObject();
     return finishCarrierPacket(builder, PACKET_TYPE_MESSAGE, ANYBODY_FRIENDMSG, friendMsg);
 }
+/**
+ * Encode one Carrier `bulkmsg` fragment (PACKET_TYPE_BULKMSG = 36). Field
+ * layout per src/carrier/packet.fbs: 0=ext string, 1=totalsz uint,
+ * 2=tid long, 3=data [ubyte]. Mirrors the C SDK's send_bulk_message.
+ */
+export function encodeBulkMsgPacket(opts) {
+    const builder = new Builder(opts.data.length + 128);
+    const dataOffset = builder.createByteVector(opts.data);
+    const extOffset = opts.ext ? builder.createString(opts.ext) : 0;
+    builder.startObject(4);
+    builder.addFieldOffset(3, dataOffset, 0);
+    if (opts.tid !== 0n) {
+        builder.addFieldInt64(2, opts.tid, BigInt(0));
+    }
+    if (opts.totalsz) {
+        builder.addFieldInt32(1, opts.totalsz, 0);
+    }
+    if (extOffset) {
+        builder.addFieldOffset(0, extOffset, 0);
+    }
+    const bulk = builder.endObject();
+    return finishCarrierPacket(builder, PACKET_TYPE_BULKMSG, ANYBODY_BULKMSG, bulk);
+}
 export function decodeCarrierPacket(bytes) {
     const bb = new ByteBuffer(bytes);
     const root = bb.readInt32(bb.position()) + bb.position();
@@ -106,6 +137,15 @@ export function decodeCarrierPacket(bytes) {
             data: readByteVectorField(body, 1) ?? new Uint8Array()
         };
     }
+    if (type === PACKET_TYPE_BULKMSG && bodyType === ANYBODY_BULKMSG) {
+        return {
+            type,
+            ext: readStringField(body, 0) ?? undefined,
+            totalsz: readUint32Field(body, 1),
+            tid: readInt64Field(body, 2),
+            data: readByteVectorField(body, 3) ?? new Uint8Array()
+        };
+    }
     throw new Error(`unsupported carrier packet type/body: ${type}/${bodyType}`);
 }
 function finishCarrierPacket(builder, type, bodyType, bodyOffset) {
@@ -125,6 +165,14 @@ function readUint8Field(table, field) {
     const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
     return offset ? table.bb.readUint8(table.bb_pos + offset) : 0;
 }
+function readUint32Field(table, field) {
+    const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
+    return offset ? table.bb.readUint32(table.bb_pos + offset) : 0;
+}
+function readInt64Field(table, field) {
+    const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
+    return offset ? table.bb.readInt64(table.bb_pos + offset) : BigInt(0);
+}
 function readStringField(table, field) {
     const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
     if (!offset) {

package/dist/compat/tcp-relay-pool.js

@@ -23,7 +23,17 @@ import { EventEmitter } from "node:events";
 import { base58ToBytes } from "../utils/base58.js";
 import { TcpRelayClient } from "./tcp-relay.js";
 const KEY_SIZE = 32;
-const MAX_RELAY_CONNECTIONS = 3;
+// Connect to (up to) this many bootstrap nodes as persistent TCP relays. It was
+// 3 — but the pool picks the FIRST N in order, so a peer only met friends whose
+// relays happened to be in its own top-3. A NATIVE peer (iOS/Android) reaches us
+// ONLY over a relay we both sit on (OOB cookie handshake); if our top-3 doesn't
+// include the relay it uses, it's stuck "connecting" forever — even though we
+// share the node further down the list (observed: iOS uses sh.callt.net =
+// 47.100.103.201 as its #1 relay, which sat at #7 in our bootstrap so we never
+// connected to it). Covering more of the shared bootstrap set makes the same-
+// relay rendezvous reliable for native peers. Cheap: a handful of extra idle TCP
+// keepalives.
+const MAX_RELAY_CONNECTIONS = 8;
 const RECONNECT_BASE_MS = 5_000;
 const RECONNECT_MAX_MS = 120_000;
 export class TcpRelayPool extends EventEmitter {

package/dist/peer.d.ts

@@ -1,6 +1,6 @@
 import { type BootstrapResult } from "./compat/bootstrap.js";
 import type { FriendRecord } from "./store/friends.js";
-import type { CustomPacketEvent, FriendConnectionEvent, FriendRequest, FriendInfoEvent, LookupResult, NetworkNode, PeerOptions, TextMessage } from "./types/peer.js";
+import type { CustomPacketEvent, FriendConnectionEvent, FriendRequest, FriendInfoEvent, InlineFileEvent, LookupResult, NetworkNode, PeerOptions, TextMessage } from "./types/peer.js";
 export declare class Peer {
     #private;
     private constructor();
@@ -82,6 +82,23 @@ export declare class Peer {
     waitForFriendConnected(pubkey: string, timeoutMs?: number): Promise<boolean>;
     onFriendRequest(cb: (req: FriendRequest) => void): void;
     onText(cb: (msg: TextMessage) => void): void;
+    /** Files received inline over (bulk)messages — the iOS/C Carrier apps'
+     *  native way of sending images/audio online (FileModel JSON envelope). */
+    onInlineFile(cb: (evt: InlineFileEvent) => void): void;
+    /**
+     * Send a file INLINE over the message channel the way iOS/C Carrier apps
+     * do: a FileModel JSON envelope ({data: base64, fileExtension, fileName,
+     * type}) carried as a (bulk)message. This is the ONLY file path a native
+     * Beagle client can receive online — the toxcore file transfer (80-82)
+     * used by sendFile() is invisible to the Carrier C SDK. Best for images
+     * and small files; the hard protocol cap is ~5MB (base64-inflated), keep
+     * real use well below it.
+     */
+    sendInlineFile(pubkey: string, opts: {
+        name: string;
+        data: Uint8Array;
+        fileType?: "image" | "audio" | "text" | "unknown";
+    }): Promise<void>;
     /**
      * Send an application-defined custom packet to a friend. `id` selects the
      * channel and its delivery class by toxcore range: **160–191 lossless**