zapo-js 0.1.1 → 0.1.2

package/dist/client/messaging/participants.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGroupParticipantsCache = createGroupParticipantsCache;
+const jid_1 = require("../../protocol/jid");
+const primitives_1 = require("../../util/primitives");
+function createGroupParticipantsCache(options) {
+    const { participantsStore, queryGroupParticipantJids, logger } = options;
+    const sanitizeParticipantUsers = (participants) => {
+        const deduped = new Set();
+        for (const participant of participants) {
+            if (!participant || !participant.includes('@')) {
+                continue;
+            }
+            try {
+                deduped.add((0, jid_1.toUserJid)(participant));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed participant jid', {
+                    participant,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        }
+        return [...deduped];
+    };
+    const areParticipantListsEqual = (left, right) => {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            if (left[index] !== right[index]) {
+                return false;
+            }
+        }
+        return true;
+    };
+    const mergeParticipantUsersIntoCache = async (groupJid, cachedParticipants, participantsToAdd) => {
+        if (participantsToAdd.length === 0) {
+            return;
+        }
+        const nextParticipants = [...cachedParticipants];
+        const existing = new Set(cachedParticipants);
+        for (const participant of participantsToAdd) {
+            if (existing.has(participant)) {
+                continue;
+            }
+            existing.add(participant);
+            nextParticipants.push(participant);
+        }
+        if (nextParticipants.length === cachedParticipants.length) {
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const removeParticipantUsersFromCache = async (groupJid, cachedParticipants, participantsToRemove) => {
+        if (participantsToRemove.length === 0) {
+            return;
+        }
+        const removed = new Set(participantsToRemove);
+        const nextParticipants = cachedParticipants.filter((participant) => !removed.has(participant));
+        if (nextParticipants.length === cachedParticipants.length) {
+            return;
+        }
+        if (nextParticipants.length === 0) {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const replaceParticipantUsersInCache = async (groupJid, cachedParticipants, participantsToReplace, replacementParticipants) => {
+        const toReplace = new Set(participantsToReplace);
+        const nextParticipants = cachedParticipants.filter((participant) => !toReplace.has(participant));
+        const existing = new Set(nextParticipants);
+        for (const participant of replacementParticipants) {
+            if (existing.has(participant)) {
+                continue;
+            }
+            existing.add(participant);
+            nextParticipants.push(participant);
+        }
+        if (areParticipantListsEqual(cachedParticipants, nextParticipants)) {
+            return;
+        }
+        if (nextParticipants.length === 0) {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const resolveGroupJidForParticipantCacheEvent = (event) => {
+        if (event.action === 'linked_group_promote' || event.action === 'linked_group_demote') {
+            return event.contextGroupJid ?? event.groupJid ?? null;
+        }
+        return event.groupJid ?? null;
+    };
+    const extractParticipantUsersFromGroupEvent = (event) => {
+        const candidates = [];
+        for (const participant of event.participants ?? []) {
+            if (participant.jid) {
+                candidates.push(participant.jid);
+            }
+            if (participant.lidJid) {
+                candidates.push(participant.lidJid);
+            }
+            if (participant.phoneJid) {
+                candidates.push(participant.phoneJid);
+            }
+        }
+        return sanitizeParticipantUsers(candidates);
+    };
+    const refreshParticipantUsers = async (groupJid) => {
+        const queried = await queryGroupParticipantJids(groupJid);
+        const participants = sanitizeParticipantUsers(queried);
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants,
+            updatedAtMs: Date.now()
+        });
+        return participants;
+    };
+    const resolveParticipantUsers = async (groupJid) => {
+        const cached = await participantsStore.getGroupParticipants(groupJid);
+        if (cached && cached.participants.length > 0) {
+            return sanitizeParticipantUsers(cached.participants);
+        }
+        return refreshParticipantUsers(groupJid);
+    };
+    const mutateFromGroupEvent = async (event) => {
+        const groupJid = resolveGroupJidForParticipantCacheEvent(event);
+        if (!groupJid) {
+            return;
+        }
+        if (event.action === 'delete') {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        const participantUsers = extractParticipantUsersFromGroupEvent(event);
+        if (event.action === 'create') {
+            if (participantUsers.length === 0) {
+                return;
+            }
+            await participantsStore.upsertGroupParticipants({
+                groupJid,
+                participants: participantUsers,
+                updatedAtMs: Date.now()
+            });
+            return;
+        }
+        const cached = await participantsStore.getGroupParticipants(groupJid);
+        if (!cached || cached.participants.length === 0) {
+            return;
+        }
+        const cachedParticipants = sanitizeParticipantUsers(cached.participants);
+        if (cachedParticipants.length === 0) {
+            return;
+        }
+        if (event.action === 'add' ||
+            event.action === 'promote' ||
+            event.action === 'demote' ||
+            event.action === 'linked_group_promote' ||
+            event.action === 'linked_group_demote') {
+            await mergeParticipantUsersIntoCache(groupJid, cachedParticipants, participantUsers);
+            return;
+        }
+        if (event.action === 'remove') {
+            await removeParticipantUsersFromCache(groupJid, cachedParticipants, participantUsers);
+            return;
+        }
+        if (event.action === 'modify') {
+            const authorUsers = event.authorJid ? sanitizeParticipantUsers([event.authorJid]) : [];
+            await replaceParticipantUsersInCache(groupJid, cachedParticipants, authorUsers, participantUsers);
+        }
+    };
+    return {
+        resolveParticipantUsers,
+        refreshParticipantUsers,
+        mutateFromGroupEvent
+    };
+}

package/dist/crypto/core/hkdf.js

@@ -4,23 +4,18 @@ exports.hkdf = hkdf;
 exports.hkdfSplit = hkdfSplit;
 const node_crypto_1 = require("node:crypto");
 const bytes_1 = require("../../util/bytes");
-/**
- * HKDF key derivation using SHA-256
- */
 async function hkdf(ikm, salt, info, outLength) {
     const key = await node_crypto_1.webcrypto.subtle.importKey('raw', ikm, 'HKDF', false, ['deriveBits']);
+    const infoBytes = typeof info === 'string' ? (info === '' ? bytes_1.EMPTY_BYTES : bytes_1.TEXT_ENCODER.encode(info)) : info;
     const bits = await node_crypto_1.webcrypto.subtle.deriveBits({
         name: 'HKDF',
         hash: 'SHA-256',
         salt: salt ?? bytes_1.EMPTY_BYTES,
-        info: typeof info === 'string' ? bytes_1.TEXT_ENCODER.encode(info) : info
+        info: infoBytes
     }, key, outLength * 8);
     return (0, bytes_1.toBytesView)(bits);
 }
-/**
- * HKDF key derivation that outputs two 32-byte keys
- */
 async function hkdfSplit(ikm, salt, info) {
     const out = await hkdf(ikm, salt, info, 64);
-    return [out.subarray(0, 32), out.subarray(32, 64)];
+    return [out.subarray(0, 32), out.subarray(32)];
 }

package/dist/crypto/core/index.js

@@ -3,14 +3,11 @@
  * Cryptographic utilities
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ed25519VerifyRaw = exports.aesCtrDecrypt = exports.aesCtrEncrypt = exports.pbkdf2DeriveAesCtrKey = exports.hmacSign = exports.importHmacSha512Key = exports.importHmacKey = exports.aesCbcDecrypt = exports.aesCbcEncrypt = exports.importAesCbcKey = exports.aesGcmDecrypt = exports.aesGcmEncrypt = exports.importAesGcmKey = exports.sha512 = exports.sha256 = exports.sha1 = exports.randomIntAsync = exports.randomBytesAsync = exports.buildNonce = exports.readVersionedContent = exports.prependVersion = exports.toRawPubKey = exports.toSerializedPubKey = exports.hkdfSplit = exports.hkdf = exports.assert32 = exports.decodeBase64Url = exports.X25519 = exports.Ed25519 = void 0;
+exports.ed25519VerifyRaw = exports.aesCtrDecrypt = exports.aesCtrEncrypt = exports.pbkdf2DeriveAesCtrKey = exports.hmacSign = exports.importHmacSha512Key = exports.importHmacKey = exports.aesCbcDecrypt = exports.aesCbcEncrypt = exports.importAesCbcKey = exports.aesGcmDecrypt = exports.aesGcmEncrypt = exports.importAesGcmKey = exports.sha512 = exports.sha256 = exports.sha1 = exports.randomIntAsync = exports.randomBytesAsync = exports.buildNonce = exports.readVersionedContent = exports.prependVersion = exports.toRawPubKey = exports.toSerializedPubKey = exports.hkdfSplit = exports.hkdf = exports.X25519 = exports.Ed25519 = void 0;
 var Ed25519_1 = require("../curves/Ed25519");
 Object.defineProperty(exports, "Ed25519", { enumerable: true, get: function () { return Ed25519_1.Ed25519; } });
 var X25519_1 = require("../curves/X25519");
 Object.defineProperty(exports, "X25519", { enumerable: true, get: function () { return X25519_1.X25519; } });
-var encoding_1 = require("../core/encoding");
-Object.defineProperty(exports, "decodeBase64Url", { enumerable: true, get: function () { return encoding_1.decodeBase64Url; } });
-Object.defineProperty(exports, "assert32", { enumerable: true, get: function () { return encoding_1.assert32; } });
 var hkdf_1 = require("../core/hkdf");
 Object.defineProperty(exports, "hkdf", { enumerable: true, get: function () { return hkdf_1.hkdf; } });
 Object.defineProperty(exports, "hkdfSplit", { enumerable: true, get: function () { return hkdf_1.hkdfSplit; } });

package/dist/crypto/core/keys.js

@@ -6,6 +6,7 @@ exports.versionByte = versionByte;
 exports.prependVersion = prependVersion;
 exports.readVersionedContent = readVersionedContent;
 const constants_1 = require("../core/constants");
+const bytes_1 = require("../../util/bytes");
 /**
  * Converts a 32-byte raw public key to 33-byte serialized format (with 0x05 prefix)
  */
@@ -16,9 +17,7 @@ function toSerializedPubKey(key) {
         }
         return key;
     }
-    if (key.length !== 32) {
-        throw new Error(`invalid signal public key length ${key.length}`);
-    }
+    (0, bytes_1.assertByteLength)(key, 32, `invalid signal public key length ${key.length}`);
     const out = new Uint8Array(33);
     out[0] = constants_1.SERIALIZED_PUB_KEY_PREFIX;
     out.set(key, 1);

package/dist/crypto/core/primitives.js

@@ -22,17 +22,20 @@ exports.aesCtrDecrypt = aesCtrDecrypt;
 exports.ed25519VerifyRaw = ed25519VerifyRaw;
 const node_crypto_1 = require("node:crypto");
 const bytes_1 = require("../../util/bytes");
+async function digestBytes(algorithm, value) {
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.digest(algorithm, value));
+}
 // ============================================
 // Hash functions
 // ============================================
 async function sha256(value) {
-    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.digest('SHA-256', value));
+    return digestBytes('SHA-256', value);
 }
 async function sha1(value) {
-    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.digest('SHA-1', value));
+    return digestBytes('SHA-1', value);
 }
 async function sha512(value) {
-    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.digest('SHA-512', value));
+    return digestBytes('SHA-512', value);
 }
 function md5Bytes(input) {
     return (0, bytes_1.toBytesView)((0, node_crypto_1.createHash)('md5').update(input).digest());
@@ -44,12 +47,10 @@ async function importAesGcmKey(raw, usages) {
     return node_crypto_1.webcrypto.subtle.importKey('raw', raw, 'AES-GCM', false, usages);
 }
 async function aesGcmEncrypt(key, nonce, plaintext, aad = bytes_1.EMPTY_BYTES) {
-    const result = await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, plaintext);
-    return (0, bytes_1.toBytesView)(result);
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, plaintext));
 }
 async function aesGcmDecrypt(key, nonce, ciphertext, aad = bytes_1.EMPTY_BYTES) {
-    const result = await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, ciphertext);
-    return (0, bytes_1.toBytesView)(result);
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, additionalData: aad }, key, ciphertext));
 }
 // ============================================
 // AES-CBC (for Signal protocol)
@@ -61,12 +62,10 @@ async function importAesCbcKey(keyBytes) {
     ]);
 }
 async function aesCbcEncrypt(key, iv, plaintext) {
-    const result = await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-CBC', iv }, key, plaintext);
-    return (0, bytes_1.toBytesView)(result);
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-CBC', iv }, key, plaintext));
 }
 async function aesCbcDecrypt(key, iv, ciphertext) {
-    const result = await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-CBC', iv }, key, ciphertext);
-    return (0, bytes_1.toBytesView)(result);
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-CBC', iv }, key, ciphertext));
 }
 // ============================================
 // HMAC-SHA256 (for Signal protocol)
@@ -105,12 +104,10 @@ async function pbkdf2DeriveAesCtrKey(password, salt, iterations) {
 // AES-CTR (for pairing code crypto)
 // ============================================
 async function aesCtrEncrypt(key, counter, plaintext) {
-    const result = await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-CTR', counter, length: 64 }, key, plaintext);
-    return (0, bytes_1.toBytesView)(result);
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.encrypt({ name: 'AES-CTR', counter, length: 64 }, key, plaintext));
 }
 async function aesCtrDecrypt(key, counter, ciphertext) {
-    const result = await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-CTR', counter, length: 64 }, key, ciphertext);
-    return (0, bytes_1.toBytesView)(result);
+    return (0, bytes_1.toBytesView)(await node_crypto_1.webcrypto.subtle.decrypt({ name: 'AES-CTR', counter, length: 64 }, key, ciphertext));
 }
 // ============================================
 // Ed25519 raw verify (for Signal variant sigs)

package/dist/crypto/core/random.js

@@ -1,32 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomIntAsync = void 0;
 exports.randomBytesAsync = randomBytesAsync;
-exports.randomIntAsync = randomIntAsync;
 const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
 const bytes_1 = require("../../util/bytes");
-/**
- * Generates cryptographically secure random bytes
- */
-function randomBytesAsync(size) {
-    return new Promise((resolve, reject) => {
-        (0, node_crypto_1.randomBytes)(size, (error, buffer) => {
-            if (error)
-                reject(error);
-            else
-                resolve((0, bytes_1.toBytesView)(buffer));
-        });
-    });
-}
-/**
- * Generates a cryptographically secure random integer in the range [min, max)
- */
-function randomIntAsync(min, max) {
-    return new Promise((resolve, reject) => {
-        (0, node_crypto_1.randomInt)(min, max, (error, value) => {
-            if (error)
-                reject(error);
-            else
-                resolve(value);
-        });
-    });
+const randomBytesAsyncImpl = (0, node_util_1.promisify)(node_crypto_1.randomBytes);
+const randomIntAsyncImpl = (0, node_util_1.promisify)(node_crypto_1.randomInt);
+async function randomBytesAsync(size) {
+    return (0, bytes_1.toBytesView)(await randomBytesAsyncImpl(size));
 }
+exports.randomIntAsync = randomIntAsyncImpl;

package/dist/crypto/curves/Ed25519.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ed25519 = void 0;
 const node_crypto_1 = require("node:crypto");
-const encoding_1 = require("../core/encoding");
 const constants_1 = require("../curves/constants");
 const types_1 = require("../curves/types");
 const bytes_1 = require("../../util/bytes");
@@ -14,27 +13,27 @@ class Ed25519 {
         ]));
         const privateJwk = await node_crypto_1.webcrypto.subtle.exportKey('jwk', keys.privateKey);
         return {
-            pubKey: (0, encoding_1.decodeBase64Url)(privateJwk.x, 'ed25519 public key'),
-            privKey: (0, encoding_1.decodeBase64Url)(privateJwk.d, 'ed25519 private key')
+            pubKey: (0, bytes_1.decodeBase64Url)(privateJwk.x, 'ed25519 public key'),
+            privKey: (0, bytes_1.decodeBase64Url)(privateJwk.d, 'ed25519 private key')
         };
     }
     static async keyPairFromPrivateKey(privKey) {
-        (0, encoding_1.assert32)(privKey, 'ed25519 private key');
+        (0, bytes_1.assertByteLength)(privKey, 32, 'ed25519 private key must be 32 bytes');
         const privateKey = await node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.ED25519_PKCS8_PREFIX, privKey), { name: 'Ed25519' }, true, ['sign']);
         const privateJwk = await node_crypto_1.webcrypto.subtle.exportKey('jwk', privateKey);
         return {
-            pubKey: (0, encoding_1.decodeBase64Url)(privateJwk.x, 'ed25519 public key'),
-            privKey: (0, encoding_1.decodeBase64Url)(privateJwk.d, 'ed25519 private key')
+            pubKey: (0, bytes_1.decodeBase64Url)(privateJwk.x, 'ed25519 public key'),
+            privKey: (0, bytes_1.decodeBase64Url)(privateJwk.d, 'ed25519 private key')
         };
     }
     static async sign(message, privKey) {
-        (0, encoding_1.assert32)(privKey, 'ed25519 private key');
+        (0, bytes_1.assertByteLength)(privKey, 32, 'ed25519 private key must be 32 bytes');
         const privateKey = await node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.ED25519_PKCS8_PREFIX, privKey), { name: 'Ed25519' }, false, ['sign']);
         const signature = await node_crypto_1.webcrypto.subtle.sign('Ed25519', privateKey, message);
         return (0, bytes_1.toBytesView)(signature);
     }
     static async verify(message, signature, pubKey) {
-        (0, encoding_1.assert32)(pubKey, 'ed25519 public key');
+        (0, bytes_1.assertByteLength)(pubKey, 32, 'ed25519 public key must be 32 bytes');
         const publicKey = await node_crypto_1.webcrypto.subtle.importKey('raw', pubKey, { name: 'Ed25519' }, false, ['verify']);
         return node_crypto_1.webcrypto.subtle.verify('Ed25519', publicKey, signature, message);
     }

package/dist/crypto/curves/X25519.js

@@ -4,25 +4,20 @@ exports.X25519 = void 0;
 exports.clampCurvePrivateKeyInPlace = clampCurvePrivateKeyInPlace;
 exports.montgomeryToEdwardsPublic = montgomeryToEdwardsPublic;
 const node_crypto_1 = require("node:crypto");
-const encoding_1 = require("../core/encoding");
 const constants_1 = require("../curves/constants");
 const types_1 = require("../curves/types");
 const le_1 = require("../math/le");
 const mod_1 = require("../math/mod");
 const bytes_1 = require("../../util/bytes");
 function clampCurvePrivateKeyInPlace(privateKey) {
-    if (privateKey.length !== 32) {
-        throw new Error(`invalid curve25519 private key length ${privateKey.length}`);
-    }
+    (0, bytes_1.assertByteLength)(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
     privateKey[0] &= 248;
     privateKey[31] &= 127;
     privateKey[31] |= 64;
     return privateKey;
 }
 function montgomeryToEdwardsPublic(curvePublicKey, signBit) {
-    if (curvePublicKey.length !== 32) {
-        throw new Error(`invalid curve25519 public key length ${curvePublicKey.length}`);
-    }
+    (0, bytes_1.assertByteLength)(curvePublicKey, 32, `invalid curve25519 public key length ${curvePublicKey.length}`);
     const x = (0, le_1.bytesToBigIntLE)(curvePublicKey);
     if (x === mod_1.FIELD_P - 1n) {
         throw new Error('invalid curve25519 low-order public key');
@@ -39,24 +34,26 @@ class X25519 {
         ]));
         const privateJwk = await node_crypto_1.webcrypto.subtle.exportKey('jwk', keys.privateKey);
         return {
-            pubKey: (0, encoding_1.decodeBase64Url)(privateJwk.x, 'x25519 public key'),
-            privKey: (0, encoding_1.decodeBase64Url)(privateJwk.d, 'x25519 private key')
+            pubKey: (0, bytes_1.decodeBase64Url)(privateJwk.x, 'x25519 public key'),
+            privKey: (0, bytes_1.decodeBase64Url)(privateJwk.d, 'x25519 private key')
         };
     }
     static async keyPairFromPrivateKey(privKey) {
-        (0, encoding_1.assert32)(privKey, 'x25519 private key');
+        (0, bytes_1.assertByteLength)(privKey, 32, 'x25519 private key must be 32 bytes');
         const privateKey = await node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, true, ['deriveBits']);
         const privateJwk = await node_crypto_1.webcrypto.subtle.exportKey('jwk', privateKey);
         return {
-            pubKey: (0, encoding_1.decodeBase64Url)(privateJwk.x, 'x25519 public key'),
-            privKey: (0, encoding_1.decodeBase64Url)(privateJwk.d, 'x25519 private key')
+            pubKey: (0, bytes_1.decodeBase64Url)(privateJwk.x, 'x25519 public key'),
+            privKey: (0, bytes_1.decodeBase64Url)(privateJwk.d, 'x25519 private key')
         };
     }
     static async scalarMult(privKey, pubKey) {
-        (0, encoding_1.assert32)(privKey, 'x25519 private key');
-        (0, encoding_1.assert32)(pubKey, 'x25519 public key');
-        const privateKey = await node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, false, ['deriveBits']);
-        const publicKey = await node_crypto_1.webcrypto.subtle.importKey('raw', pubKey, { name: 'X25519' }, false, []);
+        (0, bytes_1.assertByteLength)(privKey, 32, 'x25519 private key must be 32 bytes');
+        (0, bytes_1.assertByteLength)(pubKey, 32, 'x25519 public key must be 32 bytes');
+        const [privateKey, publicKey] = await Promise.all([
+            node_crypto_1.webcrypto.subtle.importKey('pkcs8', (0, types_1.pkcs8FromRawPrivate)(constants_1.X25519_PKCS8_PREFIX, privKey), { name: 'X25519' }, false, ['deriveBits']),
+            node_crypto_1.webcrypto.subtle.importKey('raw', pubKey, { name: 'X25519' }, false, [])
+        ]);
         const sharedBits = await node_crypto_1.webcrypto.subtle.deriveBits({ name: 'X25519', public: publicKey }, privateKey, 256);
         return (0, bytes_1.toBytesView)(sharedBits);
     }

package/dist/crypto/index.js

@@ -14,9 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.X25519 = exports.Ed25519 = void 0;
 __exportStar(require("./core"), exports);
-var Ed25519_1 = require("./curves/Ed25519");
-Object.defineProperty(exports, "Ed25519", { enumerable: true, get: function () { return Ed25519_1.Ed25519; } });
-var X25519_1 = require("./curves/X25519");
-Object.defineProperty(exports, "X25519", { enumerable: true, get: function () { return X25519_1.X25519; } });

package/dist/esm/appstate/WaAppStateCrypto.js

@@ -1,19 +1,18 @@
 import { APP_STATE_DERIVED_INDEX_KEY_END, APP_STATE_DERIVED_KEY_LENGTH, APP_STATE_DERIVED_PATCH_MAC_KEY_END, APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END, APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END, APP_STATE_DERIVED_VALUE_MAC_KEY_END, APP_STATE_EMPTY_LT_HASH, APP_STATE_IV_LENGTH, APP_STATE_MAC_OCTET_LENGTH, APP_STATE_POINT_SIZE, APP_STATE_VALUE_MAC_LENGTH } from './constants.js';
-import { toNetworkOrder64 } from './utils.js';
 import { hkdf } from '../crypto/core/hkdf.js';
 import { aesCbcDecrypt, aesCbcEncrypt, hmacSign, importAesCbcKey, importHmacKey, importHmacSha512Key } from '../crypto/core/primitives.js';
 import { randomBytesAsync } from '../crypto/core/random.js';
 import { proto } from '../proto.js';
 import { WA_APP_STATE_KDF_INFO } from '../protocol/constants.js';
-import { bytesToBase64 } from '../util/base64.js';
-import { concatBytes, EMPTY_BYTES, TEXT_DECODER, TEXT_ENCODER, uint8Equal } from '../util/bytes.js';
+import { bytesToBase64 } from '../util/bytes.js';
+import { concatBytes, EMPTY_BYTES, intToBytes, TEXT_DECODER, TEXT_ENCODER, uint8Equal } from '../util/bytes.js';
 import { setBoundedMapEntry } from '../util/collections.js';
+import { normalizeNonNegativeInteger } from '../util/primitives.js';
 const DEFAULT_DERIVED_KEYS_CACHE_MAX_SIZE = 256;
 export class WaAppStateCrypto {
     constructor(derivedKeysCacheMaxSize = DEFAULT_DERIVED_KEYS_CACHE_MAX_SIZE) {
         this.derivedKeysCache = new Map();
-        this.derivedKeysCacheMaxSize =
-            this.normalizeDerivedKeysCacheMaxSize(derivedKeysCacheMaxSize);
+        this.derivedKeysCacheMaxSize = normalizeNonNegativeInteger(derivedKeysCacheMaxSize, DEFAULT_DERIVED_KEYS_CACHE_MAX_SIZE);
     }
     clearCache() {
         this.derivedKeysCache.clear();
@@ -107,7 +106,7 @@ export class WaAppStateCrypto {
         const derivedKeys = await this.deriveKeys(keyData);
         const payload = concatBytes([
             ltHash,
-            toNetworkOrder64(version),
+            intToBytes(8, version),
             TEXT_ENCODER.encode(collectionName)
         ]);
         const key = await importHmacKey(derivedKeys.snapshotMacKey);
@@ -118,7 +117,7 @@ export class WaAppStateCrypto {
         const payload = concatBytes([
             snapshotMac,
             ...valueMacs,
-            toNetworkOrder64(version),
+            intToBytes(8, version),
             TEXT_ENCODER.encode(collectionName)
         ]);
         const key = await importHmacKey(derivedKeys.patchMacKey);
@@ -183,12 +182,6 @@ export class WaAppStateCrypto {
         const full = await hmacSign(key, concatBytes([associatedData, cipherWithIv, octetLength]));
         return full.slice(0, APP_STATE_VALUE_MAC_LENGTH);
     }
-    normalizeDerivedKeysCacheMaxSize(value) {
-        if (!Number.isFinite(value)) {
-            return DEFAULT_DERIVED_KEYS_CACHE_MAX_SIZE;
-        }
-        return Math.max(0, Math.trunc(value));
-    }
     touchDerivedKeysCacheEntry(cacheKey, keys) {
         if (this.derivedKeysCacheMaxSize <= 0) {
             return;