zapo-js 0.1.0 → 0.1.2

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

@@ -1,4 +1,5 @@
 import { SERIALIZED_PUB_KEY_PREFIX } from '../core/constants.js';
+import { assertByteLength } from '../../util/bytes.js';
 /**
  * Converts a 32-byte raw public key to 33-byte serialized format (with 0x05 prefix)
  */
@@ -9,9 +10,7 @@ export function toSerializedPubKey(key) {
         }
         return key;
     }
-    if (key.length !== 32) {
-        throw new Error(`invalid signal public key length ${key.length}`);
-    }
+    assertByteLength(key, 32, `invalid signal public key length ${key.length}`);
     const out = new Uint8Array(33);
     out[0] = SERIALIZED_PUB_KEY_PREFIX;
     out.set(key, 1);

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

@@ -3,17 +3,20 @@
  */
 import { createHash, webcrypto } from 'node:crypto';
 import { EMPTY_BYTES, toBytesView } from '../../util/bytes.js';
+async function digestBytes(algorithm, value) {
+    return toBytesView(await webcrypto.subtle.digest(algorithm, value));
+}
 // ============================================
 // Hash functions
 // ============================================
 export async function sha256(value) {
-    return toBytesView(await webcrypto.subtle.digest('SHA-256', value));
+    return digestBytes('SHA-256', value);
 }
 export async function sha1(value) {
-    return toBytesView(await webcrypto.subtle.digest('SHA-1', value));
+    return digestBytes('SHA-1', value);
 }
 export async function sha512(value) {
-    return toBytesView(await webcrypto.subtle.digest('SHA-512', value));
+    return digestBytes('SHA-512', value);
 }
 export function md5Bytes(input) {
     return toBytesView(createHash('md5').update(input).digest());
@@ -25,12 +28,10 @@ export async function importAesGcmKey(raw, usages) {
     return webcrypto.subtle.importKey('raw', raw, 'AES-GCM', false, usages);
 }
 export async function aesGcmEncrypt(key, nonce, plaintext, aad = EMPTY_BYTES) {
-    const result = await webcrypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, plaintext);
-    return toBytesView(result);
+    return toBytesView(await webcrypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, plaintext));
 }
 export async function aesGcmDecrypt(key, nonce, ciphertext, aad = EMPTY_BYTES) {
-    const result = await webcrypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, ciphertext);
-    return toBytesView(result);
+    return toBytesView(await webcrypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, ciphertext));
 }
 // ============================================
 // AES-CBC (for Signal protocol)
@@ -42,12 +43,10 @@ export async function importAesCbcKey(keyBytes) {
     ]);
 }
 export async function aesCbcEncrypt(key, iv, plaintext) {
-    const result = await webcrypto.subtle.encrypt({ name: 'AES-CBC', iv }, key, plaintext);
-    return toBytesView(result);
+    return toBytesView(await webcrypto.subtle.encrypt({ name: 'AES-CBC', iv }, key, plaintext));
 }
 export async function aesCbcDecrypt(key, iv, ciphertext) {
-    const result = await webcrypto.subtle.decrypt({ name: 'AES-CBC', iv }, key, ciphertext);
-    return toBytesView(result);
+    return toBytesView(await webcrypto.subtle.decrypt({ name: 'AES-CBC', iv }, key, ciphertext));
 }
 // ============================================
 // HMAC-SHA256 (for Signal protocol)
@@ -86,12 +85,10 @@ export async function pbkdf2DeriveAesCtrKey(password, salt, iterations) {
 // AES-CTR (for pairing code crypto)
 // ============================================
 export async function aesCtrEncrypt(key, counter, plaintext) {
-    const result = await webcrypto.subtle.encrypt({ name: 'AES-CTR', counter, length: 64 }, key, plaintext);
-    return toBytesView(result);
+    return toBytesView(await webcrypto.subtle.encrypt({ name: 'AES-CTR', counter, length: 64 }, key, plaintext));
 }
 export async function aesCtrDecrypt(key, counter, ciphertext) {
-    const result = await webcrypto.subtle.decrypt({ name: 'AES-CTR', counter, length: 64 }, key, ciphertext);
-    return toBytesView(result);
+    return toBytesView(await webcrypto.subtle.decrypt({ name: 'AES-CTR', counter, length: 64 }, key, ciphertext));
 }
 // ============================================
 // Ed25519 raw verify (for Signal variant sigs)

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

@@ -1,28 +1,9 @@
 import { randomBytes, randomInt } from 'node:crypto';
+import { promisify } from 'node:util';
 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);
-        });
-    });
+const randomBytesAsyncImpl = promisify(randomBytes);
+const randomIntAsyncImpl = promisify(randomInt);
+export async function randomBytesAsync(size) {
+    return toBytesView(await randomBytesAsyncImpl(size));
 }
+export const randomIntAsync = randomIntAsyncImpl;

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

@@ -1,8 +1,7 @@
 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';
+import { assertByteLength, decodeBase64Url, toBytesView } from '../../util/bytes.js';
 export class Ed25519 {
     static async generateKeyPair() {
         const keys = (await webcrypto.subtle.generateKey({ name: 'Ed25519' }, true, [
@@ -16,7 +15,7 @@ export class Ed25519 {
         };
     }
     static async keyPairFromPrivateKey(privKey) {
-        assert32(privKey, 'ed25519 private key');
+        assertByteLength(privKey, 32, 'ed25519 private key must be 32 bytes');
         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 {
@@ -25,13 +24,13 @@ export class Ed25519 {
         };
     }
     static async sign(message, privKey) {
-        assert32(privKey, 'ed25519 private key');
+        assertByteLength(privKey, 32, 'ed25519 private key must be 32 bytes');
         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');
+        assertByteLength(pubKey, 32, 'ed25519 public key must be 32 bytes');
         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

@@ -1,23 +1,18 @@
 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';
+import { assertByteLength, decodeBase64Url, toBytesView } from '../../util/bytes.js';
 export function clampCurvePrivateKeyInPlace(privateKey) {
-    if (privateKey.length !== 32) {
-        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
-    }
+    assertByteLength(privateKey, 32, `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}`);
-    }
+    assertByteLength(curvePublicKey, 32, `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');
@@ -39,7 +34,7 @@ export class X25519 {
         };
     }
     static async keyPairFromPrivateKey(privKey) {
-        assert32(privKey, 'x25519 private key');
+        assertByteLength(privKey, 32, 'x25519 private key must be 32 bytes');
         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 {
@@ -48,10 +43,12 @@ export class X25519 {
         };
     }
     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, []);
+        assertByteLength(privKey, 32, 'x25519 private key must be 32 bytes');
+        assertByteLength(pubKey, 32, 'x25519 public key must be 32 bytes');
+        const [privateKey, publicKey] = await Promise.all([
+            webcrypto.subtle.importKey('pkcs8', pkcs8FromRawPrivate(X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, false, ['deriveBits']),
+            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/index.js

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

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

@@ -5,36 +5,37 @@ const LOG_LEVEL_PRIORITY = {
     warn: 40,
     error: 50
 };
+const CONSOLE_WRITERS = {
+    trace: console.debug,
+    debug: console.debug,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+};
 export class ConsoleLogger {
     constructor(level = 'info') {
         this.level = level;
+        this.minLevelPriority = LOG_LEVEL_PRIORITY[level];
     }
     trace(message, context) {
-        if (this.canLog('trace')) {
-            console.debug(message, context);
-        }
+        this.write('trace', message, context);
     }
     debug(message, context) {
-        if (this.canLog('debug')) {
-            console.debug(message, context);
-        }
+        this.write('debug', message, context);
     }
     info(message, context) {
-        if (this.canLog('info')) {
-            console.info(message, context);
-        }
+        this.write('info', message, context);
     }
     warn(message, context) {
-        if (this.canLog('warn')) {
-            console.warn(message, context);
-        }
+        this.write('warn', message, context);
     }
     error(message, context) {
-        if (this.canLog('error')) {
-            console.error(message, context);
-        }
+        this.write('error', message, context);
     }
-    canLog(level) {
-        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+    write(level, message, context) {
+        if (LOG_LEVEL_PRIORITY[level] < this.minLevelPriority) {
+            return;
+        }
+        CONSOLE_WRITERS[level](message, context);
     }
 }

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

@@ -23,26 +23,32 @@ export class PinoLogger {
         this.logger.level = level;
     }
     trace(message, context) {
-        this.writeLog('trace', message, context);
+        this.write('trace', message, context);
     }
     debug(message, context) {
-        this.writeLog('debug', message, context);
+        this.write('debug', message, context);
     }
     info(message, context) {
-        this.writeLog('info', message, context);
+        this.write('info', message, context);
     }
     warn(message, context) {
-        this.writeLog('warn', message, context);
+        this.write('warn', message, context);
     }
     error(message, context) {
-        this.writeLog('error', message, context);
+        this.write('error', message, context);
     }
-    writeLog(method, message, context) {
-        if (!context || Object.keys(context).length === 0) {
-            this.logger[method](message);
+    write(level, message, context) {
+        if (context === null || context === undefined) {
+            this.logger[level](message);
             return;
         }
-        this.logger[method](context, message);
+        for (const key in context) {
+            if (Object.prototype.hasOwnProperty.call(context, key)) {
+                this.logger[level](context, message);
+                return;
+            }
+        }
+        this.logger[level](message);
     }
 }
 export async function createPinoLogger(options = {}) {

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

@@ -1 +1,11 @@
-export {};
+function noop() { }
+export function createNoopLogger(level = 'trace') {
+    return {
+        level,
+        trace: noop,
+        debug: noop,
+        info: noop,
+        warn: noop,
+        error: noop
+    };
+}

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

@@ -7,6 +7,16 @@ export class BoundedTaskQueueFullError extends Error {
 }
 export class BoundedTaskQueue {
     constructor(maxQueueSize = 256, maxConcurrency = 1) {
+        this.settleTask = () => {
+            this.running--;
+            if (this.head >= 1024 && this.head * 2 >= this.queue.length) {
+                const remaining = this.queue.length - this.head;
+                this.queue.copyWithin(0, this.head);
+                this.queue.length = remaining;
+                this.head = 0;
+            }
+            this.drain();
+        };
         if (maxQueueSize <= 0) {
             throw new Error('maxQueueSize must be > 0');
         }
@@ -25,8 +35,8 @@ export class BoundedTaskQueue {
         }
         return new Promise((resolve, reject) => {
             this.queue.push({
-                task,
-                resolve: (value) => resolve(value),
+                task: task,
+                resolve: resolve,
                 reject
             });
             this.drain();
@@ -42,21 +52,7 @@ export class BoundedTaskQueue {
         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();
-            });
+            void item.task().then(item.resolve, item.reject).finally(this.settleTask);
         }
     }
-    compactIfNeeded() {
-        if (this.head < 1024 || this.head * 2 < this.queue.length) {
-            return;
-        }
-        this.queue.splice(0, this.head);
-        this.head = 0;
-    }
 }

package/dist/esm/media/WaMediaCrypto.js

@@ -6,16 +6,14 @@ import { aesCbcDecrypt, aesCbcEncrypt, hmacSign, importAesCbcKey, importHmacKey,
 import { randomBytesAsync } from '../crypto/core/random.js';
 import { ENC_KEY_END, ENC_KEY_START, HMAC_TRUNCATED_SIZE, IV_SIZE, MAC_KEY_END, MAC_KEY_START, MEDIA_HKDF_SIZE } from './constants.js';
 import { WA_APP_STATE_KEY_TYPES, getWaMediaHkdfInfo } from '../protocol/constants.js';
-import { concatBytes, EMPTY_BYTES, readAllBytes, toChunkBytes, toBytesView, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
+import { assertByteLength, concatBytes, EMPTY_BYTES, readAllBytes, toChunkBytes, toBytesView, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 export class WaMediaCrypto {
     static async generateMediaKey() {
         return randomBytesAsync(32);
     }
     static async deriveKeys(mediaType, mediaKey) {
-        if (mediaKey.byteLength !== 32) {
-            throw new Error(`invalid media key length ${mediaKey.byteLength}, expected 32`);
-        }
+        assertByteLength(mediaKey, 32, `invalid media key length ${mediaKey.byteLength}, expected 32`);
         const info = mediaTypeToHkdfInfo(mediaType);
         const expanded = await hkdf(mediaKey, null, info, MEDIA_HKDF_SIZE);
         return {