zapo-js 0.1.0 → 0.1.2

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,13 @@ 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 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 +178,57 @@ export 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 === 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 {
+            results,
+            collectionsToRefetch,
+            stateChanged,
+            missingKeyIds,
+            blockedCollections
         };
     }
     async buildCollectionSyncRequest(collection, pendingByCollection) {
         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;
@@ -271,6 +285,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 +307,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 = [];
@@ -337,13 +348,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 +397,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(','),
@@ -492,13 +496,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,
@@ -530,29 +534,36 @@ 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.slice();
     }
     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 recordKeyId = decodeProtoBytes(record.keyId?.id, `snapshot.record.keyId.id (${collection})`);
+        const records = (snapshot.records ?? []).map((record) => ({
+            indexMac: decodeProtoBytes(record.index?.blob, `snapshot.record.index.blob (${collection})`),
+            valueBlob: decodeProtoBytes(record.value?.blob, `snapshot.record.value.blob (${collection})`),
+            recordKeyId: 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 ${keyIdToHex(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                throw new WaAppStateMissingKeyError(`missing snapshot mutation key ${bytesToHex(recordKeyId)} for ${collection}`, recordKeyId, collection);
             }
             const decrypted = await this.crypto.decryptMutation({
                 operation: proto.SyncdMutation.SyncdOperation.SET,
@@ -568,7 +579,7 @@ export 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})`);
@@ -577,12 +588,18 @@ 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})`);
+            return {
+                operationCode,
+                indexMac: decodeProtoBytes(record.index?.blob, `patch.record.index.blob (${collection})`),
+                valueBlob: decodeProtoBytes(record.value?.blob, `patch.record.value.blob (${collection})`),
+                recordKeyId: 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 ${keyIdToHex(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                throw new WaAppStateMissingKeyError(`missing mutation key ${bytesToHex(recordKeyId)} for ${collection}`, recordKeyId, collection);
             }
             const decrypted = await this.crypto.decryptMutation({
                 operation: operationCode,
@@ -608,14 +625,14 @@ export class WaAppStateSyncClient {
             };
         }));
     }
-    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}`);
         }
@@ -657,12 +674,15 @@ export 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.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 +694,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 +787,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 +834,7 @@ export class WaAppStateSyncClient {
     setCollectionState(collection, version, hash, indexValueMap) {
         const context = this.requireSyncContext();
         context.collections.set(collection, {
+            initialized: true,
             version,
             hash,
             indexValueMap

package/dist/esm/appstate/WaAppStateSyncResponseParser.js

@@ -1,13 +1,19 @@
 import { parseCollectionName } from './utils.js';
 import { proto } from '../proto.js';
 import { WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_IQ_TYPES, WA_NODE_TAGS } from '../protocol/constants.js';
-import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
+import { decodeNodeContentBase64OrBytes, findNodeChildrenByTags, findNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
 export function parseSyncResponse(iqNode) {
     if (iqNode.tag !== WA_NODE_TAGS.IQ) {
         throw new Error(`invalid sync response tag ${iqNode.tag}`);
     }
     const syncNode = findNodeChild(iqNode, WA_NODE_TAGS.SYNC);
     if (!syncNode) {
+        if (iqNode.attrs.type === WA_IQ_TYPES.ERROR) {
+            const errorNode = findNodeChild(iqNode, 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 = [];
@@ -26,11 +32,16 @@ export function parseSyncResponse(iqNode) {
             }
             version = parsedVersion;
         }
-        const patchesNode = findNodeChild(collectionNode, WA_NODE_TAGS.PATCHES);
-        const patches = patchesNode
-            ? getNodeChildrenByTag(patchesNode, WA_NODE_TAGS.PATCH).map((node) => proto.SyncdPatch.decode(decodeNodeContentBase64OrBytes(node.content, 'collection.patches.patch')))
-            : [];
-        const snapshotNode = findNodeChild(collectionNode, WA_NODE_TAGS.SNAPSHOT);
+        const [patchesNode, snapshotNode] = findNodeChildrenByTags(collectionNode, [
+            WA_NODE_TAGS.PATCHES,
+            WA_NODE_TAGS.SNAPSHOT
+        ]);
+        const patches = [];
+        if (patchesNode) {
+            for (const patchNode of getNodeChildrenByTag(patchesNode, WA_NODE_TAGS.PATCH)) {
+                patches.push(proto.SyncdPatch.decode(decodeNodeContentBase64OrBytes(patchNode.content, 'collection.patches.patch')));
+            }
+        }
         const snapshotReference = snapshotNode
             ? proto.ExternalBlobReference.decode(decodeNodeContentBase64OrBytes(snapshotNode.content, 'collection.snapshot'))
             : undefined;

package/dist/esm/appstate/constants.js

@@ -11,10 +11,11 @@ export const APP_STATE_IV_LENGTH = 16;
 export const APP_STATE_LT_HASH_SIZE = 128;
 export const APP_STATE_POINT_SIZE = 2;
 export const APP_STATE_EMPTY_LT_HASH = new Uint8Array(APP_STATE_LT_HASH_SIZE);
-export const APP_STATE_DEFAULT_COLLECTIONS = [
+export const APP_STATE_DEFAULT_COLLECTION_VERSION = 0;
+export const APP_STATE_DEFAULT_COLLECTIONS = Object.freeze([
     WA_APP_STATE_COLLECTIONS.CRITICAL_UNBLOCK_LOW,
     WA_APP_STATE_COLLECTIONS.CRITICAL_BLOCK,
     WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
     WA_APP_STATE_COLLECTIONS.REGULAR,
     WA_APP_STATE_COLLECTIONS.REGULAR_HIGH
-];
+]);

package/dist/esm/appstate/utils.js

@@ -1,31 +1,16 @@
 import { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_KEY_TYPES } from '../protocol/constants.js';
-import { decodeProtoBytes } from '../util/base64.js';
-import { bytesToHex } from '../util/bytes.js';
-export function keyIdToHex(keyId) {
-    return bytesToHex(keyId);
-}
+import { decodeProtoBytes, intToBytes } from '../util/bytes.js';
+const APP_STATE_COLLECTION_NAMES = new Set(Object.values(WA_APP_STATE_COLLECTIONS));
 export function parseCollectionName(value) {
-    if (!value) {
-        return null;
-    }
-    for (const collection of Object.values(WA_APP_STATE_COLLECTIONS)) {
-        if (collection === value) {
-            return collection;
-        }
-    }
-    return null;
+    return value && APP_STATE_COLLECTION_NAMES.has(value) ? value : null;
 }
 export 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];
 }
 export 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];
 }
 export function pickActiveSyncKey(keys) {
     let active = null;
@@ -52,11 +37,7 @@ export function pickActiveSyncKey(keys) {
     return active;
 }
 export 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 intToBytes(8, value);
 }
 export async function downloadExternalBlobReference(mediaTransfer, reference) {
     if (!reference.directPath) {