zapo-js 0.1.0 → 0.1.2

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,13 @@ 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 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 +182,57 @@ class WaAppStateSyncClient {
                 skippedUploadCollections.add(request.collection);
             }
         }
-        return {
-            collectionNodes: requests.map((request) => request.node),
+        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 results = [];
+        const collectionsToRefetch = [];
+        const blockedCollections = [];
+        const missingKeyIds = [];
+        const missingKeyIdHexes = new Set();
+        let stateChanged = false;
+        for (const entry of collectionOutcomes) {
+            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 {
+            results,
+            collectionsToRefetch,
+            stateChanged,
+            missingKeyIds,
+            blockedCollections
         };
     }
     async buildCollectionSyncRequest(collection, pendingByCollection) {
         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;
@@ -275,6 +289,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 +311,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 = [];
@@ -341,13 +352,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 +401,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(','),
@@ -493,16 +497,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,
@@ -519,7 +523,7 @@ class WaAppStateSyncClient {
         }
         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_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,32 +535,39 @@ 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.slice();
     }
     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 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, utils_1.keyIdToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                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,
@@ -572,7 +583,7 @@ class WaAppStateSyncClient {
         }));
     }
     async decryptPatchMutations(collection, patch) {
-        return Promise.all((patch.mutations ?? []).map(async (mutation) => {
+        const parsedMutations = (patch.mutations ?? []).map((mutation) => {
             const operationCode = mutation.operation;
             if (operationCode === null || operationCode === undefined) {
                 throw new Error(`patch mutation is missing operation (${collection})`);
@@ -581,12 +592,18 @@ 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})`);
+            return {
+                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, utils_1.keyIdToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                throw new WaAppStateMissingKeyError(`missing mutation key ${(0, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
             }
             const decrypted = await this.crypto.decryptMutation({
                 operation: operationCode,
@@ -612,15 +629,15 @@ class WaAppStateSyncClient {
             };
         }));
     }
-    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}`);
         }
     }
@@ -661,12 +678,15 @@ class WaAppStateSyncClient {
         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 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 +698,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 +791,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 +838,7 @@ class WaAppStateSyncClient {
     setCollectionState(collection, version, hash, indexValueMap) {
         const context = this.requireSyncContext();
         context.collections.set(collection, {
+            initialized: true,
             version,
             hash,
             indexValueMap

package/dist/appstate/WaAppStateSyncResponseParser.js

@@ -12,6 +12,12 @@ function parseSyncResponse(iqNode) {
     }
     const syncNode = (0, helpers_1.findNodeChild)(iqNode, constants_1.WA_NODE_TAGS.SYNC);
     if (!syncNode) {
+        if (iqNode.attrs.type === constants_1.WA_IQ_TYPES.ERROR) {
+            const errorNode = (0, helpers_1.findNodeChild)(iqNode, constants_1.WA_NODE_TAGS.ERROR);
+            const code = errorNode?.attrs.code ?? 'unknown';
+            const text = errorNode?.attrs.text ?? 'unknown';
+            throw new Error(`sync iq failed (${code}: ${text})`);
+        }
         throw new Error('sync response is missing <sync> node');
     }
     const payloads = [];
@@ -30,11 +36,16 @@ function parseSyncResponse(iqNode) {
             }
             version = parsedVersion;
         }
-        const patchesNode = (0, helpers_1.findNodeChild)(collectionNode, constants_1.WA_NODE_TAGS.PATCHES);
-        const patches = patchesNode
-            ? (0, helpers_1.getNodeChildrenByTag)(patchesNode, constants_1.WA_NODE_TAGS.PATCH).map((node) => _proto_1.proto.SyncdPatch.decode((0, helpers_1.decodeNodeContentBase64OrBytes)(node.content, 'collection.patches.patch')))
-            : [];
-        const snapshotNode = (0, helpers_1.findNodeChild)(collectionNode, constants_1.WA_NODE_TAGS.SNAPSHOT);
+        const [patchesNode, snapshotNode] = (0, helpers_1.findNodeChildrenByTags)(collectionNode, [
+            constants_1.WA_NODE_TAGS.PATCHES,
+            constants_1.WA_NODE_TAGS.SNAPSHOT
+        ]);
+        const patches = [];
+        if (patchesNode) {
+            for (const patchNode of (0, helpers_1.getNodeChildrenByTag)(patchesNode, constants_1.WA_NODE_TAGS.PATCH)) {
+                patches.push(_proto_1.proto.SyncdPatch.decode((0, helpers_1.decodeNodeContentBase64OrBytes)(patchNode.content, 'collection.patches.patch')));
+            }
+        }
         const snapshotReference = snapshotNode
             ? _proto_1.proto.ExternalBlobReference.decode((0, helpers_1.decodeNodeContentBase64OrBytes)(snapshotNode.content, 'collection.snapshot'))
             : undefined;

package/dist/appstate/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APP_STATE_DEFAULT_COLLECTIONS = exports.APP_STATE_EMPTY_LT_HASH = exports.APP_STATE_POINT_SIZE = exports.APP_STATE_LT_HASH_SIZE = exports.APP_STATE_IV_LENGTH = exports.APP_STATE_MAC_OCTET_LENGTH = exports.APP_STATE_VALUE_MAC_LENGTH = exports.APP_STATE_DERIVED_PATCH_MAC_KEY_END = exports.APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END = exports.APP_STATE_DERIVED_VALUE_MAC_KEY_END = exports.APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END = exports.APP_STATE_DERIVED_INDEX_KEY_END = exports.APP_STATE_DERIVED_KEY_LENGTH = void 0;
+exports.APP_STATE_DEFAULT_COLLECTIONS = exports.APP_STATE_DEFAULT_COLLECTION_VERSION = exports.APP_STATE_EMPTY_LT_HASH = exports.APP_STATE_POINT_SIZE = exports.APP_STATE_LT_HASH_SIZE = exports.APP_STATE_IV_LENGTH = exports.APP_STATE_MAC_OCTET_LENGTH = exports.APP_STATE_VALUE_MAC_LENGTH = exports.APP_STATE_DERIVED_PATCH_MAC_KEY_END = exports.APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END = exports.APP_STATE_DERIVED_VALUE_MAC_KEY_END = exports.APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END = exports.APP_STATE_DERIVED_INDEX_KEY_END = exports.APP_STATE_DERIVED_KEY_LENGTH = void 0;
 const constants_1 = require("../protocol/constants");
 exports.APP_STATE_DERIVED_KEY_LENGTH = 160;
 exports.APP_STATE_DERIVED_INDEX_KEY_END = 32;
@@ -14,10 +14,11 @@ exports.APP_STATE_IV_LENGTH = 16;
 exports.APP_STATE_LT_HASH_SIZE = 128;
 exports.APP_STATE_POINT_SIZE = 2;
 exports.APP_STATE_EMPTY_LT_HASH = new Uint8Array(exports.APP_STATE_LT_HASH_SIZE);
-exports.APP_STATE_DEFAULT_COLLECTIONS = [
+exports.APP_STATE_DEFAULT_COLLECTION_VERSION = 0;
+exports.APP_STATE_DEFAULT_COLLECTIONS = Object.freeze([
     constants_1.WA_APP_STATE_COLLECTIONS.CRITICAL_UNBLOCK_LOW,
     constants_1.WA_APP_STATE_COLLECTIONS.CRITICAL_BLOCK,
     constants_1.WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
     constants_1.WA_APP_STATE_COLLECTIONS.REGULAR,
     constants_1.WA_APP_STATE_COLLECTIONS.REGULAR_HIGH
-];
+]);

package/dist/appstate/utils.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keyIdToHex = keyIdToHex;
 exports.parseCollectionName = parseCollectionName;
 exports.keyDeviceId = keyDeviceId;
 exports.keyEpoch = keyEpoch;
@@ -8,33 +7,18 @@ exports.pickActiveSyncKey = pickActiveSyncKey;
 exports.toNetworkOrder64 = toNetworkOrder64;
 exports.downloadExternalBlobReference = downloadExternalBlobReference;
 const constants_1 = require("../protocol/constants");
-const base64_1 = require("../util/base64");
 const bytes_1 = require("../util/bytes");
-function keyIdToHex(keyId) {
-    return (0, bytes_1.bytesToHex)(keyId);
-}
+const APP_STATE_COLLECTION_NAMES = new Set(Object.values(constants_1.WA_APP_STATE_COLLECTIONS));
 function parseCollectionName(value) {
-    if (!value) {
-        return null;
-    }
-    for (const collection of Object.values(constants_1.WA_APP_STATE_COLLECTIONS)) {
-        if (collection === value) {
-            return collection;
-        }
-    }
-    return null;
+    return value && APP_STATE_COLLECTION_NAMES.has(value) ? value : null;
 }
 function keyDeviceId(keyId) {
-    if (keyId.byteLength < 6) {
-        return null;
-    }
-    return (keyId[0] << 8) | keyId[1];
+    return keyId.byteLength < 6 ? null : (keyId[0] << 8) | keyId[1];
 }
 function keyEpoch(keyId) {
-    if (keyId.byteLength < 6) {
-        return -1;
-    }
-    return new DataView(keyId.buffer, keyId.byteOffset, keyId.byteLength).getUint32(2, false);
+    return keyId.byteLength < 6
+        ? -1
+        : keyId[2] * 16777216 + keyId[3] * 65536 + keyId[4] * 256 + keyId[5];
 }
 function pickActiveSyncKey(keys) {
     let active = null;
@@ -61,19 +45,15 @@ function pickActiveSyncKey(keys) {
     return active;
 }
 function toNetworkOrder64(value) {
-    const out = new Uint8Array(8);
-    const view = new DataView(out.buffer);
-    view.setUint32(0, Math.floor(value / 4294967296), false);
-    view.setUint32(4, value >>> 0, false);
-    return out;
+    return (0, bytes_1.intToBytes)(8, value);
 }
 async function downloadExternalBlobReference(mediaTransfer, reference) {
     if (!reference.directPath) {
         throw new Error('external blob reference is missing directPath');
     }
-    const mediaKey = (0, base64_1.decodeProtoBytes)(reference.mediaKey, 'external blob mediaKey');
-    const fileSha256 = (0, base64_1.decodeProtoBytes)(reference.fileSha256, 'external blob fileSha256');
-    const fileEncSha256 = (0, base64_1.decodeProtoBytes)(reference.fileEncSha256, 'external blob fileEncSha256');
+    const mediaKey = (0, bytes_1.decodeProtoBytes)(reference.mediaKey, 'external blob mediaKey');
+    const fileSha256 = (0, bytes_1.decodeProtoBytes)(reference.fileSha256, 'external blob fileSha256');
+    const fileEncSha256 = (0, bytes_1.decodeProtoBytes)(reference.fileEncSha256, 'external blob fileEncSha256');
     return mediaTransfer.downloadAndDecrypt({
         directPath: reference.directPath,
         mediaType: constants_1.WA_APP_STATE_KEY_TYPES.MD_APP_STATE,