zapo-js 0.2.0 → 0.3.0

package/README.md

@@ -1,4 +1,6 @@
-<h1 align="center">zapo</h1>
+<p align="center">
+  <img src=".github/assets/logo.png" alt="zapo" width="400" />
+</p>
 
 <p align="center">
   <strong>High-performance TypeScript implementation of the WhatsApp Web protocol.</strong><br />
@@ -129,12 +131,14 @@ const store = createStore({
     providers: {
         auth: 'sqlite',
         signal: 'sqlite',
+        preKey: 'sqlite',
+        session: 'sqlite',
+        identity: 'sqlite',
         senderKey: 'sqlite',
         appState: 'sqlite',
         messages: 'sqlite',
         threads: 'sqlite',
-        contacts: 'sqlite',
-        privacyToken: 'sqlite'
+        contacts: 'sqlite'
     }
 })
 

package/dist/appstate/WaAppStateCrypto.js

@@ -8,14 +8,17 @@ const random_1 = require("../crypto/core/random");
 const _proto_1 = require("../proto.js");
 const constants_2 = require("../protocol/constants");
 const bytes_1 = require("../util/bytes");
-const bytes_2 = require("../util/bytes");
 const collections_1 = require("../util/collections");
 const primitives_2 = require("../util/primitives");
 const DEFAULT_DERIVED_KEYS_CACHE_MAX_SIZE = 256;
 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 = (0, primitives_2.normalizeNonNegativeInteger)(derivedKeysCacheMaxSize, DEFAULT_DERIVED_KEYS_CACHE_MAX_SIZE);
+        this.skipMacVerification = skipMacVerification;
+    }
+    get isMacVerificationSkipped() {
+        return this.skipMacVerification;
     }
     clearCache() {
         this.derivedKeysCache.clear();
@@ -28,45 +31,50 @@ class WaAppStateCrypto {
             return cached;
         }
         const derived = await (0, hkdf_1.hkdf)(keyData, null, constants_2.WA_APP_STATE_KDF_INFO.MUTATION_KEYS, constants_1.APP_STATE_DERIVED_KEY_LENGTH);
+        const [indexHmacKey, valueEncryptionAesKey, valueMacHmacKey, snapshotMacHmacKey, patchMacHmacKey] = await Promise.all([
+            (0, primitives_1.importHmacKey)(derived.subarray(0, constants_1.APP_STATE_DERIVED_INDEX_KEY_END)),
+            (0, primitives_1.importAesCbcKey)(derived.subarray(constants_1.APP_STATE_DERIVED_INDEX_KEY_END, constants_1.APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END)),
+            (0, primitives_1.importHmacSha512Key)(derived.subarray(constants_1.APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END, constants_1.APP_STATE_DERIVED_VALUE_MAC_KEY_END)),
+            (0, primitives_1.importHmacKey)(derived.subarray(constants_1.APP_STATE_DERIVED_VALUE_MAC_KEY_END, constants_1.APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END)),
+            (0, primitives_1.importHmacKey)(derived.subarray(constants_1.APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END, constants_1.APP_STATE_DERIVED_PATCH_MAC_KEY_END))
+        ]);
         const keys = {
-            indexKey: derived.subarray(0, constants_1.APP_STATE_DERIVED_INDEX_KEY_END),
-            valueEncryptionKey: derived.subarray(constants_1.APP_STATE_DERIVED_INDEX_KEY_END, constants_1.APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END),
-            valueMacKey: derived.subarray(constants_1.APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END, constants_1.APP_STATE_DERIVED_VALUE_MAC_KEY_END),
-            snapshotMacKey: derived.subarray(constants_1.APP_STATE_DERIVED_VALUE_MAC_KEY_END, constants_1.APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END),
-            patchMacKey: derived.subarray(constants_1.APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END, constants_1.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 (0, primitives_1.importHmacKey)(indexKey);
-        return (0, primitives_1.hmacSign)(key, indexBytes);
+    async generateIndexMac(indexHmacKey, indexBytes) {
+        return (0, primitives_1.hmacSign)(indexHmacKey, indexBytes);
     }
     async encryptMutation(args) {
         const derivedKeys = await this.deriveKeys(args.keyData);
-        const indexBytes = bytes_2.TEXT_ENCODER.encode(args.index);
+        const indexBytes = bytes_1.TEXT_ENCODER.encode(args.index);
         const encoded = _proto_1.proto.SyncActionData.encode({
             index: indexBytes,
             value: args.value ?? undefined,
-            padding: bytes_2.EMPTY_BYTES,
+            padding: bytes_1.EMPTY_BYTES,
             version: args.version
         }).finish();
         const iv = args.iv ?? (await (0, random_1.randomBytesAsync)(constants_1.APP_STATE_IV_LENGTH));
         if (iv.byteLength !== constants_1.APP_STATE_IV_LENGTH) {
             throw new Error(`invalid IV length ${iv.byteLength}`);
         }
-        const indexMacPromise = this.generateIndexMac(derivedKeys.indexKey, indexBytes);
-        const encryptionKey = await (0, primitives_1.importAesCbcKey)(derivedKeys.valueEncryptionKey);
-        const cipherText = await (0, primitives_1.aesCbcEncrypt)(encryptionKey, iv, encoded);
-        const cipherWithIv = (0, bytes_2.concatBytes)([iv, cipherText]);
+        const indexMacPromise = this.generateIndexMac(derivedKeys.indexHmacKey, indexBytes);
+        const cipherText = await (0, primitives_1.aesCbcEncrypt)(derivedKeys.valueEncryptionAesKey, iv, encoded);
+        const cipherWithIv = (0, bytes_1.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 {
             indexMac,
-            valueBlob: (0, bytes_2.concatBytes)([cipherWithIv, valueMac]),
+            valueBlob: (0, bytes_1.concatBytes)([cipherWithIv, valueMac]),
             valueMac
         };
     }
@@ -79,13 +87,14 @@ class WaAppStateCrypto {
         const mac = args.valueBlob.subarray(args.valueBlob.byteLength - constants_1.APP_STATE_VALUE_MAC_LENGTH);
         const cipherText = args.valueBlob.subarray(constants_1.APP_STATE_IV_LENGTH, args.valueBlob.byteLength - constants_1.APP_STATE_VALUE_MAC_LENGTH);
         const cipherWithIv = args.valueBlob.subarray(0, args.valueBlob.byteLength - constants_1.APP_STATE_VALUE_MAC_LENGTH);
-        const associatedData = this.generateAssociatedData(args.operation, args.keyId);
-        const expectedMac = await this.generateValueMac(derivedKeys.valueMacKey, associatedData, cipherWithIv);
-        if (!(0, bytes_2.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 (!(0, bytes_1.uint8TimingSafeEqual)(mac, expectedMac)) {
+                throw new Error('mutation value MAC mismatch');
+            }
         }
-        const decryptionKey = await (0, primitives_1.importAesCbcKey)(derivedKeys.valueEncryptionKey);
-        const plaintext = await (0, primitives_1.aesCbcDecrypt)(decryptionKey, iv, cipherText);
+        const plaintext = await (0, primitives_1.aesCbcDecrypt)(derivedKeys.valueEncryptionAesKey, iv, cipherText);
         const syncActionData = _proto_1.proto.SyncActionData.decode(plaintext);
         if (!syncActionData.index) {
             throw new Error('missing sync action index');
@@ -93,12 +102,14 @@ 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 (!(0, bytes_2.uint8Equal)(generatedIndexMac, args.indexMac)) {
-            throw new Error('mutation index MAC mismatch');
+        if (!this.skipMacVerification) {
+            const generatedIndexMac = await this.generateIndexMac(derivedKeys.indexHmacKey, syncActionData.index);
+            if (!(0, bytes_1.uint8TimingSafeEqual)(generatedIndexMac, args.indexMac)) {
+                throw new Error('mutation index MAC mismatch');
+            }
         }
         return {
-            index: bytes_2.TEXT_DECODER.decode(syncActionData.index),
+            index: bytes_1.TEXT_DECODER.decode(syncActionData.index),
             value: syncActionData.value ?? null,
             version: syncActionData.version,
             indexMac: args.indexMac,
@@ -107,24 +118,22 @@ class WaAppStateCrypto {
     }
     async generateSnapshotMac(keyData, ltHash, version, collectionName) {
         const derivedKeys = await this.deriveKeys(keyData);
-        const payload = (0, bytes_2.concatBytes)([
+        const payload = (0, bytes_1.concatBytes)([
             ltHash,
-            (0, bytes_2.intToBytes)(8, version),
-            bytes_2.TEXT_ENCODER.encode(collectionName)
+            (0, bytes_1.intToBytes)(8, version),
+            bytes_1.TEXT_ENCODER.encode(collectionName)
         ]);
-        const key = await (0, primitives_1.importHmacKey)(derivedKeys.snapshotMacKey);
-        return (0, primitives_1.hmacSign)(key, payload);
+        return (0, primitives_1.hmacSign)(derivedKeys.snapshotMacHmacKey, payload);
     }
     async generatePatchMac(keyData, snapshotMac, valueMacs, version, collectionName) {
         const derivedKeys = await this.deriveKeys(keyData);
-        const payload = (0, bytes_2.concatBytes)([
+        const payload = (0, bytes_1.concatBytes)([
             snapshotMac,
             ...valueMacs,
-            (0, bytes_2.intToBytes)(8, version),
-            bytes_2.TEXT_ENCODER.encode(collectionName)
+            (0, bytes_1.intToBytes)(8, version),
+            bytes_1.TEXT_ENCODER.encode(collectionName)
         ]);
-        const key = await (0, primitives_1.importHmacKey)(derivedKeys.patchMacKey);
-        return (0, primitives_1.hmacSign)(key, payload);
+        return (0, primitives_1.hmacSign)(derivedKeys.patchMacHmacKey, payload);
     }
     async ltHashAdd(base, addValues) {
         return this.ltHashApply(base, addValues, (left, right) => left + right);
@@ -178,11 +187,10 @@ class WaAppStateCrypto {
         out.set(keyId, 1);
         return out;
     }
-    async generateValueMac(valueMacKey, associatedData, cipherWithIv) {
+    async generateValueMac(valueMacHmacKey, associatedData, cipherWithIv) {
         const octetLength = new Uint8Array(constants_1.APP_STATE_MAC_OCTET_LENGTH);
         octetLength[octetLength.length - 1] = associatedData.byteLength & 0xff;
-        const key = await (0, primitives_1.importHmacSha512Key)(valueMacKey);
-        const full = await (0, primitives_1.hmacSign)(key, (0, bytes_2.concatBytes)([associatedData, cipherWithIv, octetLength]));
+        const full = await (0, primitives_1.hmacSign)(valueMacHmacKey, (0, bytes_1.concatBytes)([associatedData, cipherWithIv, octetLength]));
         return full.subarray(0, constants_1.APP_STATE_VALUE_MAC_LENGTH);
     }
     touchDerivedKeysCacheEntry(cacheKey, keys) {

package/dist/appstate/WaAppStateSyncClient.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaAppStateSyncClient = exports.WaAppStateMissingKeyError = void 0;
 const constants_1 = require("./constants");
+const response_parser_1 = require("./response-parser");
 const WaAppStateCrypto_1 = require("./WaAppStateCrypto");
-const WaAppStateSyncResponseParser_1 = require("./WaAppStateSyncResponseParser");
+const _crypto_1 = require("../crypto/index.js");
 const _proto_1 = require("../proto.js");
 const constants_2 = require("../protocol/constants");
 const jid_1 = require("../protocol/jid");
 const query_1 = require("../transport/node/query");
 const bytes_1 = require("../util/bytes");
-const bytes_2 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 class WaAppStateMissingKeyError extends Error {
     constructor(message, keyId, collection) {
@@ -29,7 +29,8 @@ class WaAppStateSyncClient {
         this.hostDomain = options.hostDomain ?? constants_2.WA_DEFAULTS.HOST_DOMAIN;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? constants_2.WA_DEFAULTS.APP_STATE_SYNC_TIMEOUT_MS;
         this.onMissingKeys = options.onMissingKeys;
-        this.crypto = new WaAppStateCrypto_1.WaAppStateCrypto();
+        this.crypto = new WaAppStateCrypto_1.WaAppStateCrypto(undefined, options.skipMacVerification === true);
+        this.mobilePrimary = options.mobilePrimary ?? false;
         this.syncContext = null;
         this.syncPromise = null;
     }
@@ -37,6 +38,28 @@ class WaAppStateSyncClient {
         this.logger.trace('app-state export requested');
         return this.store.exportData();
     }
+    async ensureInitialSyncKey() {
+        const existing = await this.store.getActiveSyncKey();
+        if (existing) {
+            return existing;
+        }
+        const keyIdBytes = await (0, _crypto_1.randomBytesAsync)(2);
+        const keyData = await (0, _crypto_1.randomBytesAsync)(32);
+        const rawId = await (0, _crypto_1.randomIntAsync)(0, 4294967295);
+        const key = {
+            keyId: keyIdBytes,
+            keyData,
+            timestamp: Date.now(),
+            fingerprint: { rawId, currentIndex: 0, deviceIndexes: [0] }
+        };
+        await this.store.upsertSyncKeys([key]);
+        this.crypto.clearCache();
+        this.logger.info('app-state initial sync key generated (mobile primary)', {
+            keyId: (0, bytes_1.bytesToHex)(keyIdBytes),
+            rawId
+        });
+        return key;
+    }
     async importSyncKeys(keys) {
         this.logger.debug('app-state importing sync keys', { count: keys.length });
         const inserted = await this.store.upsertSyncKeys(keys);
@@ -52,7 +75,7 @@ class WaAppStateSyncClient {
             const keyId = (0, bytes_1.decodeProtoBytes)(item.keyId?.keyId, 'appStateSyncKeyShare.keys[].keyId.keyId');
             if (!item.keyData?.keyData) {
                 this.logger.debug('app-state sync key share entry missing key data', {
-                    keyId: (0, bytes_2.bytesToHex)(keyId)
+                    keyId: (0, bytes_1.bytesToHex)(keyId)
                 });
                 continue;
             }
@@ -220,7 +243,7 @@ class WaAppStateSyncClient {
                 blockedCollections.push(entry.collection);
             }
             if (entry.missingKeyId) {
-                const keyHex = (0, bytes_2.bytesToHex)(entry.missingKeyId);
+                const keyHex = (0, bytes_1.bytesToHex)(entry.missingKeyId);
                 if (!missingKeyIdHexes.has(keyHex)) {
                     missingKeyIdHexes.add(keyHex);
                     missingKeyIds.push(entry.missingKeyId);
@@ -287,7 +310,7 @@ class WaAppStateSyncClient {
             content: [
                 {
                     tag: constants_2.WA_NODE_TAGS.SYNC,
-                    attrs: {},
+                    attrs: this.mobilePrimary ? { data_namespace: '3' } : {},
                     content: collectionNodes
                 }
             ]
@@ -300,7 +323,7 @@ class WaAppStateSyncClient {
             type: responseNode.attrs.type
         });
         (0, query_1.assertIqResult)(responseNode, 'app-state sync');
-        const payloads = (0, WaAppStateSyncResponseParser_1.parseSyncResponse)(responseNode);
+        const payloads = (0, response_parser_1.parseSyncResponse)(responseNode);
         this.logger.debug('app-state sync payloads parsed', { count: payloads.length });
         const payloadByCollection = new Map();
         for (const payload of payloads) {
@@ -417,7 +440,7 @@ class WaAppStateSyncClient {
         if (keyIds.length === 0 || collections.length === 0) {
             return;
         }
-        const keyIdsHex = keyIds.map((keyId) => (0, bytes_2.bytesToHex)(keyId));
+        const keyIdsHex = keyIds.map((keyId) => (0, bytes_1.bytesToHex)(keyId));
         this.logger.info('app-state requesting missing sync keys', {
             keys: keyIdsHex.length,
             keyIds: keyIdsHex.join(','),
@@ -466,11 +489,13 @@ class WaAppStateSyncClient {
         if (!snapshot.version?.version) {
             throw new Error(`snapshot for ${collection} is missing version`);
         }
-        if (!snapshot.mac) {
-            throw new Error(`snapshot for ${collection} is missing mac`);
-        }
-        if (!snapshot.keyId?.id) {
-            throw new Error(`snapshot for ${collection} is missing keyId`);
+        if (!this.crypto.isMacVerificationSkipped) {
+            if (!snapshot.mac) {
+                throw new Error(`snapshot for ${collection} is missing mac`);
+            }
+            if (!snapshot.keyId?.id) {
+                throw new Error(`snapshot for ${collection} is missing keyId`);
+            }
         }
         return snapshot;
     }
@@ -485,14 +510,16 @@ class WaAppStateSyncClient {
         if (!patch.version?.version) {
             throw new Error(`patch for ${collection} is missing version`);
         }
-        if (!patch.snapshotMac) {
-            throw new Error(`patch for ${collection} is missing snapshotMac`);
-        }
-        if (!patch.patchMac) {
-            throw new Error(`patch for ${collection} is missing patchMac`);
-        }
-        if (!patch.keyId?.id) {
-            throw new Error(`patch for ${collection} is missing keyId`);
+        if (!this.crypto.isMacVerificationSkipped) {
+            if (!patch.snapshotMac) {
+                throw new Error(`patch for ${collection} is missing snapshotMac`);
+            }
+            if (!patch.patchMac) {
+                throw new Error(`patch for ${collection} is missing patchMac`);
+            }
+            if (!patch.keyId?.id) {
+                throw new Error(`patch for ${collection} is missing keyId`);
+            }
         }
         if (patch.mutations && patch.mutations.length > 0 && patch.externalMutations) {
             throw new Error(`patch for ${collection} has inline and external mutations together`);
@@ -506,16 +533,19 @@ class WaAppStateSyncClient {
     }
     async applySnapshot(collection, snapshot) {
         const version = this.normalizeProtoLong(snapshot.version?.version, `snapshot.version.version (${collection})`);
-        const keyId = (0, bytes_1.decodeProtoBytes)(snapshot.keyId?.id, `snapshot.keyId.id (${collection})`);
-        const keyData = await this.getKeyData(keyId);
-        if (!keyData) {
-            throw new WaAppStateMissingKeyError(`missing snapshot key ${(0, bytes_2.bytesToHex)(keyId)} for ${collection}`, keyId, collection);
+        let keyData = null;
+        if (!this.crypto.isMacVerificationSkipped) {
+            const keyId = (0, bytes_1.decodeProtoBytes)(snapshot.keyId?.id, `snapshot.keyId.id (${collection})`);
+            keyData = await this.getKeyData(keyId);
+            if (!keyData) {
+                throw new WaAppStateMissingKeyError(`missing snapshot key ${(0, bytes_1.bytesToHex)(keyId)} for ${collection}`, keyId, collection);
+            }
         }
         const indexValueMap = new Map();
         const mutations = [];
         const decryptedRecords = await this.decryptSnapshotRecords(collection, snapshot);
         for (const { decrypted, recordKeyId } of decryptedRecords) {
-            const indexMacHex = (0, bytes_2.bytesToHex)(decrypted.indexMac);
+            const indexMacHex = (0, bytes_1.bytesToHex)(decrypted.indexMac);
             indexValueMap.set(indexMacHex, decrypted.valueMac);
             mutations.push({
                 collection,
@@ -537,9 +567,11 @@ class WaAppStateSyncClient {
             ltHashInputIndex += 1;
         }
         const ltHash = await this.crypto.ltHashAdd(constants_1.APP_STATE_EMPTY_LT_HASH, ltHashInput);
-        const expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
-        if (!(0, bytes_2.uint8Equal)(expectedSnapshotMac, snapshot.mac)) {
-            throw new Error(`snapshot MAC mismatch for ${collection}`);
+        if (keyData !== null) {
+            const expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
+            if (!(0, bytes_1.uint8Equal)(expectedSnapshotMac, snapshot.mac)) {
+                throw new Error(`snapshot MAC mismatch for ${collection}`);
+            }
         }
         this.setCollectionState(collection, version, ltHash, indexValueMap);
         return mutations;
@@ -550,10 +582,13 @@ class WaAppStateSyncClient {
         if (current.version !== patchVersion - 1) {
             throw new Error(`patch version mismatch for ${collection}: local=${current.version}, incoming=${patchVersion}`);
         }
-        const patchKeyId = (0, bytes_1.decodeProtoBytes)(patch.keyId?.id, `patch.keyId.id (${collection})`);
-        const patchKeyData = await this.getKeyData(patchKeyId);
-        if (!patchKeyData) {
-            throw new WaAppStateMissingKeyError(`missing patch key ${(0, bytes_2.bytesToHex)(patchKeyId)} for ${collection}`, patchKeyId, collection);
+        let patchKeyData = null;
+        if (!this.crypto.isMacVerificationSkipped) {
+            const patchKeyId = (0, bytes_1.decodeProtoBytes)(patch.keyId?.id, `patch.keyId.id (${collection})`);
+            patchKeyData = await this.getKeyData(patchKeyId);
+            if (!patchKeyData) {
+                throw new WaAppStateMissingKeyError(`missing patch key ${(0, bytes_1.bytesToHex)(patchKeyId)} for ${collection}`, patchKeyId, collection);
+            }
         }
         const decryptedMutations = await this.decryptPatchMutations(collection, patch);
         const macMutations = new Array(decryptedMutations.length);
@@ -568,7 +603,9 @@ class WaAppStateSyncClient {
             };
         }
         const nextState = await this.computeNextCollectionState(current.hash, current.indexValueMap, macMutations, collection);
-        await this.assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextState.hash, valueMacs);
+        if (patchKeyData !== null) {
+            await this.assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextState.hash, valueMacs);
+        }
         this.setCollectionState(collection, patchVersion, nextState.hash, nextState.indexValueMap);
         return decryptedMutations;
     }
@@ -593,7 +630,7 @@ class WaAppStateSyncClient {
             decryptTasks[i] = (async () => {
                 const recordKeyData = await this.getKeyData(recordKeyId);
                 if (!recordKeyData) {
-                    throw new WaAppStateMissingKeyError(`missing snapshot mutation key ${(0, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                    throw new WaAppStateMissingKeyError(`missing snapshot mutation key ${(0, bytes_1.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
                 }
                 const decrypted = await this.crypto.decryptMutation({
                     operation: _proto_1.proto.SyncdMutation.SyncdOperation.SET,
@@ -640,7 +677,7 @@ class WaAppStateSyncClient {
             decryptTasks[i] = (async () => {
                 const recordKeyData = await this.getKeyData(recordKeyId);
                 if (!recordKeyData) {
-                    throw new WaAppStateMissingKeyError(`missing mutation key ${(0, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                    throw new WaAppStateMissingKeyError(`missing mutation key ${(0, bytes_1.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
                 }
                 const decrypted = await this.crypto.decryptMutation({
                     operation: operationCode,
@@ -671,12 +708,12 @@ class WaAppStateSyncClient {
     async assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextHash, valueMacs) {
         const snapshotMac = (0, bytes_1.decodeProtoBytes)(patch.snapshotMac, `patch.snapshotMac (${collection})`);
         const expectedSnapshotMac = await this.crypto.generateSnapshotMac(patchKeyData, nextHash, patchVersion, collection);
-        if (!(0, bytes_2.uint8Equal)(expectedSnapshotMac, snapshotMac)) {
+        if (!(0, bytes_1.uint8Equal)(expectedSnapshotMac, snapshotMac)) {
             throw new Error(`patch snapshot MAC mismatch for ${collection}`);
         }
         const patchMac = (0, bytes_1.decodeProtoBytes)(patch.patchMac, `patch.patchMac (${collection})`);
         const expectedPatchMac = await this.crypto.generatePatchMac(patchKeyData, snapshotMac, valueMacs, patchVersion, collection);
-        if (!(0, bytes_2.uint8Equal)(expectedPatchMac, patchMac)) {
+        if (!(0, bytes_1.uint8Equal)(expectedPatchMac, patchMac)) {
             throw new Error(`patch MAC mismatch for ${collection}`);
         }
     }
@@ -771,7 +808,7 @@ class WaAppStateSyncClient {
         const removeValues = [];
         let missingRemoveCount = 0;
         for (const mutation of mutations) {
-            const indexMacHex = (0, bytes_2.bytesToHex)(mutation.indexMac);
+            const indexMacHex = (0, bytes_1.bytesToHex)(mutation.indexMac);
             const existing = indexValueMap.get(indexMacHex);
             if (mutation.operation === _proto_1.proto.SyncdMutation.SyncdOperation.REMOVE) {
                 if (!existing) {
@@ -845,7 +882,7 @@ class WaAppStateSyncClient {
         const missingKeyHexes = new Set();
         for (let index = 0; index < keyIds.length; index += 1) {
             const keyId = keyIds[index];
-            const keyHex = (0, bytes_2.bytesToHex)(keyId);
+            const keyHex = (0, bytes_1.bytesToHex)(keyId);
             if (context.keys.has(keyHex) || missingKeyHexes.has(keyHex)) {
                 continue;
             }
@@ -857,12 +894,12 @@ class WaAppStateSyncClient {
         }
         const loadedKeyData = await this.store.getSyncKeyDataBatch(missingKeyIds);
         for (let index = 0; index < missingKeyIds.length; index += 1) {
-            context.keys.set((0, bytes_2.bytesToHex)(missingKeyIds[index]), loadedKeyData[index] ?? null);
+            context.keys.set((0, bytes_1.bytesToHex)(missingKeyIds[index]), loadedKeyData[index] ?? null);
         }
     }
     async getKeyData(keyId) {
         const context = this.requireSyncContext();
-        const keyHex = (0, bytes_2.bytesToHex)(keyId);
+        const keyHex = (0, bytes_1.bytesToHex)(keyId);
         if (context.keys.has(keyHex)) {
             return context.keys.get(keyHex) ?? null;
         }

package/dist/appstate/index.js

@@ -24,7 +24,7 @@ Object.defineProperty(exports, "decodeAppStateSyncKeys", { enumerable: true, get
 __exportStar(require("./utils"), exports);
 var WaAppStateCrypto_1 = require("./WaAppStateCrypto");
 Object.defineProperty(exports, "WaAppStateCrypto", { enumerable: true, get: function () { return WaAppStateCrypto_1.WaAppStateCrypto; } });
-var WaAppStateSyncResponseParser_1 = require("./WaAppStateSyncResponseParser");
-Object.defineProperty(exports, "parseSyncResponse", { enumerable: true, get: function () { return WaAppStateSyncResponseParser_1.parseSyncResponse; } });
+var response_parser_1 = require("./response-parser");
+Object.defineProperty(exports, "parseSyncResponse", { enumerable: true, get: function () { return response_parser_1.parseSyncResponse; } });
 var WaAppStateSyncClient_1 = require("./WaAppStateSyncClient");
 Object.defineProperty(exports, "WaAppStateSyncClient", { enumerable: true, get: function () { return WaAppStateSyncClient_1.WaAppStateSyncClient; } });

package/dist/auth/WaAuthClient.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaAuthClient = void 0;
-const WaAuthCredentialsFlow_1 = require("./flow/WaAuthCredentialsFlow");
+const credentials_flow_1 = require("./credentials-flow");
 const WaPairingFlow_1 = require("./pairing/WaPairingFlow");
 const WaQrFlow_1 = require("./pairing/WaQrFlow");
 const constants_1 = require("../protocol/constants");
@@ -27,6 +27,7 @@ class WaAuthClient {
         this.callbacks = deps.callbacks ?? {};
         this.authStore = deps.authStore;
         this.signalStore = deps.signalStore;
+        this.preKeyStore = deps.preKeyStore;
         this.credentials = null;
         this.qrFlow = new WaQrFlow_1.WaQrFlow({
             logger: this.logger,
@@ -47,7 +48,8 @@ class WaAuthClient {
                 emitPairingCode: (code) => this.callbacks.onPairingCode?.(code),
                 emitPairingRefresh: (forceManual) => this.callbacks.onPairingRefresh?.(forceManual),
                 emitPaired: (credentials) => this.callbacks.onPaired?.(credentials)
-            }
+            },
+            dangerous: options.dangerous
         });
     }
     getState(connected = false) {
@@ -64,10 +66,12 @@ class WaAuthClient {
     async loadOrCreateCredentials() {
         return this.runHandled(async () => {
             this.logger.debug('auth client loadOrCreateCredentials start');
-            this.credentials = await (0, WaAuthCredentialsFlow_1.loadOrCreateCredentials)({
+            this.credentials = await (0, credentials_flow_1.loadOrCreateCredentials)({
                 logger: this.logger,
                 authStore: this.authStore,
-                signalStore: this.signalStore
+                signalStore: this.signalStore,
+                preKeyStore: this.preKeyStore,
+                skipSignedPreKeySignatureVerification: this.options.dangerous?.disableSignedPreKeySignatureVerification
             });
             this.logger.info('auth client credentials ready', {
                 registered: this.credentials?.meJid !== null && this.credentials?.meJid !== undefined
@@ -75,13 +79,17 @@ class WaAuthClient {
             return this.credentials;
         });
     }
-    buildCommsConfig(socketOptions) {
+    buildCommsConfig(socketOptions, overrides = {}) {
         this.logger.trace('auth client building comms config');
-        return (0, WaAuthCredentialsFlow_1.buildCommsConfig)(this.logger, this.requireCredentials(), socketOptions, {
+        return (0, credentials_flow_1.buildCommsConfig)(this.logger, this.requireCredentials(), socketOptions, {
             deviceBrowser: this.options.deviceBrowser,
             deviceOsDisplayName: this.options.deviceOsDisplayName,
             requireFullSync: this.options.requireFullSync,
-            version: this.options.version
+            version: this.options.version,
+            mobileTransport: this.options.mobileTransport,
+            noiseTrustedRootCa: overrides.noiseTrustedRootCa,
+            disableNoiseCertificateChainVerification: overrides.disableNoiseCertificateChainVerification ??
+                this.options.dangerous?.disableNoiseCertificateChainVerification
         });
     }
     async clearTransientState() {
@@ -180,10 +188,10 @@ class WaAuthClient {
             }
         });
     }
-    async requestPairingCode(phoneNumber, shouldShowPushNotification = false) {
+    async requestPairingCode(phoneNumber, shouldShowPushNotification = false, customCode) {
         this.requireCredentials();
         this.logger.info('auth client requesting pairing code');
-        return this.runHandled(() => this.pairingFlow.requestPairingCode(phoneNumber, shouldShowPushNotification));
+        return this.runHandled(() => this.pairingFlow.requestPairingCode(phoneNumber, shouldShowPushNotification, customCode));
     }
     async fetchPairingCountryCodeIso() {
         this.requireCredentials();
@@ -228,10 +236,11 @@ class WaAuthClient {
             registered: credentials?.meJid !== null && credentials?.meJid !== undefined
         });
         this.credentials = credentials;
-        await (0, WaAuthCredentialsFlow_1.persistCredentials)({
+        await (0, credentials_flow_1.persistCredentials)({
             logger: this.logger,
             authStore: this.authStore,
-            signalStore: this.signalStore
+            signalStore: this.signalStore,
+            preKeyStore: this.preKeyStore
         }, credentials);
     }
     requireCredentials() {