@decentnetwork/peer 0.1.46 → 0.1.48

package/dist/crypto/sign.d.ts

@@ -1 +1,12 @@
-export declare function signDetached(_payload: Uint8Array): Promise<never>;
+export declare const SIGNATURE_LENGTH = 64;
+/**
+ * Produce a detached XEdDSA signature over `message` using a 32-byte X25519
+ * secret key (a Carrier identity secret key). Returns a 64-byte signature.
+ */
+export declare function signDetached(secretKey: Uint8Array, message: Uint8Array): Uint8Array;
+/**
+ * Verify a detached XEdDSA signature against a 32-byte X25519 public key
+ * (decode the userid to get it). Returns false on any malformed input rather
+ * than throwing, so callers can treat it as a plain predicate.
+ */
+export declare function verifyDetached(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;

package/dist/crypto/sign.js

@@ -1,3 +1,44 @@
-export async function signDetached(_payload) {
-    throw new Error("Legacy-compatible signing is not implemented yet");
+// Detached signatures over a Carrier identity's key.
+//
+// A Carrier/toxcore identity key is an X25519 (Curve25519) key pair — the
+// same key used for crypto_box, and the public half IS the userid (base58).
+// X25519 keys can't be fed to Ed25519 (nacl.sign) directly, so we use XEdDSA
+// (Signal's scheme): sign with the Montgomery/X25519 private key, and verify
+// against the X25519 public key. A relying party (e.g. a website doing
+// "Sign in with Decent") decodes the userid → 32-byte X25519 public key and
+// verifies with the same primitive — no separate signing key, no new key
+// derivation path, the signature is bound to the identity itself.
+//
+// curve25519-js implements XEdDSA sign/verify; randomization (64 bytes) makes
+// signatures non-deterministic per the spec. Verification is independent of
+// the random used.
+import { sign as xeddsaSign, verify as xeddsaVerify } from "curve25519-js";
+import nacl from "tweetnacl";
+export const SIGNATURE_LENGTH = 64;
+/**
+ * Produce a detached XEdDSA signature over `message` using a 32-byte X25519
+ * secret key (a Carrier identity secret key). Returns a 64-byte signature.
+ */
+export function signDetached(secretKey, message) {
+    if (secretKey.length !== nacl.box.secretKeyLength) {
+        throw new Error(`secretKey must be ${nacl.box.secretKeyLength} bytes`);
+    }
+    const random = nacl.randomBytes(64);
+    return xeddsaSign(secretKey, message, random);
+}
+/**
+ * Verify a detached XEdDSA signature against a 32-byte X25519 public key
+ * (decode the userid to get it). Returns false on any malformed input rather
+ * than throwing, so callers can treat it as a plain predicate.
+ */
+export function verifyDetached(publicKey, message, signature) {
+    if (publicKey.length !== nacl.box.publicKeyLength || signature.length !== SIGNATURE_LENGTH) {
+        return false;
+    }
+    try {
+        return xeddsaVerify(publicKey, message, signature);
+    }
+    catch {
+        return false;
+    }
 }

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { CARRIER_ADDRESS_SIZE, CARRIER_PUBLIC_KEY_SIZE, carrierAddressFromPublic
 export { PACKET_TYPE_FRIEND_REQUEST, PACKET_TYPE_MESSAGE, decodeCarrierPacket, encodeFriendMessagePacket, encodeFriendRequestPacket } from "./compat/packet.js";
 export { CRYPTO_PACKET_DHTPK, CRYPTO_PACKET_FRIEND_REQ, CRYPTO_PACKET_NAT_PING, NET_PACKET_CRYPTO, createToxDhtCryptoRequest, openToxDhtCryptoRequest } from "./compat/tox-dht-crypto.js";
 export { NET_PACKET_ONION_ANNOUNCE_REQUEST, NET_PACKET_ONION_ANNOUNCE_RESPONSE, NET_PACKET_ONION_DATA_REQUEST, NET_PACKET_ONION_DATA_RESPONSE, ONION_FRIEND_REQUEST_ID } from "./compat/tox-onion.js";
+export { signDetached, verifyDetached, SIGNATURE_LENGTH } from "./crypto/sign.js";
+export { base58ToBytes, bytesToBase58 } from "./utils/base58.js";
 export { LegacyProtocolNotImplementedError } from "./runtime/errors.js";
 export type { CarrierPacket, FriendMessagePacket, FriendRequestPacket } from "./compat/packet.js";
 export type { ToxDhtCryptoRequest } from "./compat/tox-dht-crypto.js";

package/dist/index.js

@@ -3,4 +3,6 @@ export { CARRIER_ADDRESS_SIZE, CARRIER_PUBLIC_KEY_SIZE, carrierAddressFromPublic
 export { PACKET_TYPE_FRIEND_REQUEST, PACKET_TYPE_MESSAGE, decodeCarrierPacket, encodeFriendMessagePacket, encodeFriendRequestPacket } from "./compat/packet.js";
 export { CRYPTO_PACKET_DHTPK, CRYPTO_PACKET_FRIEND_REQ, CRYPTO_PACKET_NAT_PING, NET_PACKET_CRYPTO, createToxDhtCryptoRequest, openToxDhtCryptoRequest } from "./compat/tox-dht-crypto.js";
 export { NET_PACKET_ONION_ANNOUNCE_REQUEST, NET_PACKET_ONION_ANNOUNCE_RESPONSE, NET_PACKET_ONION_DATA_REQUEST, NET_PACKET_ONION_DATA_RESPONSE, ONION_FRIEND_REQUEST_ID } from "./compat/tox-onion.js";
+export { signDetached, verifyDetached, SIGNATURE_LENGTH } from "./crypto/sign.js";
+export { base58ToBytes, bytesToBase58 } from "./utils/base58.js";
 export { LegacyProtocolNotImplementedError } from "./runtime/errors.js";

package/dist/peer.d.ts

@@ -9,6 +9,14 @@ export declare class Peer {
     stop(): Promise<void>;
     pubkey(): string;
     userid(): string;
+    /**
+     * Sign `message` with this identity's private key (XEdDSA over the X25519
+     * key). The signature verifies against the userid — `verifyDetached(
+     * base58Decode(userid), message, sig)` — so a relying party that knows only
+     * the userid can prove the signer holds the matching key. Used by "Sign in
+     * with Decent". Returns a detached 64-byte signature.
+     */
+    sign(message: Uint8Array): Uint8Array;
     address(): string;
     joinNetwork(): Promise<BootstrapResult>;
     lookup(pubkey: string): Promise<LookupResult>;

package/dist/peer.js

@@ -9,12 +9,13 @@ 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 { FileTransferManager, PACKET_ID_FILE_SENDREQUEST, PACKET_ID_FILE_CONTROL, PACKET_ID_FILE_DATA } 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";
 import { LegacyDhtClient } from "./compat/dht.js";
 import { loadOrCreateKeyPair } from "./crypto/keypair.js";
+import { signDetached } from "./crypto/sign.js";
 import { base58ToBytes } from "./utils/base58.js";
 import { UdpTransport } from "./transport/udp.js";
 import { bytesToHex, concatBytes, randomBytes } from "./utils/bytes.js";
@@ -481,6 +482,19 @@ export class Peer {
         }
         return carrierIdFromPublicKey(this.#keyPair.publicKey);
     }
+    /**
+     * Sign `message` with this identity's private key (XEdDSA over the X25519
+     * key). The signature verifies against the userid — `verifyDetached(
+     * base58Decode(userid), message, sig)` — so a relying party that knows only
+     * the userid can prove the signer holds the matching key. Used by "Sign in
+     * with Decent". Returns a detached 64-byte signature.
+     */
+    sign(message) {
+        if (!this.#keyPair) {
+            throw new Error("Peer is not started");
+        }
+        return signDetached(this.#keyPair.secretKey, message);
+    }
     address() {
         if (!this.#keyPair) {
             throw new Error("Peer is not started");
@@ -2771,8 +2785,23 @@ export class Peer {
         // e.g. decentlan IP=163) stays bulk / single-transport to avoid the relay
         // backlog + duplicate fan-out that high packet rates cause. Chat is sparse
         // and net_crypto dedups by packet number, so dual-send is safe here.
-        const isBulkData = this.#opts.bulkDataPacketId !== undefined && kind === this.#opts.bulkDataPacketId;
-        await this.#sendToFriend(friendId, encrypted, session, isBulkData);
+        // File transfer (80 sendrequest / 81 control / 82 data) is ALSO treated as
+        // bulk → single-transport. It is high-volume AND order-sensitive: the
+        // receiver reassembles chunks SEQUENTIALLY (position is implicit) and there
+        // is no retransmit queue. Dual-sending it over UDP + relay (two paths with
+        // different latency) reorders the chunks, and the receive-side low-water
+        // dedup then drops the late copies — so a large file (mp4) gets gaps /
+        // wrong order and never completes, while a tiny one (png, 1-2 chunks)
+        // happens to finish before reordering bites. Pinning file transfer to a
+        // single transport keeps the chunks in send order. (Reliability across a
+        // lossy path still wants a reorder buffer + retransmit — tracked separately.)
+        const isFileTransfer = kind === PACKET_ID_FILE_SENDREQUEST || kind === PACKET_ID_FILE_CONTROL || kind === PACKET_ID_FILE_DATA;
+        const isBulkData = (this.#opts.bulkDataPacketId !== undefined && kind === this.#opts.bulkDataPacketId) || isFileTransfer;
+        // File transfer rides the relay RELIABLY (never dropped under backpressure):
+        // a dropped IP/CCTV packet is fine (the stream moves on), but a dropped file
+        // chunk corrupts the file (no retransmit). So bulk IP data stays droppable
+        // while file transfer is queued.
+        await this.#sendToFriend(friendId, encrypted, session, isBulkData, isFileTransfer);
     }
     /**
      * Send `packet` to `friendId` over whichever transport(s) are
@@ -2782,7 +2811,7 @@ export class Peer {
      * receiving end (toxcore does the same when both transports are up).
      * Throws only if zero transports succeeded.
      */
-    async #sendToFriend(friendId, packet, session, isBulkData = false) {
+    async #sendToFriend(friendId, packet, session, isBulkData = false, reliableOnRelay = false) {
         const s = session ?? this.#friendSessions.get(friendId);
         let udpOk = false;
         let tcpOk = false;
@@ -2862,7 +2891,9 @@ export class Peer {
                 // Bulk IP data is droppable over the relay: under backpressure the
                 // relay client drops it (bounded queue) rather than buffering seconds
                 // of packets. Control frames pass isBulkData=false and always queue.
-                const sent = this.#tcpRelays.sendToFriend(tcpKey, packet, isBulkData);
+                // File transfer is bulk (single-transport routing) but must NOT be
+                // dropped — a lost chunk corrupts the file — so it is queued reliably.
+                const sent = this.#tcpRelays.sendToFriend(tcpKey, packet, isBulkData && !reliableOnRelay);
                 if (sent > 0) {
                     tcpOk = true;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "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",
@@ -72,6 +72,7 @@
   },
   "dependencies": {
     "flatbuffers": "^25.9.23",
-    "tweetnacl": "^1.0.3"
+    "tweetnacl": "^1.0.3",
+    "curve25519-js": "^0.0.4"
   }
 }