zapo-js 0.1.1 → 0.2.0

package/dist/esm/appstate/WaAppStateSyncClient.js

@@ -1,11 +1,12 @@
-import { APP_STATE_DEFAULT_COLLECTIONS, APP_STATE_EMPTY_LT_HASH } from './constants.js';
-import { keyIdToHex } from './utils.js';
+import { APP_STATE_DEFAULT_COLLECTIONS, APP_STATE_DEFAULT_COLLECTION_VERSION, APP_STATE_EMPTY_LT_HASH } from './constants.js';
 import { WaAppStateCrypto } from './WaAppStateCrypto.js';
 import { parseSyncResponse } from './WaAppStateSyncResponseParser.js';
 import { proto } from '../proto.js';
 import { WA_APP_STATE_COLLECTION_STATES, WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../protocol/constants.js';
-import { decodeProtoBytes } from '../util/base64.js';
-import { uint8Equal } from '../util/bytes.js';
+import { parseSignalAddressFromJid } from '../protocol/jid.js';
+import { assertIqResult } from '../transport/node/query.js';
+import { decodeProtoBytes } from '../util/bytes.js';
+import { bytesToHex, uint8Equal } from '../util/bytes.js';
 import { longToNumber } from '../util/primitives.js';
 export class WaAppStateMissingKeyError extends Error {
     constructor(message, keyId, collection) {
@@ -20,6 +21,7 @@ export class WaAppStateSyncClient {
         this.logger = options.logger;
         this.query = options.query;
         this.store = options.store;
+        this.getCurrentMeJid = options.getCurrentMeJid;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? WA_DEFAULTS.APP_STATE_SYNC_TIMEOUT_MS;
         this.onMissingKeys = options.onMissingKeys;
@@ -46,7 +48,7 @@ export class WaAppStateSyncClient {
             const keyId = 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: keyIdToHex(keyId)
+                    keyId: bytesToHex(keyId)
                 });
                 continue;
             }
@@ -89,6 +91,10 @@ export class WaAppStateSyncClient {
             ...new Set(options.collections ?? 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
@@ -158,36 +164,18 @@ export 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 === 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);
             }
@@ -195,26 +183,62 @@ export 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 === WA_APP_STATE_COLLECTION_STATES.BLOCKED) {
+                blockedCollections.push(entry.collection);
+            }
+            if (entry.missingKeyId) {
+                const keyHex = 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 ||
-            !uint8Equal(collectionState.hash, APP_STATE_EMPTY_LT_HASH);
+        const hasPersistedState = collectionState.initialized;
         const attrs = {
-            name: collection
+            name: collection,
+            version: String(hasPersistedState ? collectionState.version : 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;
@@ -228,7 +252,7 @@ export 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: WA_NODE_TAGS.PATCH,
@@ -271,6 +295,7 @@ export class WaAppStateSyncClient {
             tag: responseNode.tag,
             type: responseNode.attrs.type
         });
+        assertIqResult(responseNode, 'app-state sync');
         const payloads = parseSyncResponse(responseNode);
         this.logger.debug('app-state sync payloads parsed', { count: payloads.length });
         const payloadByCollection = new Map();
@@ -292,20 +317,16 @@ export class WaAppStateSyncClient {
             return this.createCollectionOutcome(collection, payload.state, payload.version);
         }
         const pendingMutationsCount = pendingByCollection.get(collection)?.length ?? 0;
-        if (payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE) {
-            shouldRefetch = true;
-        }
-        else if (payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT &&
-            pendingMutationsCount > 0) {
-            shouldRefetch = true;
-        }
-        if (payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT) {
-            return this.createCollectionOutcome(collection, pendingMutationsCount > 0
-                ? WA_APP_STATE_COLLECTION_STATES.CONFLICT
-                : WA_APP_STATE_COLLECTION_STATES.SUCCESS, payload.version, shouldRefetch);
-        }
-        if (payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE) {
-            return this.createCollectionOutcome(collection, payload.state, payload.version, shouldRefetch);
+        if (payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT ||
+            payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE) {
+            shouldRefetch =
+                payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE ||
+                    pendingMutationsCount > 0;
+            return this.createCollectionOutcome(collection, payload.state === WA_APP_STATE_COLLECTION_STATES.CONFLICT
+                ? pendingMutationsCount > 0
+                    ? WA_APP_STATE_COLLECTION_STATES.CONFLICT
+                    : WA_APP_STATE_COLLECTION_STATES.SUCCESS
+                : payload.state, payload.version, shouldRefetch);
         }
         try {
             let appliedMutations = [];
@@ -317,14 +338,14 @@ export class WaAppStateSyncClient {
                 const snapshotBytes = await downloader(payload.collection, 'snapshot', payload.snapshotReference);
                 const snapshot = this.validateSnapshot(payload.collection, 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;
                 }
             }
@@ -337,13 +358,17 @@ export class WaAppStateSyncClient {
                     collectionStateChanged = true;
                 }
             }
-            if (payload.state === WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE) {
-                shouldRefetch = true;
-            }
-            if (payload.state === WA_APP_STATE_COLLECTION_STATES.SUCCESS &&
-                skippedUploadCollections.has(collection)) {
-                shouldRefetch = true;
+            const currentCollectionState = await this.getCollectionState(collection);
+            if (!currentCollectionState.initialized &&
+                payload.state === WA_APP_STATE_COLLECTION_STATES.SUCCESS) {
+                this.setCollectionState(collection, payload.version ?? currentCollectionState.version, currentCollectionState.hash, currentCollectionState.indexValueMap);
+                collectionStateChanged = true;
             }
+            shouldRefetch =
+                shouldRefetch ||
+                    payload.state === WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE ||
+                    (payload.state === WA_APP_STATE_COLLECTION_STATES.SUCCESS &&
+                        skippedUploadCollections.has(collection));
             this.logger.debug('app-state collection processed', {
                 collection: payload.collection,
                 state: payload.state,
@@ -382,24 +407,13 @@ export class WaAppStateSyncClient {
             }
         };
     }
-    collectDistinctMissingKeyIds(keyIds) {
-        const byHex = new Map();
-        for (const keyId of keyIds) {
-            const keyHex = 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) => keyIdToHex(keyId));
+        const keyIdsHex = keyIds.map((keyId) => bytesToHex(keyId));
         this.logger.info('app-state requesting missing sync keys', {
             keys: keyIdsHex.length,
             keyIds: keyIdsHex.join(','),
@@ -420,13 +434,12 @@ export 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) &&
@@ -492,13 +505,13 @@ export class WaAppStateSyncClient {
         const keyId = decodeProtoBytes(snapshot.keyId?.id, `snapshot.keyId.id (${collection})`);
         const keyData = await this.getKeyData(keyId);
         if (!keyData) {
-            throw new WaAppStateMissingKeyError(`missing snapshot key ${keyIdToHex(keyId)} for ${collection}`, keyId, collection);
+            throw new WaAppStateMissingKeyError(`missing snapshot key ${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 = keyIdToHex(decrypted.indexMac);
+            const indexMacHex = bytesToHex(decrypted.indexMac);
             indexValueMap.set(indexMacHex, decrypted.valueMac);
             mutations.push({
                 collection,
@@ -513,7 +526,13 @@ export class WaAppStateSyncClient {
                 timestamp: this.normalizeProtoLong(decrypted.value?.timestamp, `snapshot.record.value.timestamp (${collection})`)
             });
         }
-        const ltHash = await this.crypto.ltHashAdd(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(APP_STATE_EMPTY_LT_HASH, ltHashInput);
         const expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
         if (!uint8Equal(expectedSnapshotMac, snapshot.mac)) {
             throw new Error(`snapshot MAC mismatch for ${collection}`);
@@ -530,45 +549,69 @@ export class WaAppStateSyncClient {
         const patchKeyId = decodeProtoBytes(patch.keyId?.id, `patch.keyId.id (${collection})`);
         const patchKeyData = await this.getKeyData(patchKeyId);
         if (!patchKeyData) {
-            throw new WaAppStateMissingKeyError(`missing patch key ${keyIdToHex(patchKeyId)} for ${collection}`, patchKeyId, collection);
+            throw new WaAppStateMissingKeyError(`missing patch key ${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 = decodeProtoBytes(record.index?.blob, `snapshot.record.index.blob (${collection})`);
-            const valueBlob = decodeProtoBytes(record.value?.blob, `snapshot.record.value.blob (${collection})`);
+        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 = decodeProtoBytes(record.keyId?.id, `snapshot.record.keyId.id (${collection})`);
-            const recordKeyData = await this.getKeyData(recordKeyId);
-            if (!recordKeyData) {
-                throw new WaAppStateMissingKeyError(`missing snapshot mutation key ${keyIdToHex(recordKeyId)} for ${collection}`, recordKeyId, collection);
-            }
-            const decrypted = await this.crypto.decryptMutation({
-                operation: proto.SyncdMutation.SyncdOperation.SET,
-                keyId: recordKeyId,
-                keyData: recordKeyData,
-                indexMac,
-                valueBlob
-            });
-            return {
-                decrypted,
+            records[i] = {
+                indexMac: decodeProtoBytes(record.index?.blob, `snapshot.record.index.blob (${collection})`),
+                valueBlob: 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 ${bytesToHex(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                }
+                const decrypted = await this.crypto.decryptMutation({
+                    operation: 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})`);
@@ -577,51 +620,63 @@ export class WaAppStateSyncClient {
             if (!record) {
                 throw new Error(`patch mutation is missing record (${collection})`);
             }
-            const indexMac = decodeProtoBytes(record.index?.blob, `patch.record.index.blob (${collection})`);
-            const valueBlob = decodeProtoBytes(record.value?.blob, `patch.record.value.blob (${collection})`);
             const recordKeyId = decodeProtoBytes(record.keyId?.id, `patch.record.keyId.id (${collection})`);
-            const recordKeyData = await this.getKeyData(recordKeyId);
-            if (!recordKeyData) {
-                throw new WaAppStateMissingKeyError(`missing mutation key ${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.SyncdMutation.SyncdOperation.REMOVE
-                    ? 'remove'
-                    : 'set',
-                source: 'patch',
+            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: decodeProtoBytes(record.index?.blob, `patch.record.index.blob (${collection})`),
+                valueBlob: 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 ${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.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) {
+    async assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextHash, valueMacs) {
         const snapshotMac = decodeProtoBytes(patch.snapshotMac, `patch.snapshotMac (${collection})`);
         const expectedSnapshotMac = await this.crypto.generateSnapshotMac(patchKeyData, nextHash, patchVersion, collection);
         if (!uint8Equal(expectedSnapshotMac, snapshotMac)) {
             throw new Error(`patch snapshot MAC mismatch for ${collection}`);
         }
         const patchMac = decodeProtoBytes(patch.patchMac, `patch.patchMac (${collection})`);
-        const expectedPatchMac = await this.crypto.generatePatchMac(patchKeyData, snapshotMac, decryptedMutations.map((mutation) => mutation.valueMac), patchVersion, collection);
+        const expectedPatchMac = await this.crypto.generatePatchMac(patchKeyData, snapshotMac, valueMacs, patchVersion, collection);
         if (!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);
         }
@@ -640,29 +695,39 @@ export 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.SyncdPatch.encode({
-            version: { version: patchVersion },
             mutations: encryptedMutations,
             snapshotMac,
             patchMac,
-            keyId: { id: activeKey.keyId }
+            keyId: { id: activeKey.keyId },
+            ...(deviceIndex === undefined ? {} : { deviceIndex }),
+            clientDebugData
         }).finish();
         return {
             encodedPatch,
@@ -674,13 +739,35 @@ export class WaAppStateSyncClient {
             }
         };
     }
+    resolveDeviceIndex() {
+        const meJid = this.getCurrentMeJid?.();
+        if (!meJid) {
+            return undefined;
+        }
+        try {
+            return 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.PatchDebugData.encode({
+            isSenderPrimary: false,
+            senderPlatform: 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 = keyIdToHex(mutation.indexMac);
+            const indexMacHex = bytesToHex(mutation.indexMac);
             const existing = indexValueMap.get(indexMacHex);
             if (mutation.operation === proto.SyncdMutation.SyncdOperation.REMOVE) {
                 if (!existing) {
@@ -745,9 +832,33 @@ export 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 = 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(bytesToHex(missingKeyIds[index]), loadedKeyData[index] ?? null);
+        }
+    }
     async getKeyData(keyId) {
         const context = this.requireSyncContext();
-        const keyHex = keyIdToHex(keyId);
+        const keyHex = bytesToHex(keyId);
         if (context.keys.has(keyHex)) {
             return context.keys.get(keyHex) ?? null;
         }
@@ -768,6 +879,7 @@ export class WaAppStateSyncClient {
     setCollectionState(collection, version, hash, indexValueMap) {
         const context = this.requireSyncContext();
         context.collections.set(collection, {
+            initialized: true,
             version,
             hash,
             indexValueMap