zapo-js 0.1.2 → 0.3.0

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;
             }
@@ -168,7 +191,12 @@ class WaAppStateSyncClient {
         }
     }
     async syncCollectionsRound(collections, pendingByCollection, options) {
-        const requests = await Promise.all(collections.map((collection) => this.buildCollectionSyncRequest(collection, pendingByCollection)));
+        const activeSyncKey = await this.store.getActiveSyncKey();
+        const requestPromises = new Array(collections.length);
+        for (let index = 0; index < collections.length; index += 1) {
+            requestPromises[index] = this.buildCollectionSyncRequest(collections[index], pendingByCollection, activeSyncKey);
+        }
+        const requests = await Promise.all(requestPromises);
         const collectionNodes = new Array(requests.length);
         const outgoingContexts = new Map();
         const skippedUploadCollections = new Set();
@@ -184,21 +212,26 @@ class WaAppStateSyncClient {
         }
         const iqNode = this.buildSyncIqNode(collectionNodes);
         const payloadByCollection = await this.fetchSyncPayloadByCollection(iqNode, options.timeoutMs ?? this.defaultTimeoutMs);
-        const collectionOutcomes = await Promise.all(collections.map((collection) => this.processCollectionRound({
-            collection,
-            payloadByCollection,
-            pendingByCollection,
-            options,
-            outgoingContexts,
-            skippedUploadCollections
-        })));
+        const collectionOutcomePromises = new Array(collections.length);
+        for (let index = 0; index < collections.length; index += 1) {
+            collectionOutcomePromises[index] = this.processCollectionRound({
+                collection: collections[index],
+                payloadByCollection,
+                pendingByCollection,
+                options,
+                outgoingContexts,
+                skippedUploadCollections
+            });
+        }
+        const collectionOutcomes = await Promise.all(collectionOutcomePromises);
         const results = [];
         const collectionsToRefetch = [];
         const blockedCollections = [];
         const missingKeyIds = [];
         const missingKeyIdHexes = new Set();
         let stateChanged = false;
-        for (const entry of collectionOutcomes) {
+        for (let index = 0; index < collectionOutcomes.length; index += 1) {
+            const entry = collectionOutcomes[index];
             results.push(entry.result);
             if (entry.shouldRefetch) {
                 collectionsToRefetch.push(entry.collection);
@@ -210,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);
@@ -225,7 +258,7 @@ class WaAppStateSyncClient {
             blockedCollections
         };
     }
-    async buildCollectionSyncRequest(collection, pendingByCollection) {
+    async buildCollectionSyncRequest(collection, pendingByCollection, activeSyncKey) {
         const collectionState = await this.getCollectionState(collection);
         const hasPersistedState = collectionState.initialized;
         const attrs = {
@@ -246,7 +279,7 @@ class WaAppStateSyncClient {
                 });
             }
             else {
-                const outgoing = await this.buildOutgoingPatch(collection, collectionState, pendingMutations);
+                const outgoing = await this.buildOutgoingPatch(collection, collectionState, pendingMutations, activeSyncKey);
                 outgoingContext = outgoing.context;
                 children.push({
                     tag: constants_2.WA_NODE_TAGS.PATCH,
@@ -277,7 +310,7 @@ class WaAppStateSyncClient {
             content: [
                 {
                     tag: constants_2.WA_NODE_TAGS.SYNC,
-                    attrs: {},
+                    attrs: this.mobilePrimary ? { data_namespace: '3' } : {},
                     content: collectionNodes
                 }
             ]
@@ -290,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) {
@@ -332,14 +365,14 @@ class WaAppStateSyncClient {
                 const snapshotBytes = await downloader(payload.collection, 'snapshot', payload.snapshotReference);
                 const snapshot = this.validateSnapshot(payload.collection, _proto_1.proto.SyncdSnapshot.decode(snapshotBytes));
                 const snapshotMutations = await this.applySnapshot(payload.collection, snapshot);
-                appliedMutations = appliedMutations.concat(snapshotMutations);
+                appliedMutations.push(...snapshotMutations);
                 collectionStateChanged = true;
             }
             if (payload.patches.length > 0) {
                 const readyPatches = await this.resolveReadyPatches(payload, options);
                 for (const readyPatch of readyPatches) {
                     const patchMutations = await this.applyPatch(payload.collection, readyPatch);
-                    appliedMutations = appliedMutations.concat(patchMutations);
+                    appliedMutations.push(...patchMutations);
                     collectionStateChanged = true;
                 }
             }
@@ -407,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(','),
@@ -428,13 +461,12 @@ class WaAppStateSyncClient {
         }
     }
     async resolveReadyPatches(payload, options) {
-        const sortedPatches = payload.patches
-            .map((patch) => ({
-            patch,
-            sortVersion: this.parseCollectionPatchVersion(payload.collection, patch)
-        }))
-            .sort((left, right) => left.sortVersion - right.sortVersion)
-            .map((entry) => entry.patch);
+        const sortedPatches = payload.patches.slice();
+        const sortVersions = new Map();
+        for (const patch of sortedPatches) {
+            sortVersions.set(patch, this.parseCollectionPatchVersion(payload.collection, patch));
+        }
+        sortedPatches.sort((left, right) => sortVersions.get(left) - sortVersions.get(right));
         return Promise.all(sortedPatches.map(async (patch) => {
             let readyPatch = patch;
             if ((!readyPatch.mutations || readyPatch.mutations.length === 0) &&
@@ -457,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;
     }
@@ -476,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`);
@@ -497,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,
@@ -521,10 +560,18 @@ class WaAppStateSyncClient {
                 timestamp: this.normalizeProtoLong(decrypted.value?.timestamp, `snapshot.record.value.timestamp (${collection})`)
             });
         }
-        const ltHash = await this.crypto.ltHashAdd(constants_1.APP_STATE_EMPTY_LT_HASH, Array.from(indexValueMap.values()));
-        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}`);
+        const ltHashInput = new Array(indexValueMap.size);
+        let ltHashInputIndex = 0;
+        for (const valueMac of indexValueMap.values()) {
+            ltHashInput[ltHashInputIndex] = valueMac;
+            ltHashInputIndex += 1;
+        }
+        const ltHash = await this.crypto.ltHashAdd(constants_1.APP_STATE_EMPTY_LT_HASH, ltHashInput);
+        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;
@@ -535,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);
@@ -553,37 +603,56 @@ 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.slice();
+        return decryptedMutations;
     }
     async decryptSnapshotRecords(collection, snapshot) {
-        const records = (snapshot.records ?? []).map((record) => ({
-            indexMac: (0, bytes_1.decodeProtoBytes)(record.index?.blob, `snapshot.record.index.blob (${collection})`),
-            valueBlob: (0, bytes_1.decodeProtoBytes)(record.value?.blob, `snapshot.record.value.blob (${collection})`),
-            recordKeyId: (0, bytes_1.decodeProtoBytes)(record.keyId?.id, `snapshot.record.keyId.id (${collection})`)
-        }));
-        await this.preloadKeyData(records.map((record) => record.recordKeyId));
-        return Promise.all(records.map(async ({ indexMac, valueBlob, recordKeyId }) => {
-            const recordKeyData = await this.getKeyData(recordKeyId);
-            if (!recordKeyData) {
-                throw new WaAppStateMissingKeyError(`missing snapshot mutation key ${(0, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
-            }
-            const decrypted = await this.crypto.decryptMutation({
-                operation: _proto_1.proto.SyncdMutation.SyncdOperation.SET,
-                keyId: recordKeyId,
-                keyData: recordKeyData,
-                indexMac,
-                valueBlob
-            });
-            return {
-                decrypted,
+        const rawRecords = snapshot.records ?? [];
+        const records = new Array(rawRecords.length);
+        const recordKeyIds = new Array(rawRecords.length);
+        for (let i = 0; i < rawRecords.length; i += 1) {
+            const record = rawRecords[i];
+            const recordKeyId = (0, bytes_1.decodeProtoBytes)(record.keyId?.id, `snapshot.record.keyId.id (${collection})`);
+            records[i] = {
+                indexMac: (0, bytes_1.decodeProtoBytes)(record.index?.blob, `snapshot.record.index.blob (${collection})`),
+                valueBlob: (0, bytes_1.decodeProtoBytes)(record.value?.blob, `snapshot.record.value.blob (${collection})`),
                 recordKeyId
             };
-        }));
+            recordKeyIds[i] = recordKeyId;
+        }
+        await this.preloadKeyData(recordKeyIds);
+        const decryptTasks = new Array(records.length);
+        for (let i = 0; i < records.length; i += 1) {
+            const { indexMac, valueBlob, recordKeyId } = records[i];
+            decryptTasks[i] = (async () => {
+                const recordKeyData = await this.getKeyData(recordKeyId);
+                if (!recordKeyData) {
+                    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,
+                    keyId: recordKeyId,
+                    keyData: recordKeyData,
+                    indexMac,
+                    valueBlob
+                });
+                return {
+                    decrypted,
+                    recordKeyId
+                };
+            })();
+        }
+        return Promise.all(decryptTasks);
     }
     async decryptPatchMutations(collection, patch) {
-        const parsedMutations = (patch.mutations ?? []).map((mutation) => {
+        const rawMutations = patch.mutations ?? [];
+        const parsedMutations = new Array(rawMutations.length);
+        const mutationKeyIds = new Array(rawMutations.length);
+        for (let i = 0; i < rawMutations.length; i += 1) {
+            const mutation = rawMutations[i];
             const operationCode = mutation.operation;
             if (operationCode === null || operationCode === undefined) {
                 throw new Error(`patch mutation is missing operation (${collection})`);
@@ -592,57 +661,63 @@ class WaAppStateSyncClient {
             if (!record) {
                 throw new Error(`patch mutation is missing record (${collection})`);
             }
-            return {
+            const recordKeyId = (0, bytes_1.decodeProtoBytes)(record.keyId?.id, `patch.record.keyId.id (${collection})`);
+            parsedMutations[i] = {
                 operationCode,
                 indexMac: (0, bytes_1.decodeProtoBytes)(record.index?.blob, `patch.record.index.blob (${collection})`),
                 valueBlob: (0, bytes_1.decodeProtoBytes)(record.value?.blob, `patch.record.value.blob (${collection})`),
-                recordKeyId: (0, bytes_1.decodeProtoBytes)(record.keyId?.id, `patch.record.keyId.id (${collection})`)
-            };
-        });
-        await this.preloadKeyData(parsedMutations.map((mutation) => mutation.recordKeyId));
-        return Promise.all(parsedMutations.map(async ({ operationCode, indexMac, valueBlob, recordKeyId }) => {
-            const recordKeyData = await this.getKeyData(recordKeyId);
-            if (!recordKeyData) {
-                throw new WaAppStateMissingKeyError(`missing mutation key ${(0, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
-            }
-            const decrypted = await this.crypto.decryptMutation({
-                operation: operationCode,
-                keyId: recordKeyId,
-                keyData: recordKeyData,
-                indexMac,
-                valueBlob
-            });
-            return {
-                collection,
-                operation: operationCode === _proto_1.proto.SyncdMutation.SyncdOperation.REMOVE
-                    ? 'remove'
-                    : 'set',
-                source: 'patch',
-                operationCode,
-                index: decrypted.index,
-                value: decrypted.value,
-                version: decrypted.version,
-                indexMac: decrypted.indexMac,
-                valueMac: decrypted.valueMac,
-                keyId: recordKeyId,
-                timestamp: this.normalizeProtoLong(decrypted.value?.timestamp, `patch.record.value.timestamp (${collection})`)
+                recordKeyId
             };
-        }));
+            mutationKeyIds[i] = recordKeyId;
+        }
+        await this.preloadKeyData(mutationKeyIds);
+        const decryptTasks = new Array(parsedMutations.length);
+        for (let i = 0; i < parsedMutations.length; i += 1) {
+            const { operationCode, indexMac, valueBlob, recordKeyId } = parsedMutations[i];
+            decryptTasks[i] = (async () => {
+                const recordKeyData = await this.getKeyData(recordKeyId);
+                if (!recordKeyData) {
+                    throw new WaAppStateMissingKeyError(`missing mutation key ${(0, bytes_1.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                }
+                const decrypted = await this.crypto.decryptMutation({
+                    operation: operationCode,
+                    keyId: recordKeyId,
+                    keyData: recordKeyData,
+                    indexMac,
+                    valueBlob
+                });
+                return {
+                    collection,
+                    operation: operationCode === _proto_1.proto.SyncdMutation.SyncdOperation.REMOVE
+                        ? 'remove'
+                        : 'set',
+                    source: 'patch',
+                    operationCode,
+                    index: decrypted.index,
+                    value: decrypted.value,
+                    version: decrypted.version,
+                    indexMac: decrypted.indexMac,
+                    valueMac: decrypted.valueMac,
+                    keyId: recordKeyId,
+                    timestamp: this.normalizeProtoLong(decrypted.value?.timestamp, `patch.record.value.timestamp (${collection})`)
+                };
+            })();
+        }
+        return Promise.all(decryptTasks);
     }
     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}`);
         }
     }
-    async buildOutgoingPatch(collection, snapshot, pendingMutations) {
-        const activeKey = await this.store.getActiveSyncKey();
+    async buildOutgoingPatch(collection, snapshot, pendingMutations, activeKey) {
         if (!activeKey) {
             throw new WaAppStateMissingKeyError(`no sync key available to upload ${collection}`, null, collection);
         }
@@ -661,23 +736,30 @@ class WaAppStateSyncClient {
             });
             return { operationCode, encrypted };
         }));
-        const encryptedMutations = encryptedResults.map(({ operationCode, encrypted }) => ({
-            operation: operationCode,
-            record: {
-                keyId: { id: activeKey.keyId },
-                index: { blob: encrypted.indexMac },
-                value: { blob: encrypted.valueBlob }
-            }
-        }));
-        const macMutations = encryptedResults.map(({ operationCode, encrypted }) => ({
-            operation: operationCode,
-            indexMac: encrypted.indexMac,
-            valueMac: encrypted.valueMac
-        }));
+        const encryptedMutations = new Array(encryptedResults.length);
+        const macMutations = new Array(encryptedResults.length);
+        const valueMacs = new Array(encryptedResults.length);
+        for (let i = 0; i < encryptedResults.length; i += 1) {
+            const { operationCode, encrypted } = encryptedResults[i];
+            encryptedMutations[i] = {
+                operation: operationCode,
+                record: {
+                    keyId: { id: activeKey.keyId },
+                    index: { blob: encrypted.indexMac },
+                    value: { blob: encrypted.valueBlob }
+                }
+            };
+            macMutations[i] = {
+                operation: operationCode,
+                indexMac: encrypted.indexMac,
+                valueMac: encrypted.valueMac
+            };
+            valueMacs[i] = encrypted.valueMac;
+        }
         const nextState = await this.computeNextCollectionState(snapshot.hash, snapshot.indexValueMap, macMutations, collection);
         const patchVersion = snapshot.version + 1;
         const snapshotMac = await this.crypto.generateSnapshotMac(activeKey.keyData, nextState.hash, patchVersion, collection);
-        const patchMac = await this.crypto.generatePatchMac(activeKey.keyData, snapshotMac, macMutations.map((item) => item.valueMac), patchVersion, collection);
+        const patchMac = await this.crypto.generatePatchMac(activeKey.keyData, snapshotMac, valueMacs, patchVersion, collection);
         const deviceIndex = this.resolveDeviceIndex();
         const clientDebugData = this.buildPatchClientDebugData();
         const encodedPatch = _proto_1.proto.SyncdPatch.encode({
@@ -726,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) {
@@ -800,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;
             }
@@ -812,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/{store/sqlite.js → encoding.js}

@@ -4,8 +4,8 @@ exports.encodeAppStateFingerprint = encodeAppStateFingerprint;
 exports.decodeAppStateFingerprint = decodeAppStateFingerprint;
 exports.decodeAppStateSyncKeys = decodeAppStateSyncKeys;
 exports.decodeAppStateCollections = decodeAppStateCollections;
-const _proto_1 = require("../../proto.js");
-const coercion_1 = require("../../util/coercion");
+const _proto_1 = require("../proto.js");
+const coercion_1 = require("../util/coercion");
 function encodeAppStateFingerprint(fingerprint) {
     if (!fingerprint) {
         return null;
@@ -26,12 +26,17 @@ function decodeAppStateFingerprint(raw) {
     }
 }
 function decodeAppStateSyncKeys(rows) {
-    return rows.map((row) => ({
-        keyId: (0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id'),
-        keyData: (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'),
-        timestamp: (0, coercion_1.asNumber)(row.timestamp, 'appstate_sync_keys.timestamp'),
-        fingerprint: decodeAppStateFingerprint(row.fingerprint)
-    }));
+    const decoded = new Array(rows.length);
+    for (let i = 0; i < rows.length; i += 1) {
+        const row = rows[i];
+        decoded[i] = {
+            keyId: (0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id'),
+            keyData: (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'),
+            timestamp: (0, coercion_1.asNumber)(row.timestamp, 'appstate_sync_keys.timestamp'),
+            fingerprint: decodeAppStateFingerprint(row.fingerprint)
+        };
+    }
+    return decoded;
 }
 function decodeAppStateCollections(versionRows, valueRows) {
     const valueMapByCollection = new Map();

package/dist/appstate/index.js

@@ -14,15 +14,17 @@ 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.WaAppStateSyncClient = exports.parseSyncResponse = exports.parseCollectionState = exports.WaAppStateMissingKeyError = exports.WaAppStateCrypto = void 0;
+exports.WaAppStateSyncClient = exports.parseSyncResponse = exports.WaAppStateCrypto = exports.decodeAppStateSyncKeys = exports.decodeAppStateCollections = exports.decodeAppStateFingerprint = exports.encodeAppStateFingerprint = void 0;
 __exportStar(require("./constants"), exports);
+var encoding_1 = require("./encoding");
+Object.defineProperty(exports, "encodeAppStateFingerprint", { enumerable: true, get: function () { return encoding_1.encodeAppStateFingerprint; } });
+Object.defineProperty(exports, "decodeAppStateFingerprint", { enumerable: true, get: function () { return encoding_1.decodeAppStateFingerprint; } });
+Object.defineProperty(exports, "decodeAppStateCollections", { enumerable: true, get: function () { return encoding_1.decodeAppStateCollections; } });
+Object.defineProperty(exports, "decodeAppStateSyncKeys", { enumerable: true, get: function () { return encoding_1.decodeAppStateSyncKeys; } });
 __exportStar(require("./utils"), exports);
 var WaAppStateCrypto_1 = require("./WaAppStateCrypto");
 Object.defineProperty(exports, "WaAppStateCrypto", { enumerable: true, get: function () { return WaAppStateCrypto_1.WaAppStateCrypto; } });
+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, "WaAppStateMissingKeyError", { enumerable: true, get: function () { return WaAppStateSyncClient_1.WaAppStateMissingKeyError; } });
-var WaAppStateSyncResponseParser_1 = require("./WaAppStateSyncResponseParser");
-Object.defineProperty(exports, "parseCollectionState", { enumerable: true, get: function () { return WaAppStateSyncResponseParser_1.parseCollectionState; } });
-Object.defineProperty(exports, "parseSyncResponse", { enumerable: true, get: function () { return WaAppStateSyncResponseParser_1.parseSyncResponse; } });
-var WaAppStateSyncClient_2 = require("./WaAppStateSyncClient");
-Object.defineProperty(exports, "WaAppStateSyncClient", { enumerable: true, get: function () { return WaAppStateSyncClient_2.WaAppStateSyncClient; } });
+Object.defineProperty(exports, "WaAppStateSyncClient", { enumerable: true, get: function () { return WaAppStateSyncClient_1.WaAppStateSyncClient; } });

package/dist/appstate/utils.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCollectionName = parseCollectionName;
-exports.keyDeviceId = keyDeviceId;
 exports.keyEpoch = keyEpoch;
 exports.pickActiveSyncKey = pickActiveSyncKey;
-exports.toNetworkOrder64 = toNetworkOrder64;
 exports.downloadExternalBlobReference = downloadExternalBlobReference;
 const constants_1 = require("../protocol/constants");
 const bytes_1 = require("../util/bytes");
@@ -44,9 +42,6 @@ function pickActiveSyncKey(keys) {
     }
     return active;
 }
-function toNetworkOrder64(value) {
-    return (0, bytes_1.intToBytes)(8, value);
-}
 async function downloadExternalBlobReference(mediaTransfer, reference) {
     if (!reference.directPath) {
         throw new Error('external blob reference is missing directPath');