zapo-js 0.1.1 → 0.2.0

package/dist/appstate/WaAppStateSyncClient.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaAppStateSyncClient = exports.WaAppStateMissingKeyError = void 0;
 const constants_1 = require("./constants");
-const utils_1 = require("./utils");
 const WaAppStateCrypto_1 = require("./WaAppStateCrypto");
 const WaAppStateSyncResponseParser_1 = require("./WaAppStateSyncResponseParser");
 const _proto_1 = require("../proto.js");
 const constants_2 = require("../protocol/constants");
-const base64_1 = require("../util/base64");
+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) {
@@ -24,6 +25,7 @@ class WaAppStateSyncClient {
         this.logger = options.logger;
         this.query = options.query;
         this.store = options.store;
+        this.getCurrentMeJid = options.getCurrentMeJid;
         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;
@@ -47,14 +49,14 @@ class WaAppStateSyncClient {
     async importSyncKeyShare(share) {
         const keys = [];
         for (const item of share.keys ?? []) {
-            const keyId = (0, base64_1.decodeProtoBytes)(item.keyId?.keyId, 'appStateSyncKeyShare.keys[].keyId.keyId');
+            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, utils_1.keyIdToHex)(keyId)
+                    keyId: (0, bytes_2.bytesToHex)(keyId)
                 });
                 continue;
             }
-            const keyData = (0, base64_1.decodeProtoBytes)(item.keyData?.keyData, 'appStateSyncKeyShare.keys[].keyData.keyData');
+            const keyData = (0, bytes_1.decodeProtoBytes)(item.keyData?.keyData, 'appStateSyncKeyShare.keys[].keyData.keyData');
             keys.push({
                 keyId,
                 keyData,
@@ -93,6 +95,10 @@ class WaAppStateSyncClient {
             ...new Set(options.collections ?? constants_1.APP_STATE_DEFAULT_COLLECTIONS)
         ];
         try {
+            const initialCollectionStates = await this.store.getCollectionStates(collections);
+            for (let index = 0; index < collections.length; index += 1) {
+                context.collections.set(collections[index], initialCollectionStates[index]);
+            }
             this.logger.info('app-state sync start', {
                 collections: collections.length,
                 pendingMutations: options.pendingMutations?.length ?? 0
@@ -162,36 +168,18 @@ class WaAppStateSyncClient {
         }
     }
     async syncCollectionsRound(collections, pendingByCollection, options) {
-        const prepared = await this.prepareSyncRoundRequest(collections, pendingByCollection);
-        const iqNode = this.buildSyncIqNode(prepared.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: prepared.outgoingContexts,
-            skippedUploadCollections: prepared.skippedUploadCollections
-        })));
-        return {
-            results: collectionOutcomes.map((entry) => entry.result),
-            collectionsToRefetch: collectionOutcomes
-                .filter((entry) => entry.shouldRefetch)
-                .map((entry) => entry.collection),
-            stateChanged: collectionOutcomes.some((entry) => entry.stateChanged),
-            missingKeyIds: this.collectDistinctMissingKeyIds(collectionOutcomes
-                .map((entry) => entry.missingKeyId)
-                .filter((value) => value !== null)),
-            blockedCollections: collectionOutcomes
-                .filter((entry) => entry.result.state === constants_2.WA_APP_STATE_COLLECTION_STATES.BLOCKED)
-                .map((entry) => entry.collection)
-        };
-    }
-    async prepareSyncRoundRequest(collections, pendingByCollection) {
-        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();
-        for (const request of requests) {
+        for (let index = 0; index < requests.length; index += 1) {
+            const request = requests[index];
+            collectionNodes[index] = request.node;
             if (request.outgoingContext) {
                 outgoingContexts.set(request.collection, request.outgoingContext);
             }
@@ -199,26 +187,62 @@ class WaAppStateSyncClient {
                 skippedUploadCollections.add(request.collection);
             }
         }
+        const iqNode = this.buildSyncIqNode(collectionNodes);
+        const payloadByCollection = await this.fetchSyncPayloadByCollection(iqNode, options.timeoutMs ?? this.defaultTimeoutMs);
+        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 (let index = 0; index < collectionOutcomes.length; index += 1) {
+            const entry = collectionOutcomes[index];
+            results.push(entry.result);
+            if (entry.shouldRefetch) {
+                collectionsToRefetch.push(entry.collection);
+            }
+            if (entry.stateChanged) {
+                stateChanged = true;
+            }
+            if (entry.result.state === constants_2.WA_APP_STATE_COLLECTION_STATES.BLOCKED) {
+                blockedCollections.push(entry.collection);
+            }
+            if (entry.missingKeyId) {
+                const keyHex = (0, bytes_2.bytesToHex)(entry.missingKeyId);
+                if (!missingKeyIdHexes.has(keyHex)) {
+                    missingKeyIdHexes.add(keyHex);
+                    missingKeyIds.push(entry.missingKeyId);
+                }
+            }
+        }
         return {
-            collectionNodes: requests.map((request) => request.node),
-            outgoingContexts,
-            skippedUploadCollections
+            results,
+            collectionsToRefetch,
+            stateChanged,
+            missingKeyIds,
+            blockedCollections
         };
     }
-    async buildCollectionSyncRequest(collection, pendingByCollection) {
+    async buildCollectionSyncRequest(collection, pendingByCollection, activeSyncKey) {
         const collectionState = await this.getCollectionState(collection);
-        const hasPersistedState = collectionState.version > 0 ||
-            collectionState.indexValueMap.size > 0 ||
-            !(0, bytes_1.uint8Equal)(collectionState.hash, constants_1.APP_STATE_EMPTY_LT_HASH);
+        const hasPersistedState = collectionState.initialized;
         const attrs = {
-            name: collection
+            name: collection,
+            version: String(hasPersistedState ? collectionState.version : constants_1.APP_STATE_DEFAULT_COLLECTION_VERSION),
+            return_snapshot: hasPersistedState ? 'false' : 'true'
         };
-        if (hasPersistedState) {
-            attrs.version = String(collectionState.version);
-        }
-        else {
-            attrs.return_snapshot = 'true';
-        }
         const children = [];
         const pendingMutations = pendingByCollection.get(collection) ?? [];
         let outgoingContext;
@@ -232,7 +256,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,
@@ -275,6 +299,7 @@ class WaAppStateSyncClient {
             tag: responseNode.tag,
             type: responseNode.attrs.type
         });
+        (0, query_1.assertIqResult)(responseNode, 'app-state sync');
         const payloads = (0, WaAppStateSyncResponseParser_1.parseSyncResponse)(responseNode);
         this.logger.debug('app-state sync payloads parsed', { count: payloads.length });
         const payloadByCollection = new Map();
@@ -296,20 +321,16 @@ class WaAppStateSyncClient {
             return this.createCollectionOutcome(collection, payload.state, payload.version);
         }
         const pendingMutationsCount = pendingByCollection.get(collection)?.length ?? 0;
-        if (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE) {
-            shouldRefetch = true;
-        }
-        else if (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT &&
-            pendingMutationsCount > 0) {
-            shouldRefetch = true;
-        }
-        if (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT) {
-            return this.createCollectionOutcome(collection, pendingMutationsCount > 0
-                ? constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT
-                : constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS, payload.version, shouldRefetch);
-        }
-        if (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE) {
-            return this.createCollectionOutcome(collection, payload.state, payload.version, shouldRefetch);
+        if (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT ||
+            payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE) {
+            shouldRefetch =
+                payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE ||
+                    pendingMutationsCount > 0;
+            return this.createCollectionOutcome(collection, payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT
+                ? pendingMutationsCount > 0
+                    ? constants_2.WA_APP_STATE_COLLECTION_STATES.CONFLICT
+                    : constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS
+                : payload.state, payload.version, shouldRefetch);
         }
         try {
             let appliedMutations = [];
@@ -321,14 +342,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;
                 }
             }
@@ -341,13 +362,17 @@ class WaAppStateSyncClient {
                     collectionStateChanged = true;
                 }
             }
-            if (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE) {
-                shouldRefetch = true;
-            }
-            if (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS &&
-                skippedUploadCollections.has(collection)) {
-                shouldRefetch = true;
+            const currentCollectionState = await this.getCollectionState(collection);
+            if (!currentCollectionState.initialized &&
+                payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS) {
+                this.setCollectionState(collection, payload.version ?? currentCollectionState.version, currentCollectionState.hash, currentCollectionState.indexValueMap);
+                collectionStateChanged = true;
             }
+            shouldRefetch =
+                shouldRefetch ||
+                    payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE ||
+                    (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS &&
+                        skippedUploadCollections.has(collection));
             this.logger.debug('app-state collection processed', {
                 collection: payload.collection,
                 state: payload.state,
@@ -386,24 +411,13 @@ class WaAppStateSyncClient {
             }
         };
     }
-    collectDistinctMissingKeyIds(keyIds) {
-        const byHex = new Map();
-        for (const keyId of keyIds) {
-            const keyHex = (0, utils_1.keyIdToHex)(keyId);
-            if (byHex.has(keyHex)) {
-                continue;
-            }
-            byHex.set(keyHex, keyId);
-        }
-        return [...byHex.values()];
-    }
     async notifyMissingKeys(input) {
-        const keyIds = this.collectDistinctMissingKeyIds(input.keyIds);
-        const collections = [...new Set(input.collections)];
+        const keyIds = input.keyIds;
+        const collections = input.collections;
         if (keyIds.length === 0 || collections.length === 0) {
             return;
         }
-        const keyIdsHex = keyIds.map((keyId) => (0, utils_1.keyIdToHex)(keyId));
+        const keyIdsHex = keyIds.map((keyId) => (0, bytes_2.bytesToHex)(keyId));
         this.logger.info('app-state requesting missing sync keys', {
             keys: keyIdsHex.length,
             keyIds: keyIdsHex.join(','),
@@ -424,13 +438,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) &&
@@ -493,16 +506,16 @@ class WaAppStateSyncClient {
     }
     async applySnapshot(collection, snapshot) {
         const version = this.normalizeProtoLong(snapshot.version?.version, `snapshot.version.version (${collection})`);
-        const keyId = (0, base64_1.decodeProtoBytes)(snapshot.keyId?.id, `snapshot.keyId.id (${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, utils_1.keyIdToHex)(keyId)} for ${collection}`, keyId, collection);
+            throw new WaAppStateMissingKeyError(`missing snapshot key ${(0, bytes_2.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, utils_1.keyIdToHex)(decrypted.indexMac);
+            const indexMacHex = (0, bytes_2.bytesToHex)(decrypted.indexMac);
             indexValueMap.set(indexMacHex, decrypted.valueMac);
             mutations.push({
                 collection,
@@ -517,9 +530,15 @@ 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 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);
         const expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
-        if (!(0, bytes_1.uint8Equal)(expectedSnapshotMac, snapshot.mac)) {
+        if (!(0, bytes_2.uint8Equal)(expectedSnapshotMac, snapshot.mac)) {
             throw new Error(`snapshot MAC mismatch for ${collection}`);
         }
         this.setCollectionState(collection, version, ltHash, indexValueMap);
@@ -531,48 +550,72 @@ class WaAppStateSyncClient {
         if (current.version !== patchVersion - 1) {
             throw new Error(`patch version mismatch for ${collection}: local=${current.version}, incoming=${patchVersion}`);
         }
-        const patchKeyId = (0, base64_1.decodeProtoBytes)(patch.keyId?.id, `patch.keyId.id (${collection})`);
+        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, utils_1.keyIdToHex)(patchKeyId)} for ${collection}`, patchKeyId, collection);
+            throw new WaAppStateMissingKeyError(`missing patch key ${(0, bytes_2.bytesToHex)(patchKeyId)} for ${collection}`, patchKeyId, collection);
         }
         const decryptedMutations = await this.decryptPatchMutations(collection, patch);
-        const nextState = await this.computeNextCollectionState(current.hash, current.indexValueMap, decryptedMutations.map((mutation) => ({
-            operation: mutation.operationCode,
-            indexMac: mutation.indexMac,
-            valueMac: mutation.valueMac
-        })), collection);
-        await this.assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextState.hash, decryptedMutations);
+        const macMutations = new Array(decryptedMutations.length);
+        const valueMacs = new Array(decryptedMutations.length);
+        for (let index = 0; index < decryptedMutations.length; index += 1) {
+            const mutation = decryptedMutations[index];
+            valueMacs[index] = mutation.valueMac;
+            macMutations[index] = {
+                operation: mutation.operationCode,
+                indexMac: mutation.indexMac,
+                valueMac: mutation.valueMac
+            };
+        }
+        const nextState = await this.computeNextCollectionState(current.hash, current.indexValueMap, macMutations, collection);
+        await this.assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextState.hash, valueMacs);
         this.setCollectionState(collection, patchVersion, nextState.hash, nextState.indexValueMap);
-        return decryptedMutations.map(({ operationCode, ...mutation }) => {
-            void operationCode;
-            return mutation;
-        });
+        return decryptedMutations;
     }
     async decryptSnapshotRecords(collection, snapshot) {
-        return Promise.all((snapshot.records ?? []).map(async (record) => {
-            const indexMac = (0, base64_1.decodeProtoBytes)(record.index?.blob, `snapshot.record.index.blob (${collection})`);
-            const valueBlob = (0, base64_1.decodeProtoBytes)(record.value?.blob, `snapshot.record.value.blob (${collection})`);
-            const recordKeyId = (0, base64_1.decodeProtoBytes)(record.keyId?.id, `snapshot.record.keyId.id (${collection})`);
-            const recordKeyData = await this.getKeyData(recordKeyId);
-            if (!recordKeyData) {
-                throw new WaAppStateMissingKeyError(`missing snapshot mutation key ${(0, utils_1.keyIdToHex)(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_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,
+                    recordKeyId
+                };
+            })();
+        }
+        return Promise.all(decryptTasks);
     }
     async decryptPatchMutations(collection, patch) {
-        return Promise.all((patch.mutations ?? []).map(async (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})`);
@@ -581,51 +624,63 @@ class WaAppStateSyncClient {
             if (!record) {
                 throw new Error(`patch mutation is missing record (${collection})`);
             }
-            const indexMac = (0, base64_1.decodeProtoBytes)(record.index?.blob, `patch.record.index.blob (${collection})`);
-            const valueBlob = (0, base64_1.decodeProtoBytes)(record.value?.blob, `patch.record.value.blob (${collection})`);
-            const recordKeyId = (0, base64_1.decodeProtoBytes)(record.keyId?.id, `patch.record.keyId.id (${collection})`);
-            const recordKeyData = await this.getKeyData(recordKeyId);
-            if (!recordKeyData) {
-                throw new WaAppStateMissingKeyError(`missing mutation key ${(0, utils_1.keyIdToHex)(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',
+            const recordKeyId = (0, bytes_1.decodeProtoBytes)(record.keyId?.id, `patch.record.keyId.id (${collection})`);
+            parsedMutations[i] = {
                 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})`)
+                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
             };
-        }));
+            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_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})`)
+                };
+            })();
+        }
+        return Promise.all(decryptTasks);
     }
-    async assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextHash, decryptedMutations) {
-        const snapshotMac = (0, base64_1.decodeProtoBytes)(patch.snapshotMac, `patch.snapshotMac (${collection})`);
+    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_1.uint8Equal)(expectedSnapshotMac, snapshotMac)) {
+        if (!(0, bytes_2.uint8Equal)(expectedSnapshotMac, snapshotMac)) {
             throw new Error(`patch snapshot MAC mismatch for ${collection}`);
         }
-        const patchMac = (0, base64_1.decodeProtoBytes)(patch.patchMac, `patch.patchMac (${collection})`);
-        const expectedPatchMac = await this.crypto.generatePatchMac(patchKeyData, snapshotMac, decryptedMutations.map((mutation) => mutation.valueMac), patchVersion, collection);
-        if (!(0, bytes_1.uint8Equal)(expectedPatchMac, patchMac)) {
+        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)) {
             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);
         }
@@ -644,29 +699,39 @@ 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({
-            version: { version: patchVersion },
             mutations: encryptedMutations,
             snapshotMac,
             patchMac,
-            keyId: { id: activeKey.keyId }
+            keyId: { id: activeKey.keyId },
+            ...(deviceIndex === undefined ? {} : { deviceIndex }),
+            clientDebugData
         }).finish();
         return {
             encodedPatch,
@@ -678,13 +743,35 @@ class WaAppStateSyncClient {
             }
         };
     }
+    resolveDeviceIndex() {
+        const meJid = this.getCurrentMeJid?.();
+        if (!meJid) {
+            return undefined;
+        }
+        try {
+            return (0, jid_1.parseSignalAddressFromJid)(meJid).device;
+        }
+        catch (error) {
+            this.logger.debug('app-state could not parse device index from me jid', {
+                meJid
+            });
+            void error;
+            return undefined;
+        }
+    }
+    buildPatchClientDebugData() {
+        return _proto_1.proto.PatchDebugData.encode({
+            isSenderPrimary: false,
+            senderPlatform: _proto_1.proto.PatchDebugData.Platform.WEB
+        }).finish();
+    }
     async computeNextCollectionState(baseHash, baseMap, mutations, collection) {
         const indexValueMap = new Map(baseMap);
         const addValues = [];
         const removeValues = [];
         let missingRemoveCount = 0;
         for (const mutation of mutations) {
-            const indexMacHex = (0, utils_1.keyIdToHex)(mutation.indexMac);
+            const indexMacHex = (0, bytes_2.bytesToHex)(mutation.indexMac);
             const existing = indexValueMap.get(indexMacHex);
             if (mutation.operation === _proto_1.proto.SyncdMutation.SyncdOperation.REMOVE) {
                 if (!existing) {
@@ -749,9 +836,33 @@ class WaAppStateSyncClient {
         }
         return compacted;
     }
+    async preloadKeyData(keyIds) {
+        if (keyIds.length === 0) {
+            return;
+        }
+        const context = this.requireSyncContext();
+        const missingKeyIds = [];
+        const missingKeyHexes = new Set();
+        for (let index = 0; index < keyIds.length; index += 1) {
+            const keyId = keyIds[index];
+            const keyHex = (0, bytes_2.bytesToHex)(keyId);
+            if (context.keys.has(keyHex) || missingKeyHexes.has(keyHex)) {
+                continue;
+            }
+            missingKeyHexes.add(keyHex);
+            missingKeyIds.push(keyId);
+        }
+        if (missingKeyIds.length === 0) {
+            return;
+        }
+        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);
+        }
+    }
     async getKeyData(keyId) {
         const context = this.requireSyncContext();
-        const keyHex = (0, utils_1.keyIdToHex)(keyId);
+        const keyHex = (0, bytes_2.bytesToHex)(keyId);
         if (context.keys.has(keyHex)) {
             return context.keys.get(keyHex) ?? null;
         }
@@ -772,6 +883,7 @@ class WaAppStateSyncClient {
     setCollectionState(collection, version, hash, indexValueMap) {
         const context = this.requireSyncContext();
         context.collections.set(collection, {
+            initialized: true,
             version,
             hash,
             indexValueMap