zapo-js 0.2.0 → 0.3.0

package/dist/client/messages.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildMediaMessageContent = buildMediaMessageContent;
 exports.getMediaConn = getMediaConn;
 const node_fs_1 = require("node:fs");
+const media_1 = require("./media");
 const conn_1 = require("../media/conn");
 const constants_1 = require("../media/constants");
 const WaMediaCrypto_1 = require("../media/WaMediaCrypto");
 const content_1 = require("../message/content");
 const constants_2 = require("../protocol/constants");
-const media_1 = require("../transport/node/builders/media");
+const media_2 = require("../transport/node/builders/media");
 const bytes_1 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 async function buildMediaMessageContent(options, content) {
@@ -30,11 +31,14 @@ async function getMediaConn(options, forceRefresh = false) {
     if (!forceRefresh && cached && Date.now() + constants_1.MEDIA_CONN_CACHE_GRACE_MS < cached.expiresAtMs) {
         return cached;
     }
-    const response = await options.queryWithContext('media_conn.fetch', (0, media_1.buildMediaConnIq)(), options.iqTimeoutMs ?? constants_2.WA_DEFAULTS.IQ_TIMEOUT_MS);
+    const response = await options.queryWithContext('media_conn.fetch', (0, media_2.buildMediaConnIq)(), options.iqTimeoutMs ?? constants_2.WA_DEFAULTS.IQ_TIMEOUT_MS);
     const mediaConn = (0, conn_1.parseMediaConnResponse)(response, Date.now());
     options.setMediaConnCache(mediaConn);
     return mediaConn;
 }
+function needsSidecar(content) {
+    return content.type === 'video' || content.type === 'ptv' || content.type === 'audio';
+}
 function resolveUploadType(content) {
     if (content.type === 'video' && content.gifPlayback)
         return 'gif';
@@ -42,85 +46,146 @@ function resolveUploadType(content) {
         return 'ptt';
     return content.type;
 }
-function isReadableStream(value) {
-    return (!!value &&
-        typeof value === 'object' &&
-        'pipe' in value &&
-        typeof value.pipe === 'function');
+function resolveMimetype(content) {
+    if (content.mimetype)
+        return content.mimetype;
+    if (content.type === 'sticker')
+        return 'image/webp';
+    throw new Error(`mimetype is required for ${content.type} messages`);
 }
 async function buildMediaMessage(options, content) {
-    const uploaded = isReadableStream(content.media)
-        ? await uploadMediaStream(options, content, content.media)
-        : await uploadMediaBytes(options, content, (0, bytes_1.toBytesView)(content.media));
-    const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
-    const common = {
-        url: uploaded.url,
-        mimetype: content.mimetype,
-        fileSha256: uploaded.fileSha256,
-        fileLength: uploaded.fileLength,
-        mediaKey: uploaded.mediaKey,
-        fileEncSha256: uploaded.fileEncSha256,
-        directPath: uploaded.directPath,
-        mediaKeyTimestamp
-    };
-    switch (content.type) {
-        case 'image':
-            return {
-                imageMessage: {
-                    ...common,
-                    caption: content.caption,
-                    width: content.width,
-                    height: content.height
-                }
-            };
-        case 'video':
-            return {
-                videoMessage: {
-                    ...common,
-                    caption: content.caption,
-                    gifPlayback: content.gifPlayback,
-                    seconds: content.seconds,
-                    width: content.width,
-                    height: content.height,
-                    metadataUrl: uploaded.metadataUrl
-                }
-            };
-        case 'ptv':
-            return {
-                ptvMessage: {
-                    ...common,
-                    seconds: content.seconds,
-                    width: content.width,
-                    height: content.height
-                }
-            };
-        case 'audio':
-            return {
-                audioMessage: {
-                    ...common,
-                    seconds: content.seconds,
-                    ptt: content.ptt
-                }
-            };
-        case 'document':
-            return {
-                documentMessage: {
-                    ...common,
-                    caption: content.caption,
-                    fileName: content.fileName ?? 'file',
-                    title: content.fileName ?? undefined
-                }
-            };
-        case 'sticker':
-            return {
-                stickerMessage: {
-                    ...common,
-                    width: content.width,
-                    height: content.height
+    const needsTempFile = (0, media_1.hasMediaProcessingTasks)(options.media, content) ||
+        (content.type === 'sticker' && content.firstFrameLength === undefined);
+    const resolved = await (0, media_1.resolveMediaInputs)(needsTempFile, content.media);
+    try {
+        let detectedFirstFrameLength;
+        if (content.type === 'sticker' &&
+            content.firstFrameLength === undefined &&
+            resolved.processorInput) {
+            const input = resolved.processorInput;
+            const header = typeof input === 'string' ? await (0, media_1.readFileHead)(input, 100) : input.subarray(0, 100);
+            detectedFirstFrameLength = (0, media_1.parseWebpAnimation)(header)?.firstFrameLength;
+        }
+        const firstFrameLength = content.type === 'sticker'
+            ? (content.firstFrameLength ?? detectedFirstFrameLength)
+            : undefined;
+        const uploadPromise = (0, media_1.isReadableStream)(resolved.uploadMedia)
+            ? uploadMediaStream(options, content, resolved.uploadMedia, firstFrameLength)
+            : uploadMediaBytes(options, content, resolved.uploadMedia, firstFrameLength);
+        const processPromise = (0, media_1.runMediaProcessor)(options.media, resolved.processorInput, content, options.logger);
+        const [uploadResult, processResult] = await Promise.allSettled([
+            uploadPromise,
+            processPromise
+        ]);
+        if (uploadResult.status === 'rejected')
+            throw uploadResult.reason;
+        if (processResult.status === 'rejected')
+            throw processResult.reason;
+        const uploaded = uploadResult.value;
+        const processed = processResult.value;
+        const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
+        const uploadedFields = {
+            url: uploaded.url,
+            fileSha256: uploaded.fileSha256,
+            fileLength: uploaded.fileLength,
+            mediaKey: uploaded.mediaKey,
+            fileEncSha256: uploaded.fileEncSha256,
+            directPath: uploaded.directPath,
+            mediaKeyTimestamp,
+            mimetype: resolveMimetype(content)
+        };
+        function spread(c) {
+            const result = {};
+            for (const key in c) {
+                if (key !== 'type' &&
+                    key !== 'media' &&
+                    key !== 'fileLength' &&
+                    key !== 'mimetype') {
+                    result[key] = c[key];
                 }
-            };
-        default:
-            throw new Error(`unsupported media message type: ${String(content.type)}`);
+            }
+            return result;
+        }
+        switch (content.type) {
+            case 'image':
+                return {
+                    imageMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail
+                    }
+                };
+            case 'video':
+                return {
+                    videoMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail,
+                        streamingSidecar: uploaded.streamingSidecar,
+                        metadataUrl: uploaded.metadataUrl
+                    }
+                };
+            case 'ptv':
+                return {
+                    ptvMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail,
+                        streamingSidecar: uploaded.streamingSidecar
+                    }
+                };
+            case 'audio':
+                return {
+                    audioMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        seconds: content.seconds ?? processed.seconds,
+                        streamingSidecar: uploaded.streamingSidecar,
+                        waveform: content.waveform ?? processed.waveform
+                    }
+                };
+            case 'document':
+                return {
+                    documentMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        fileName: content.fileName ?? 'file',
+                        title: content.title ?? content.fileName ?? undefined,
+                        jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail
+                    }
+                };
+            case 'sticker':
+                return {
+                    stickerMessage: {
+                        ...spread(content),
+                        ...uploadedFields,
+                        width: content.width ?? processed.width,
+                        height: content.height ?? processed.height,
+                        pngThumbnail: content.pngThumbnail ?? processed.pngThumbnail,
+                        isAnimated: content.isAnimated ??
+                            processed.isAnimated ??
+                            firstFrameLength !== undefined,
+                        firstFrameLength: content.firstFrameLength ?? uploaded.firstFrameLength,
+                        firstFrameSidecar: content.firstFrameSidecar ?? uploaded.firstFrameSidecar,
+                        stickerSentTs: content.stickerSentTs ?? Date.now()
+                    }
+                };
+            default:
+                throw new Error(`unsupported media message type: ${String(content.type)}`);
+        }
+    }
+    finally {
+        if (resolved.tempFilePath) {
+            await (0, media_1.cleanupTempFile)(resolved.tempFilePath);
+        }
     }
 }
 function buildUploadUrl(host, uploadType, auth, fileEncSha256) {
@@ -151,11 +216,14 @@ function parseUploadResponse(body, status) {
         ...(parsed.metadata_url ? { metadataUrl: parsed.metadata_url } : {})
     };
 }
-async function uploadMediaBytes(options, content, mediaBytes) {
+async function uploadMediaBytes(options, content, mediaBytes, firstFrameLength) {
     const uploadType = resolveUploadType(content);
     const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
     const [encrypted, mediaConn] = await Promise.all([
-        WaMediaCrypto_1.WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes),
+        WaMediaCrypto_1.WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes, {
+            sidecar: needsSidecar(content),
+            firstFrameLength
+        }),
         getMediaConn(options)
     ]);
     const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ?? mediaConn.hosts[0].hostname;
@@ -170,7 +238,7 @@ async function uploadMediaBytes(options, content, mediaBytes) {
         method: 'POST',
         body: encrypted.ciphertextHmac,
         contentLength: encrypted.ciphertextHmac.byteLength,
-        contentType: content.mimetype
+        contentType: resolveMimetype(content)
     });
     const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
     const parsed = parseUploadResponse(responseBody, uploadResponse.status);
@@ -179,13 +247,19 @@ async function uploadMediaBytes(options, content, mediaBytes) {
         mediaKey,
         fileSha256: encrypted.fileSha256,
         fileEncSha256: encrypted.fileEncSha256,
-        fileLength: mediaBytes.byteLength
+        fileLength: mediaBytes.byteLength,
+        streamingSidecar: encrypted.streamingSidecar,
+        firstFrameSidecar: encrypted.firstFrameSidecar,
+        firstFrameLength
     };
 }
-async function uploadMediaStream(options, content, stream) {
+async function uploadMediaStream(options, content, stream, firstFrameLength) {
     const uploadType = resolveUploadType(content);
     const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
-    const encResult = await WaMediaCrypto_1.WaMediaCrypto.encryptToFile(uploadType, mediaKey, stream);
+    const encResult = await WaMediaCrypto_1.WaMediaCrypto.encryptToFile(uploadType, mediaKey, stream, {
+        sidecar: needsSidecar(content),
+        firstFrameLength
+    });
     let readStream;
     try {
         const mediaConn = await getMediaConn(options);
@@ -204,7 +278,7 @@ async function uploadMediaStream(options, content, stream) {
             method: 'POST',
             body: readStream,
             contentLength: encResult.fileSize,
-            contentType: content.mimetype
+            contentType: resolveMimetype(content)
         });
         const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
         const parsed = parseUploadResponse(responseBody, uploadResponse.status);
@@ -213,7 +287,10 @@ async function uploadMediaStream(options, content, stream) {
             mediaKey,
             fileSha256: encResult.fileSha256,
             fileEncSha256: encResult.fileEncSha256,
-            fileLength: encResult.plaintextLength
+            fileLength: encResult.plaintextLength,
+            streamingSidecar: encResult.streamingSidecar,
+            firstFrameSidecar: encResult.firstFrameSidecar,
+            firstFrameLength
         };
     }
     finally {

package/dist/crypto/core/index.js

@@ -3,7 +3,7 @@
  * Cryptographic utilities
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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.randomFillAsync = exports.randomBytesAsync = exports.buildNonce = exports.readVersionedContent = exports.prependVersion = exports.toRawPubKey = exports.toSerializedPubKey = exports.hkdfSplit = exports.hkdf = exports.X25519 = exports.Ed25519 = void 0;
+exports.xeddsaVerify = exports.xeddsaSign = 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.randomFillAsync = 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");
@@ -38,3 +38,6 @@ Object.defineProperty(exports, "hmacSign", { enumerable: true, get: function ()
 Object.defineProperty(exports, "pbkdf2DeriveAesCtrKey", { enumerable: true, get: function () { return primitives_1.pbkdf2DeriveAesCtrKey; } });
 Object.defineProperty(exports, "aesCtrEncrypt", { enumerable: true, get: function () { return primitives_1.aesCtrEncrypt; } });
 Object.defineProperty(exports, "aesCtrDecrypt", { enumerable: true, get: function () { return primitives_1.aesCtrDecrypt; } });
+var xeddsa_1 = require("../core/xeddsa");
+Object.defineProperty(exports, "xeddsaSign", { enumerable: true, get: function () { return xeddsa_1.xeddsaSign; } });
+Object.defineProperty(exports, "xeddsaVerify", { enumerable: true, get: function () { return xeddsa_1.xeddsaVerify; } });

package/dist/crypto/core/random.js

@@ -1,16 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomIntAsync = void 0;
-exports.randomBytesAsync = randomBytesAsync;
+exports.randomBytesAsync = exports.randomIntAsync = void 0;
 exports.randomFillAsync = randomFillAsync;
 const node_crypto_1 = require("node:crypto");
 const node_util_1 = require("node:util");
-const bytes_1 = require("../../util/bytes");
-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));
-}
 async function randomFillAsync(target, offset, size) {
     await new Promise((resolve, reject) => {
         const onDone = (error) => {
@@ -32,4 +25,5 @@ async function randomFillAsync(target, offset, size) {
     });
     return target;
 }
-exports.randomIntAsync = randomIntAsyncImpl;
+exports.randomIntAsync = (0, node_util_1.promisify)(node_crypto_1.randomInt);
+exports.randomBytesAsync = (0, node_util_1.promisify)(node_crypto_1.randomBytes);

package/dist/crypto/core/xeddsa.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xeddsaVerify = xeddsaVerify;
+exports.xeddsaSign = xeddsaSign;
+const primitives_1 = require("../core/primitives");
+const random_1 = require("../core/random");
+const Ed25519_1 = require("../curves/Ed25519");
+const X25519_1 = require("../curves/X25519");
+const edwards_1 = require("../math/edwards");
+const le_1 = require("../math/le");
+const mod_1 = require("../math/mod");
+const bytes_1 = require("../../util/bytes");
+const PREFIX_SIGNATURE_RANDOM = new Uint8Array([
+    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+]);
+async function xeddsaVerify(curvePublicKey, message, signature) {
+    if (signature.length !== 64) {
+        return false;
+    }
+    if ((signature[63] & 0x60) !== 0) {
+        return false;
+    }
+    const lastByteIndex = 63;
+    const originalLastByte = signature[lastByteIndex];
+    const signBit = originalLastByte & 0x80;
+    signature[lastByteIndex] = originalLastByte & 0x7f;
+    const edPublic = (0, X25519_1.montgomeryToEdwardsPublic)(curvePublicKey, signBit);
+    try {
+        return await Ed25519_1.Ed25519.verify(message, signature, edPublic);
+    }
+    finally {
+        signature[lastByteIndex] = originalLastByte;
+    }
+}
+async function xeddsaSign(privateKey, message) {
+    (0, bytes_1.assertByteLength)(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
+    const clampedPrivateKey = (0, X25519_1.clampCurvePrivateKeyInPlace)(privateKey);
+    const privateScalar = (0, le_1.bytesToBigIntLE)(clampedPrivateKey);
+    const encodedPublic = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(privateScalar));
+    const pubKeySignBit = encodedPublic[31] & 0x80;
+    const randomSuffix = await (0, random_1.randomBytesAsync)(64);
+    const hashInput = (0, bytes_1.concatBytes)([
+        PREFIX_SIGNATURE_RANDOM,
+        clampedPrivateKey,
+        message,
+        randomSuffix
+    ]);
+    const r = (0, mod_1.modGroup)((0, le_1.bytesToBigIntLE)(await (0, primitives_1.sha512)(hashInput)));
+    const encodedR = (0, edwards_1.encodeExtendedPoint)((0, edwards_1.scalarMultBase)(r));
+    const hInput = (0, bytes_1.concatBytes)([encodedR, encodedPublic, message]);
+    const h = (0, mod_1.modGroup)((0, le_1.bytesToBigIntLE)(await (0, primitives_1.sha512)(hInput)));
+    const s = (0, mod_1.modGroup)(r + h * privateScalar);
+    const encodedS = (0, le_1.bigIntToBytesLE)(s, 32);
+    encodedS[31] = (encodedS[31] & 0x7f) | pubKeySignBit;
+    return (0, bytes_1.concatBytes)([encodedR, encodedS]);
+}

package/dist/crypto/curves/X25519.js

@@ -9,6 +9,8 @@ const types_1 = require("../curves/types");
 const constants_2 = require("../math/constants");
 const fe_1 = require("../math/fe");
 const bytes_1 = require("../../util/bytes");
+const runtime_1 = require("../../util/runtime");
+const IS_BUN = (0, runtime_1.isBunRuntime)();
 // Pre-allocated temps for montgomeryToEdwardsPublic (safe: single-threaded)
 const _mx = (0, fe_1.fe)();
 const _m1 = (0, fe_1.fe)();
@@ -69,6 +71,22 @@ class X25519 {
     static async scalarMult(privKey, pubKey) {
         (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');
+        // TODO: When Bun supports deriveBits with X25519 change to Async Web Crypto API
+        // https://github.com/oven-sh/bun/pull/29152
+        if (IS_BUN) {
+            const spki = new Uint8Array(constants_1.X25519_SPKI_PREFIX.length + 32);
+            spki.set(constants_1.X25519_SPKI_PREFIX, 0);
+            spki.set(pubKey, constants_1.X25519_SPKI_PREFIX.length);
+            const shared = (0, node_crypto_1.diffieHellman)({
+                privateKey: (0, node_crypto_1.createPrivateKey)({
+                    key: (0, types_1.pkcs8FromRawPrivate)(constants_1.X25519_PKCS8_PREFIX, privKey),
+                    format: 'der',
+                    type: 'pkcs8'
+                }),
+                publicKey: (0, node_crypto_1.createPublicKey)({ key: spki, format: 'der', type: 'spki' })
+            });
+            return (0, bytes_1.toBytesView)(shared);
+        }
         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, [])

package/dist/crypto/curves/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ED25519_PKCS8_PREFIX = exports.X25519_PKCS8_PREFIX = void 0;
+exports.ED25519_PKCS8_PREFIX = exports.X25519_SPKI_PREFIX = exports.X25519_PKCS8_PREFIX = void 0;
 const bytes_1 = require("../../util/bytes");
 exports.X25519_PKCS8_PREFIX = (0, bytes_1.hexToBytes)('302e020100300506032b656e04220420');
+exports.X25519_SPKI_PREFIX = (0, bytes_1.hexToBytes)('302a300506032b656e032100');
 exports.ED25519_PKCS8_PREFIX = (0, bytes_1.hexToBytes)('302e020100300506032b657004220420');

package/dist/esm/appstate/WaAppStateCrypto.js

@@ -4,15 +4,18 @@ import { aesCbcDecrypt, aesCbcEncrypt, hmacSign, importAesCbcKey, importHmacKey,
 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/bytes.js';
-import { concatBytes, EMPTY_BYTES, intToBytes, TEXT_DECODER, TEXT_ENCODER, uint8Equal } from '../util/bytes.js';
+import { bytesToBase64, concatBytes, EMPTY_BYTES, intToBytes, TEXT_DECODER, TEXT_ENCODER, uint8TimingSafeEqual } 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) {
+    constructor(derivedKeysCacheMaxSize = DEFAULT_DERIVED_KEYS_CACHE_MAX_SIZE, skipMacVerification = false) {
         this.derivedKeysCache = new Map();
         this.derivedKeysCacheMaxSize = normalizeNonNegativeInteger(derivedKeysCacheMaxSize, DEFAULT_DERIVED_KEYS_CACHE_MAX_SIZE);
+        this.skipMacVerification = skipMacVerification;
+    }
+    get isMacVerificationSkipped() {
+        return this.skipMacVerification;
     }
     clearCache() {
         this.derivedKeysCache.clear();
@@ -25,19 +28,25 @@ export class WaAppStateCrypto {
             return cached;
         }
         const derived = await hkdf(keyData, null, WA_APP_STATE_KDF_INFO.MUTATION_KEYS, APP_STATE_DERIVED_KEY_LENGTH);
+        const [indexHmacKey, valueEncryptionAesKey, valueMacHmacKey, snapshotMacHmacKey, patchMacHmacKey] = await Promise.all([
+            importHmacKey(derived.subarray(0, APP_STATE_DERIVED_INDEX_KEY_END)),
+            importAesCbcKey(derived.subarray(APP_STATE_DERIVED_INDEX_KEY_END, APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END)),
+            importHmacSha512Key(derived.subarray(APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END, APP_STATE_DERIVED_VALUE_MAC_KEY_END)),
+            importHmacKey(derived.subarray(APP_STATE_DERIVED_VALUE_MAC_KEY_END, APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END)),
+            importHmacKey(derived.subarray(APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END, APP_STATE_DERIVED_PATCH_MAC_KEY_END))
+        ]);
         const keys = {
-            indexKey: derived.subarray(0, APP_STATE_DERIVED_INDEX_KEY_END),
-            valueEncryptionKey: derived.subarray(APP_STATE_DERIVED_INDEX_KEY_END, APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END),
-            valueMacKey: derived.subarray(APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END, APP_STATE_DERIVED_VALUE_MAC_KEY_END),
-            snapshotMacKey: derived.subarray(APP_STATE_DERIVED_VALUE_MAC_KEY_END, APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END),
-            patchMacKey: derived.subarray(APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END, APP_STATE_DERIVED_PATCH_MAC_KEY_END)
+            indexHmacKey,
+            valueEncryptionAesKey,
+            valueMacHmacKey,
+            snapshotMacHmacKey,
+            patchMacHmacKey
         };
         this.touchDerivedKeysCacheEntry(cacheKey, keys);
         return keys;
     }
-    async generateIndexMac(indexKey, indexBytes) {
-        const key = await importHmacKey(indexKey);
-        return hmacSign(key, indexBytes);
+    async generateIndexMac(indexHmacKey, indexBytes) {
+        return hmacSign(indexHmacKey, indexBytes);
     }
     async encryptMutation(args) {
         const derivedKeys = await this.deriveKeys(args.keyData);
@@ -52,13 +61,12 @@ export class WaAppStateCrypto {
         if (iv.byteLength !== APP_STATE_IV_LENGTH) {
             throw new Error(`invalid IV length ${iv.byteLength}`);
         }
-        const indexMacPromise = this.generateIndexMac(derivedKeys.indexKey, indexBytes);
-        const encryptionKey = await importAesCbcKey(derivedKeys.valueEncryptionKey);
-        const cipherText = await aesCbcEncrypt(encryptionKey, iv, encoded);
+        const indexMacPromise = this.generateIndexMac(derivedKeys.indexHmacKey, indexBytes);
+        const cipherText = await aesCbcEncrypt(derivedKeys.valueEncryptionAesKey, iv, encoded);
         const cipherWithIv = concatBytes([iv, cipherText]);
         const associatedData = this.generateAssociatedData(args.operation, args.keyId);
         const [valueMac, indexMac] = await Promise.all([
-            this.generateValueMac(derivedKeys.valueMacKey, associatedData, cipherWithIv),
+            this.generateValueMac(derivedKeys.valueMacHmacKey, associatedData, cipherWithIv),
             indexMacPromise
         ]);
         return {
@@ -76,13 +84,14 @@ export class WaAppStateCrypto {
         const mac = args.valueBlob.subarray(args.valueBlob.byteLength - APP_STATE_VALUE_MAC_LENGTH);
         const cipherText = args.valueBlob.subarray(APP_STATE_IV_LENGTH, args.valueBlob.byteLength - APP_STATE_VALUE_MAC_LENGTH);
         const cipherWithIv = args.valueBlob.subarray(0, args.valueBlob.byteLength - APP_STATE_VALUE_MAC_LENGTH);
-        const associatedData = this.generateAssociatedData(args.operation, args.keyId);
-        const expectedMac = await this.generateValueMac(derivedKeys.valueMacKey, associatedData, cipherWithIv);
-        if (!uint8Equal(mac, expectedMac)) {
-            throw new Error('mutation value MAC mismatch');
+        if (!this.skipMacVerification) {
+            const associatedData = this.generateAssociatedData(args.operation, args.keyId);
+            const expectedMac = await this.generateValueMac(derivedKeys.valueMacHmacKey, associatedData, cipherWithIv);
+            if (!uint8TimingSafeEqual(mac, expectedMac)) {
+                throw new Error('mutation value MAC mismatch');
+            }
         }
-        const decryptionKey = await importAesCbcKey(derivedKeys.valueEncryptionKey);
-        const plaintext = await aesCbcDecrypt(decryptionKey, iv, cipherText);
+        const plaintext = await aesCbcDecrypt(derivedKeys.valueEncryptionAesKey, iv, cipherText);
         const syncActionData = proto.SyncActionData.decode(plaintext);
         if (!syncActionData.index) {
             throw new Error('missing sync action index');
@@ -90,9 +99,11 @@ export class WaAppStateCrypto {
         if (syncActionData.version === null || syncActionData.version === undefined) {
             throw new Error('missing sync action version');
         }
-        const generatedIndexMac = await this.generateIndexMac(derivedKeys.indexKey, syncActionData.index);
-        if (!uint8Equal(generatedIndexMac, args.indexMac)) {
-            throw new Error('mutation index MAC mismatch');
+        if (!this.skipMacVerification) {
+            const generatedIndexMac = await this.generateIndexMac(derivedKeys.indexHmacKey, syncActionData.index);
+            if (!uint8TimingSafeEqual(generatedIndexMac, args.indexMac)) {
+                throw new Error('mutation index MAC mismatch');
+            }
         }
         return {
             index: TEXT_DECODER.decode(syncActionData.index),
@@ -109,8 +120,7 @@ export class WaAppStateCrypto {
             intToBytes(8, version),
             TEXT_ENCODER.encode(collectionName)
         ]);
-        const key = await importHmacKey(derivedKeys.snapshotMacKey);
-        return hmacSign(key, payload);
+        return hmacSign(derivedKeys.snapshotMacHmacKey, payload);
     }
     async generatePatchMac(keyData, snapshotMac, valueMacs, version, collectionName) {
         const derivedKeys = await this.deriveKeys(keyData);
@@ -120,8 +130,7 @@ export class WaAppStateCrypto {
             intToBytes(8, version),
             TEXT_ENCODER.encode(collectionName)
         ]);
-        const key = await importHmacKey(derivedKeys.patchMacKey);
-        return hmacSign(key, payload);
+        return hmacSign(derivedKeys.patchMacHmacKey, payload);
     }
     async ltHashAdd(base, addValues) {
         return this.ltHashApply(base, addValues, (left, right) => left + right);
@@ -175,11 +184,10 @@ export class WaAppStateCrypto {
         out.set(keyId, 1);
         return out;
     }
-    async generateValueMac(valueMacKey, associatedData, cipherWithIv) {
+    async generateValueMac(valueMacHmacKey, associatedData, cipherWithIv) {
         const octetLength = new Uint8Array(APP_STATE_MAC_OCTET_LENGTH);
         octetLength[octetLength.length - 1] = associatedData.byteLength & 0xff;
-        const key = await importHmacSha512Key(valueMacKey);
-        const full = await hmacSign(key, concatBytes([associatedData, cipherWithIv, octetLength]));
+        const full = await hmacSign(valueMacHmacKey, concatBytes([associatedData, cipherWithIv, octetLength]));
         return full.subarray(0, APP_STATE_VALUE_MAC_LENGTH);
     }
     touchDerivedKeysCacheEntry(cacheKey, keys) {