zapo-js 0.1.2 → 0.3.0

package/dist/esm/appstate/WaAppStateSyncClient.js

@@ -1,12 +1,12 @@
-import { APP_STATE_DEFAULT_COLLECTIONS, APP_STATE_DEFAULT_COLLECTION_VERSION, APP_STATE_EMPTY_LT_HASH } from './constants.js';
+import { APP_STATE_DEFAULT_COLLECTION_VERSION, APP_STATE_DEFAULT_COLLECTIONS, APP_STATE_EMPTY_LT_HASH } from './constants.js';
+import { parseSyncResponse } from './response-parser.js';
 import { WaAppStateCrypto } from './WaAppStateCrypto.js';
-import { parseSyncResponse } from './WaAppStateSyncResponseParser.js';
+import { randomBytesAsync, randomIntAsync } from '../crypto/index.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 { 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 { bytesToHex, decodeProtoBytes, uint8Equal } from '../util/bytes.js';
 import { longToNumber } from '../util/primitives.js';
 export class WaAppStateMissingKeyError extends Error {
     constructor(message, keyId, collection) {
@@ -25,7 +25,8 @@ export class WaAppStateSyncClient {
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? WA_DEFAULTS.APP_STATE_SYNC_TIMEOUT_MS;
         this.onMissingKeys = options.onMissingKeys;
-        this.crypto = new WaAppStateCrypto();
+        this.crypto = new WaAppStateCrypto(undefined, options.skipMacVerification === true);
+        this.mobilePrimary = options.mobilePrimary ?? false;
         this.syncContext = null;
         this.syncPromise = null;
     }
@@ -33,6 +34,28 @@ export class WaAppStateSyncClient {
         this.logger.trace('app-state export requested');
         return this.store.exportData();
     }
+    async ensureInitialSyncKey() {
+        const existing = await this.store.getActiveSyncKey();
+        if (existing) {
+            return existing;
+        }
+        const keyIdBytes = await randomBytesAsync(2);
+        const keyData = await randomBytesAsync(32);
+        const rawId = await randomIntAsync(0, 4294967295);
+        const key = {
+            keyId: keyIdBytes,
+            keyData,
+            timestamp: Date.now(),
+            fingerprint: { rawId, currentIndex: 0, deviceIndexes: [0] }
+        };
+        await this.store.upsertSyncKeys([key]);
+        this.crypto.clearCache();
+        this.logger.info('app-state initial sync key generated (mobile primary)', {
+            keyId: bytesToHex(keyIdBytes),
+            rawId
+        });
+        return key;
+    }
     async importSyncKeys(keys) {
         this.logger.debug('app-state importing sync keys', { count: keys.length });
         const inserted = await this.store.upsertSyncKeys(keys);
@@ -164,7 +187,12 @@ export class WaAppStateSyncClient {
         }
     }
     async syncCollectionsRound(collections, pendingByCollection, options) {
-        const requests = await Promise.all(collections.map((collection) => this.buildCollectionSyncRequest(collection, pendingByCollection)));
+        const activeSyncKey = await this.store.getActiveSyncKey();
+        const requestPromises = new Array(collections.length);
+        for (let index = 0; index < collections.length; index += 1) {
+            requestPromises[index] = this.buildCollectionSyncRequest(collections[index], pendingByCollection, activeSyncKey);
+        }
+        const requests = await Promise.all(requestPromises);
         const collectionNodes = new Array(requests.length);
         const outgoingContexts = new Map();
         const skippedUploadCollections = new Set();
@@ -180,21 +208,26 @@ export class WaAppStateSyncClient {
         }
         const iqNode = this.buildSyncIqNode(collectionNodes);
         const payloadByCollection = await this.fetchSyncPayloadByCollection(iqNode, options.timeoutMs ?? this.defaultTimeoutMs);
-        const collectionOutcomes = await Promise.all(collections.map((collection) => this.processCollectionRound({
-            collection,
-            payloadByCollection,
-            pendingByCollection,
-            options,
-            outgoingContexts,
-            skippedUploadCollections
-        })));
+        const collectionOutcomePromises = new Array(collections.length);
+        for (let index = 0; index < collections.length; index += 1) {
+            collectionOutcomePromises[index] = this.processCollectionRound({
+                collection: collections[index],
+                payloadByCollection,
+                pendingByCollection,
+                options,
+                outgoingContexts,
+                skippedUploadCollections
+            });
+        }
+        const collectionOutcomes = await Promise.all(collectionOutcomePromises);
         const results = [];
         const collectionsToRefetch = [];
         const blockedCollections = [];
         const missingKeyIds = [];
         const missingKeyIdHexes = new Set();
         let stateChanged = false;
-        for (const entry of collectionOutcomes) {
+        for (let index = 0; index < collectionOutcomes.length; index += 1) {
+            const entry = collectionOutcomes[index];
             results.push(entry.result);
             if (entry.shouldRefetch) {
                 collectionsToRefetch.push(entry.collection);
@@ -221,7 +254,7 @@ export class WaAppStateSyncClient {
             blockedCollections
         };
     }
-    async buildCollectionSyncRequest(collection, pendingByCollection) {
+    async buildCollectionSyncRequest(collection, pendingByCollection, activeSyncKey) {
         const collectionState = await this.getCollectionState(collection);
         const hasPersistedState = collectionState.initialized;
         const attrs = {
@@ -242,7 +275,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,
@@ -273,7 +306,7 @@ export class WaAppStateSyncClient {
             content: [
                 {
                     tag: WA_NODE_TAGS.SYNC,
-                    attrs: {},
+                    attrs: this.mobilePrimary ? { data_namespace: '3' } : {},
                     content: collectionNodes
                 }
             ]
@@ -328,14 +361,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;
                 }
             }
@@ -424,13 +457,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) &&
@@ -453,11 +485,13 @@ export class WaAppStateSyncClient {
         if (!snapshot.version?.version) {
             throw new Error(`snapshot for ${collection} is missing version`);
         }
-        if (!snapshot.mac) {
-            throw new Error(`snapshot for ${collection} is missing mac`);
-        }
-        if (!snapshot.keyId?.id) {
-            throw new Error(`snapshot for ${collection} is missing keyId`);
+        if (!this.crypto.isMacVerificationSkipped) {
+            if (!snapshot.mac) {
+                throw new Error(`snapshot for ${collection} is missing mac`);
+            }
+            if (!snapshot.keyId?.id) {
+                throw new Error(`snapshot for ${collection} is missing keyId`);
+            }
         }
         return snapshot;
     }
@@ -472,14 +506,16 @@ export class WaAppStateSyncClient {
         if (!patch.version?.version) {
             throw new Error(`patch for ${collection} is missing version`);
         }
-        if (!patch.snapshotMac) {
-            throw new Error(`patch for ${collection} is missing snapshotMac`);
-        }
-        if (!patch.patchMac) {
-            throw new Error(`patch for ${collection} is missing patchMac`);
-        }
-        if (!patch.keyId?.id) {
-            throw new Error(`patch for ${collection} is missing keyId`);
+        if (!this.crypto.isMacVerificationSkipped) {
+            if (!patch.snapshotMac) {
+                throw new Error(`patch for ${collection} is missing snapshotMac`);
+            }
+            if (!patch.patchMac) {
+                throw new Error(`patch for ${collection} is missing patchMac`);
+            }
+            if (!patch.keyId?.id) {
+                throw new Error(`patch for ${collection} is missing keyId`);
+            }
         }
         if (patch.mutations && patch.mutations.length > 0 && patch.externalMutations) {
             throw new Error(`patch for ${collection} has inline and external mutations together`);
@@ -493,10 +529,13 @@ export class WaAppStateSyncClient {
     }
     async applySnapshot(collection, snapshot) {
         const version = this.normalizeProtoLong(snapshot.version?.version, `snapshot.version.version (${collection})`);
-        const keyId = decodeProtoBytes(snapshot.keyId?.id, `snapshot.keyId.id (${collection})`);
-        const keyData = await this.getKeyData(keyId);
-        if (!keyData) {
-            throw new WaAppStateMissingKeyError(`missing snapshot key ${bytesToHex(keyId)} for ${collection}`, keyId, collection);
+        let keyData = null;
+        if (!this.crypto.isMacVerificationSkipped) {
+            const keyId = decodeProtoBytes(snapshot.keyId?.id, `snapshot.keyId.id (${collection})`);
+            keyData = await this.getKeyData(keyId);
+            if (!keyData) {
+                throw new WaAppStateMissingKeyError(`missing snapshot key ${bytesToHex(keyId)} for ${collection}`, keyId, collection);
+            }
         }
         const indexValueMap = new Map();
         const mutations = [];
@@ -517,10 +556,18 @@ 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 expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
-        if (!uint8Equal(expectedSnapshotMac, snapshot.mac)) {
-            throw new Error(`snapshot MAC mismatch for ${collection}`);
+        const ltHashInput = new Array(indexValueMap.size);
+        let ltHashInputIndex = 0;
+        for (const valueMac of indexValueMap.values()) {
+            ltHashInput[ltHashInputIndex] = valueMac;
+            ltHashInputIndex += 1;
+        }
+        const ltHash = await this.crypto.ltHashAdd(APP_STATE_EMPTY_LT_HASH, ltHashInput);
+        if (keyData !== null) {
+            const expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
+            if (!uint8Equal(expectedSnapshotMac, snapshot.mac)) {
+                throw new Error(`snapshot MAC mismatch for ${collection}`);
+            }
         }
         this.setCollectionState(collection, version, ltHash, indexValueMap);
         return mutations;
@@ -531,10 +578,13 @@ export class WaAppStateSyncClient {
         if (current.version !== patchVersion - 1) {
             throw new Error(`patch version mismatch for ${collection}: local=${current.version}, incoming=${patchVersion}`);
         }
-        const patchKeyId = decodeProtoBytes(patch.keyId?.id, `patch.keyId.id (${collection})`);
-        const patchKeyData = await this.getKeyData(patchKeyId);
-        if (!patchKeyData) {
-            throw new WaAppStateMissingKeyError(`missing patch key ${bytesToHex(patchKeyId)} for ${collection}`, patchKeyId, collection);
+        let patchKeyData = null;
+        if (!this.crypto.isMacVerificationSkipped) {
+            const patchKeyId = decodeProtoBytes(patch.keyId?.id, `patch.keyId.id (${collection})`);
+            patchKeyData = await this.getKeyData(patchKeyId);
+            if (!patchKeyData) {
+                throw new WaAppStateMissingKeyError(`missing patch key ${bytesToHex(patchKeyId)} for ${collection}`, patchKeyId, collection);
+            }
         }
         const decryptedMutations = await this.decryptPatchMutations(collection, patch);
         const macMutations = new Array(decryptedMutations.length);
@@ -549,37 +599,56 @@ export class WaAppStateSyncClient {
             };
         }
         const nextState = await this.computeNextCollectionState(current.hash, current.indexValueMap, macMutations, collection);
-        await this.assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextState.hash, valueMacs);
+        if (patchKeyData !== null) {
+            await this.assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextState.hash, valueMacs);
+        }
         this.setCollectionState(collection, patchVersion, nextState.hash, nextState.indexValueMap);
-        return decryptedMutations.slice();
+        return decryptedMutations;
     }
     async decryptSnapshotRecords(collection, snapshot) {
-        const records = (snapshot.records ?? []).map((record) => ({
-            indexMac: 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 ${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,
+        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})`);
+            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) {
-        const parsedMutations = (patch.mutations ?? []).map((mutation) => {
+        const rawMutations = patch.mutations ?? [];
+        const parsedMutations = new Array(rawMutations.length);
+        const mutationKeyIds = new Array(rawMutations.length);
+        for (let i = 0; i < rawMutations.length; i += 1) {
+            const mutation = rawMutations[i];
             const operationCode = mutation.operation;
             if (operationCode === null || operationCode === undefined) {
                 throw new Error(`patch mutation is missing operation (${collection})`);
@@ -588,42 +657,49 @@ export class WaAppStateSyncClient {
             if (!record) {
                 throw new Error(`patch mutation is missing record (${collection})`);
             }
-            return {
+            const recordKeyId = decodeProtoBytes(record.keyId?.id, `patch.record.keyId.id (${collection})`);
+            parsedMutations[i] = {
                 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 ${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})`)
+                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, valueMacs) {
         const snapshotMac = decodeProtoBytes(patch.snapshotMac, `patch.snapshotMac (${collection})`);
@@ -637,8 +713,7 @@ export class WaAppStateSyncClient {
             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);
         }
@@ -657,23 +732,30 @@ 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({

package/dist/esm/appstate/{store/sqlite.js → encoding.js}

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

package/dist/esm/appstate/index.js

@@ -1,6 +1,6 @@
 export * from './constants.js';
+export { encodeAppStateFingerprint, decodeAppStateFingerprint, decodeAppStateCollections, decodeAppStateSyncKeys } from './encoding.js';
 export * from './utils.js';
 export { WaAppStateCrypto } from './WaAppStateCrypto.js';
-export { WaAppStateMissingKeyError } from './WaAppStateSyncClient.js';
-export { parseCollectionState, parseSyncResponse } from './WaAppStateSyncResponseParser.js';
+export { parseSyncResponse } from './response-parser.js';
 export { WaAppStateSyncClient } from './WaAppStateSyncClient.js';

package/dist/esm/appstate/{WaAppStateSyncResponseParser.js → response-parser.js}

@@ -1,7 +1,7 @@
 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, findNodeChildrenByTags, findNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild, findNodeChildrenByTags, 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}`);

package/dist/esm/appstate/utils.js

@@ -1,10 +1,10 @@
 import { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_KEY_TYPES } from '../protocol/constants.js';
-import { decodeProtoBytes, intToBytes } from '../util/bytes.js';
+import { decodeProtoBytes } from '../util/bytes.js';
 const APP_STATE_COLLECTION_NAMES = new Set(Object.values(WA_APP_STATE_COLLECTIONS));
 export function parseCollectionName(value) {
     return value && APP_STATE_COLLECTION_NAMES.has(value) ? value : null;
 }
-export function keyDeviceId(keyId) {
+function keyDeviceId(keyId) {
     return keyId.byteLength < 6 ? null : (keyId[0] << 8) | keyId[1];
 }
 export function keyEpoch(keyId) {
@@ -36,9 +36,6 @@ export function pickActiveSyncKey(keys) {
     }
     return active;
 }
-export function toNetworkOrder64(value) {
-    return intToBytes(8, value);
-}
 export async function downloadExternalBlobReference(mediaTransfer, reference) {
     if (!reference.directPath) {
         throw new Error('external blob reference is missing directPath');