@decentnetwork/peer 0.1.45 → 0.1.47

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

@@ -15,6 +15,7 @@ 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");
@@ -3814,6 +3828,27 @@ export class Peer {
         if (typeof this.#dhtMaintenanceTimer.unref === "function")
             this.#dhtMaintenanceTimer.unref();
         void this.#doDhtMaintenance().catch(() => undefined); // become findable right after join
+        // Fast initial population. The steady 15s cadence converges far too
+        // slowly from a cold table — a fresh peer sat at ~14 known nodes, which
+        // is too sparse for the onion announce to store on the nodes truly
+        // closest to our key (the ones native clients query when searching for
+        // us). Run a few quick rounds up front to fill the table within seconds
+        // so the announce can reach storing nodes and we become discoverable.
+        for (const delay of [1200, 3000, 5500, 9000, 13000]) {
+            const t = setTimeout(() => void this.#doDhtMaintenance().catch(() => undefined), delay);
+            if (typeof t.unref === "function")
+                t.unref();
+        }
+        // The join-time announce ran against a near-empty table, so it stored on
+        // few/no nodes. Re-announce once the burst above has populated the table
+        // (~10s) so our FIRST useful announce lands on the genuinely-closest
+        // nodes — the difference between "discoverable within seconds" and "not
+        // until the 20s steady-state timer happens to converge".
+        for (const delay of [10000, 18000]) {
+            const a = setTimeout(() => void this.#runSelfAnnounce(true, Date.now() + 8000).catch(() => undefined), delay);
+            if (typeof a.unref === "function")
+                a.unref();
+        }
     }
     async #doDhtMaintenance() {
         if (!this.#keyPair)
@@ -3824,6 +3859,22 @@ export class Peer {
         for (const node of this.#closestKnownNodes(selfPk, 8)) {
             void this.#sendDhtGetNodes(node, selfPk);
         }
+        // 1b. Fill the routing table ACROSS the keyspace via random-target
+        //     searches. toxcore keeps random DHT search slots so the table isn't
+        //     clustered only near self; without this a JS peer's table stayed tiny
+        //     (~14-97 nodes) and the onion announce could only store on a sparse,
+        //     far-from-closest subset that native searchers never query — so they
+        //     couldn't discover the JS peer by address. A fuller table lets the
+        //     announce reach the genuinely-closest nodes. Search harder while the
+        //     table is small, then taper to a steady refresh.
+        const small = this.#knownNodes.length < 150;
+        const randomSearches = this.#knownNodes.length < 60 ? 6 : small ? 4 : 2;
+        for (let i = 0; i < randomSearches; i++) {
+            const target = randomBytes(32);
+            for (const node of this.#closestKnownNodes(target, small ? 6 : 4)) {
+                void this.#sendDhtGetNodes(node, target);
+            }
+        }
         // 2. For each friend not on a confirmed UDP path, get_nodes toward THEIR
         //    DHT key → learn their UDP endpoint → punch from our side.
         for (const [, session] of this.#friendSessions.entries()) {

package/package.json

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