zapo-js 0.1.0

package/dist/esm/crypto/core/random.js

@@ -0,0 +1,28 @@
+import { randomBytes, randomInt } from 'node:crypto';
+import { toBytesView } from '../../util/bytes.js';
+/**
+ * Generates cryptographically secure random bytes
+ */
+export function randomBytesAsync(size) {
+    return new Promise((resolve, reject) => {
+        randomBytes(size, (error, buffer) => {
+            if (error)
+                reject(error);
+            else
+                resolve(toBytesView(buffer));
+        });
+    });
+}
+/**
+ * Generates a cryptographically secure random integer in the range [min, max)
+ */
+export function randomIntAsync(min, max) {
+    return new Promise((resolve, reject) => {
+        randomInt(min, max, (error, value) => {
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        });
+    });
+}

package/dist/esm/crypto/curves/Ed25519.js

@@ -0,0 +1,38 @@
+import { webcrypto } from 'node:crypto';
+import { assert32, decodeBase64Url } from '../core/encoding.js';
+import { ED25519_PKCS8_PREFIX } from '../curves/constants.js';
+import { pkcs8FromRawPrivate } from '../curves/types.js';
+import { toBytesView } from '../../util/bytes.js';
+export class Ed25519 {
+    static async generateKeyPair() {
+        const keys = (await webcrypto.subtle.generateKey({ name: 'Ed25519' }, true, [
+            'sign',
+            'verify'
+        ]));
+        const privateJwk = await webcrypto.subtle.exportKey('jwk', keys.privateKey);
+        return {
+            pubKey: decodeBase64Url(privateJwk.x, 'ed25519 public key'),
+            privKey: decodeBase64Url(privateJwk.d, 'ed25519 private key')
+        };
+    }
+    static async keyPairFromPrivateKey(privKey) {
+        assert32(privKey, 'ed25519 private key');
+        const privateKey = await webcrypto.subtle.importKey('pkcs8', pkcs8FromRawPrivate(ED25519_PKCS8_PREFIX, privKey), { name: 'Ed25519' }, true, ['sign']);
+        const privateJwk = await webcrypto.subtle.exportKey('jwk', privateKey);
+        return {
+            pubKey: decodeBase64Url(privateJwk.x, 'ed25519 public key'),
+            privKey: decodeBase64Url(privateJwk.d, 'ed25519 private key')
+        };
+    }
+    static async sign(message, privKey) {
+        assert32(privKey, 'ed25519 private key');
+        const privateKey = await webcrypto.subtle.importKey('pkcs8', pkcs8FromRawPrivate(ED25519_PKCS8_PREFIX, privKey), { name: 'Ed25519' }, false, ['sign']);
+        const signature = await webcrypto.subtle.sign('Ed25519', privateKey, message);
+        return toBytesView(signature);
+    }
+    static async verify(message, signature, pubKey) {
+        assert32(pubKey, 'ed25519 public key');
+        const publicKey = await webcrypto.subtle.importKey('raw', pubKey, { name: 'Ed25519' }, false, ['verify']);
+        return webcrypto.subtle.verify('Ed25519', publicKey, signature, message);
+    }
+}

package/dist/esm/crypto/curves/X25519.js

@@ -0,0 +1,58 @@
+import { webcrypto } from 'node:crypto';
+import { assert32, decodeBase64Url } from '../core/encoding.js';
+import { X25519_PKCS8_PREFIX } from '../curves/constants.js';
+import { pkcs8FromRawPrivate } from '../curves/types.js';
+import { bigIntToBytesLE, bytesToBigIntLE } from '../math/le.js';
+import { FIELD_P, mod, modInv } from '../math/mod.js';
+import { toBytesView } from '../../util/bytes.js';
+export function clampCurvePrivateKeyInPlace(privateKey) {
+    if (privateKey.length !== 32) {
+        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
+    }
+    privateKey[0] &= 248;
+    privateKey[31] &= 127;
+    privateKey[31] |= 64;
+    return privateKey;
+}
+export function montgomeryToEdwardsPublic(curvePublicKey, signBit) {
+    if (curvePublicKey.length !== 32) {
+        throw new Error(`invalid curve25519 public key length ${curvePublicKey.length}`);
+    }
+    const x = bytesToBigIntLE(curvePublicKey);
+    if (x === FIELD_P - 1n) {
+        throw new Error('invalid curve25519 low-order public key');
+    }
+    const y = mod((x - 1n) * modInv(x + 1n));
+    const encoded = bigIntToBytesLE(y, 32);
+    encoded[31] = (encoded[31] & 0x7f) | (signBit & 0x80);
+    return encoded;
+}
+export class X25519 {
+    static async generateKeyPair() {
+        const keys = (await webcrypto.subtle.generateKey({ name: 'X25519' }, true, [
+            'deriveBits'
+        ]));
+        const privateJwk = await webcrypto.subtle.exportKey('jwk', keys.privateKey);
+        return {
+            pubKey: decodeBase64Url(privateJwk.x, 'x25519 public key'),
+            privKey: decodeBase64Url(privateJwk.d, 'x25519 private key')
+        };
+    }
+    static async keyPairFromPrivateKey(privKey) {
+        assert32(privKey, 'x25519 private key');
+        const privateKey = await webcrypto.subtle.importKey('pkcs8', pkcs8FromRawPrivate(X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, true, ['deriveBits']);
+        const privateJwk = await webcrypto.subtle.exportKey('jwk', privateKey);
+        return {
+            pubKey: decodeBase64Url(privateJwk.x, 'x25519 public key'),
+            privKey: decodeBase64Url(privateJwk.d, 'x25519 private key')
+        };
+    }
+    static async scalarMult(privKey, pubKey) {
+        assert32(privKey, 'x25519 private key');
+        assert32(pubKey, 'x25519 public key');
+        const privateKey = await webcrypto.subtle.importKey('pkcs8', pkcs8FromRawPrivate(X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, false, ['deriveBits']);
+        const publicKey = await webcrypto.subtle.importKey('raw', pubKey, { name: 'X25519' }, false, []);
+        const sharedBits = await webcrypto.subtle.deriveBits({ name: 'X25519', public: publicKey }, privateKey, 256);
+        return toBytesView(sharedBits);
+    }
+}

package/dist/esm/crypto/curves/constants.js

@@ -0,0 +1,3 @@
+import { hexToBytes } from '../../util/bytes.js';
+export const X25519_PKCS8_PREFIX = hexToBytes('302e020100300506032b656e04220420');
+export const ED25519_PKCS8_PREFIX = hexToBytes('302e020100300506032b657004220420');

package/dist/esm/crypto/curves/types.js

@@ -0,0 +1,6 @@
+export function pkcs8FromRawPrivate(prefix, raw) {
+    const out = new Uint8Array(prefix.length + raw.length);
+    out.set(prefix, 0);
+    out.set(raw, prefix.length);
+    return out;
+}

package/dist/esm/crypto/index.js

@@ -0,0 +1,3 @@
+export * from './core/index.js';
+export { Ed25519 } from './curves/Ed25519.js';
+export { X25519 } from './curves/X25519.js';

package/dist/esm/crypto/math/constants.js

@@ -0,0 +1,41 @@
+export const FIELD_P = (1n << 255n) - 19n;
+export const GROUP_L = (1n << 252n) + 27742317777372353535851937790883648493n;
+function modField(value) {
+    const remainder = value % FIELD_P;
+    return remainder >= 0n ? remainder : remainder + FIELD_P;
+}
+function modPowField(base, exponent) {
+    let result = 1n;
+    let current = modField(base);
+    let power = exponent;
+    while (power > 0n) {
+        if ((power & 1n) === 1n) {
+            result = modField(result * current);
+        }
+        current = modField(current * current);
+        power >>= 1n;
+    }
+    return result;
+}
+function modInvField(value) {
+    if (value === 0n) {
+        throw new Error('field inversion by zero');
+    }
+    return modPowField(value, FIELD_P - 2n);
+}
+const BASE_X = 15112221349535400772501151409588531511454012693041857206046113283949847762202n;
+const BASE_Y = 46316835694926478169428394003475163141307993866256225615783033603165251855960n;
+export const EDWARDS_D = modField(-121665n * modInvField(121666n));
+export const TWO_D = modField(2n * EDWARDS_D);
+export const BASE_POINT = Object.freeze({
+    x: BASE_X,
+    y: BASE_Y,
+    z: 1n,
+    t: modField(BASE_X * BASE_Y)
+});
+export const IDENTITY_POINT = Object.freeze({
+    x: 0n,
+    y: 1n,
+    z: 1n,
+    t: 0n
+});

package/dist/esm/crypto/math/edwards.js

@@ -0,0 +1,60 @@
+import { BASE_POINT, IDENTITY_POINT, TWO_D } from '../math/constants.js';
+import { bigIntToBytesLE } from '../math/le.js';
+import { mod, modGroup, modInv } from '../math/mod.js';
+function addPoint(a, b) {
+    const y1MinusX1 = mod(a.y - a.x);
+    const y2MinusX2 = mod(b.y - b.x);
+    const y1PlusX1 = mod(a.y + a.x);
+    const y2PlusX2 = mod(b.y + b.x);
+    const aTerm = mod(y1MinusX1 * y2MinusX2);
+    const bTerm = mod(y1PlusX1 * y2PlusX2);
+    const cTerm = mod(TWO_D * a.t * b.t);
+    const dTerm = mod(2n * a.z * b.z);
+    const eTerm = mod(bTerm - aTerm);
+    const fTerm = mod(dTerm - cTerm);
+    const gTerm = mod(dTerm + cTerm);
+    const hTerm = mod(bTerm + aTerm);
+    return {
+        x: mod(eTerm * fTerm),
+        y: mod(gTerm * hTerm),
+        z: mod(fTerm * gTerm),
+        t: mod(eTerm * hTerm)
+    };
+}
+function doublePoint(point) {
+    const aTerm = mod(point.x * point.x);
+    const bTerm = mod(point.y * point.y);
+    const cTerm = mod(2n * point.z * point.z);
+    const dTerm = mod(-aTerm);
+    const eTerm = mod(mod((point.x + point.y) * (point.x + point.y)) - aTerm - bTerm);
+    const gTerm = mod(dTerm + bTerm);
+    const fTerm = mod(gTerm - cTerm);
+    const hTerm = mod(dTerm - bTerm);
+    return {
+        x: mod(eTerm * fTerm),
+        y: mod(gTerm * hTerm),
+        z: mod(fTerm * gTerm),
+        t: mod(eTerm * hTerm)
+    };
+}
+export function scalarMultBase(scalar) {
+    let k = modGroup(scalar);
+    let result = IDENTITY_POINT;
+    let addend = BASE_POINT;
+    while (k > 0n) {
+        if ((k & 1n) === 1n) {
+            result = addPoint(result, addend);
+        }
+        addend = doublePoint(addend);
+        k >>= 1n;
+    }
+    return result;
+}
+export function encodeExtendedPoint(point) {
+    const zInv = modInv(point.z);
+    const x = mod(point.x * zInv);
+    const y = mod(point.y * zInv);
+    const encoded = bigIntToBytesLE(y, 32);
+    encoded[31] = (encoded[31] & 0x7f) | Number((x & 1n) << 7n);
+    return encoded;
+}

package/dist/esm/crypto/math/le.js

@@ -0,0 +1,16 @@
+export function bytesToBigIntLE(bytes) {
+    let out = 0n;
+    for (let i = bytes.length - 1; i >= 0; i -= 1) {
+        out = (out << 8n) + BigInt(bytes[i]);
+    }
+    return out;
+}
+export function bigIntToBytesLE(value, length) {
+    const out = new Uint8Array(length);
+    let current = value;
+    for (let i = 0; i < length; i += 1) {
+        out[i] = Number(current & 0xffn);
+        current >>= 8n;
+    }
+    return out;
+}

package/dist/esm/crypto/math/mod.js

@@ -0,0 +1,31 @@
+import { FIELD_P, GROUP_L } from '../math/constants.js';
+export { FIELD_P, GROUP_L };
+export function mod(value, modulus = FIELD_P) {
+    const remainder = value % modulus;
+    return remainder >= 0n ? remainder : remainder + modulus;
+}
+export function modGroup(value) {
+    return mod(value, GROUP_L);
+}
+export function modInv(value, modulus = FIELD_P) {
+    if (value === 0n) {
+        throw new Error('field inversion by zero');
+    }
+    return modPow(value, modulus - 2n, modulus);
+}
+function modPow(base, exponent, modulus) {
+    if (modulus <= 0n) {
+        throw new Error('modulus must be positive');
+    }
+    let result = 1n;
+    let current = ((base % modulus) + modulus) % modulus;
+    let e = exponent;
+    while (e > 0n) {
+        if ((e & 1n) === 1n) {
+            result = (result * current) % modulus;
+        }
+        current = (current * current) % modulus;
+        e >>= 1n;
+    }
+    return result;
+}

package/dist/esm/crypto/math/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+export { WaClient } from './client/index.js';
+export { ConsoleLogger } from './infra/log/ConsoleLogger.js';
+export { PinoLogger, createPinoLogger } from './infra/log/PinoLogger.js';
+export { createStore } from './store/index.js';
+export { getLoginIdentity, getWaCompanionPlatformId, getWaMediaHkdfInfo, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid, WA_ACCOUNT_SYNC_PROTOCOLS, WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS, WA_DEFAULTS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_DISCONNECT_REASONS, WA_IQ_TYPES, WA_LOGOUT_REASONS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_MEDIA_HKDF_INFO, WA_NODE_TAGS, WA_PAIRING_KDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO, WA_READY_STATES, WA_RETRYABLE_ACK_CODES, WA_SIGNALING, WA_STREAM_SIGNALING, WA_SUPPORTED_DIRTY_TYPES, WA_XMLNS } from './protocol/index.js';
+export { proto } from './proto.js';

package/dist/esm/infra/log/ConsoleLogger.js

@@ -0,0 +1,40 @@
+const LOG_LEVEL_PRIORITY = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50
+};
+export class ConsoleLogger {
+    constructor(level = 'info') {
+        this.level = level;
+    }
+    trace(message, context) {
+        if (this.canLog('trace')) {
+            console.debug(message, context);
+        }
+    }
+    debug(message, context) {
+        if (this.canLog('debug')) {
+            console.debug(message, context);
+        }
+    }
+    info(message, context) {
+        if (this.canLog('info')) {
+            console.info(message, context);
+        }
+    }
+    warn(message, context) {
+        if (this.canLog('warn')) {
+            console.warn(message, context);
+        }
+    }
+    error(message, context) {
+        if (this.canLog('error')) {
+            console.error(message, context);
+        }
+    }
+    canLog(level) {
+        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+    }
+}

package/dist/esm/infra/log/PinoLogger.js

@@ -0,0 +1,73 @@
+const PINO_MODULE = 'pino';
+const PINO_PRETTY_MODULE = 'pino-pretty';
+async function loadPinoFactory() {
+    try {
+        const loaded = await import(PINO_MODULE);
+        if (typeof loaded === 'function') {
+            return loaded;
+        }
+        const candidate = loaded && typeof loaded === 'object' ? loaded.default : undefined;
+        if (typeof candidate === 'function') {
+            return candidate;
+        }
+        throw new Error('invalid pino module export');
+    }
+    catch {
+        throw new Error('optional dependency "pino" is not installed. Install with: npm i pino');
+    }
+}
+export class PinoLogger {
+    constructor(logger, level = 'info') {
+        this.logger = logger;
+        this.level = level;
+        this.logger.level = level;
+    }
+    trace(message, context) {
+        this.writeLog('trace', message, context);
+    }
+    debug(message, context) {
+        this.writeLog('debug', message, context);
+    }
+    info(message, context) {
+        this.writeLog('info', message, context);
+    }
+    warn(message, context) {
+        this.writeLog('warn', message, context);
+    }
+    error(message, context) {
+        this.writeLog('error', message, context);
+    }
+    writeLog(method, message, context) {
+        if (!context || Object.keys(context).length === 0) {
+            this.logger[method](message);
+            return;
+        }
+        this.logger[method](context, message);
+    }
+}
+export async function createPinoLogger(options = {}) {
+    const level = options.level ?? 'info';
+    const pino = await loadPinoFactory();
+    const pinoOptions = {
+        ...(options.pinoOptions ?? {}),
+        level
+    };
+    if (options.name) {
+        pinoOptions.name = options.name;
+    }
+    if (options.base !== undefined) {
+        pinoOptions.base = options.base;
+    }
+    if (options.pretty) {
+        pinoOptions.transport = options.prettyOptions
+            ? {
+                target: PINO_PRETTY_MODULE,
+                options: options.prettyOptions
+            }
+            : {
+                target: PINO_PRETTY_MODULE
+            };
+    }
+    const pinoLogger = pino(pinoOptions);
+    return new PinoLogger(pinoLogger, level);
+}

package/dist/esm/infra/log/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/infra/perf/BoundedTaskQueue.js

@@ -0,0 +1,62 @@
+export class BoundedTaskQueueFullError extends Error {
+    constructor(message = 'queue is full') {
+        super(message);
+        this.code = 'BOUNDED_TASK_QUEUE_FULL';
+        this.name = 'BoundedTaskQueueFullError';
+    }
+}
+export class BoundedTaskQueue {
+    constructor(maxQueueSize = 256, maxConcurrency = 1) {
+        if (maxQueueSize <= 0) {
+            throw new Error('maxQueueSize must be > 0');
+        }
+        if (maxConcurrency <= 0) {
+            throw new Error('maxConcurrency must be > 0');
+        }
+        this.maxQueueSize = maxQueueSize;
+        this.maxConcurrency = maxConcurrency;
+        this.queue = [];
+        this.head = 0;
+        this.running = 0;
+    }
+    enqueue(task) {
+        if (this.pending() >= this.maxQueueSize) {
+            return Promise.reject(new BoundedTaskQueueFullError());
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                task,
+                resolve: (value) => resolve(value),
+                reject
+            });
+            this.drain();
+        });
+    }
+    pending() {
+        return this.queue.length - this.head;
+    }
+    inFlight() {
+        return this.running;
+    }
+    drain() {
+        while (this.running < this.maxConcurrency && this.head < this.queue.length) {
+            const item = this.queue[this.head++];
+            this.running++;
+            item.task()
+                .then(item.resolve)
+                .catch(item.reject)
+                .finally(() => {
+                this.running--;
+                this.compactIfNeeded();
+                this.drain();
+            });
+        }
+    }
+    compactIfNeeded() {
+        if (this.head < 1024 || this.head * 2 < this.queue.length) {
+            return;
+        }
+        this.queue.splice(0, this.head);
+        this.head = 0;
+    }
+}