zapo-js 0.1.2 → 0.2.0

package/README.md

@@ -112,6 +112,7 @@ Auth state is persisted in `.auth/state.sqlite`.
 
 ```ts
 import { createPinoLogger, createStore, WaClient } from 'zapo-js'
+import { createSqliteStore } from '@zapo-js/store-sqlite'
 
 const logger = await createPinoLogger({
     level: 'info',
@@ -119,14 +120,21 @@ const logger = await createPinoLogger({
 })
 
 const store = createStore({
-    sqlite: {
-        path: '.auth/state.sqlite',
-        driver: 'auto'
+    backends: {
+        sqlite: createSqliteStore({
+            path: '.auth/state.sqlite',
+            driver: 'auto'
+        })
     },
     providers: {
+        auth: 'sqlite',
+        signal: 'sqlite',
+        senderKey: 'sqlite',
+        appState: 'sqlite',
         messages: 'sqlite',
         threads: 'sqlite',
-        contacts: 'sqlite'
+        contacts: 'sqlite',
+        privacyToken: 'sqlite'
     }
 })
 

package/dist/appstate/WaAppStateCrypto.js

@@ -183,7 +183,7 @@ class WaAppStateCrypto {
         octetLength[octetLength.length - 1] = associatedData.byteLength & 0xff;
         const key = await (0, primitives_1.importHmacSha512Key)(valueMacKey);
         const full = await (0, primitives_1.hmacSign)(key, (0, bytes_2.concatBytes)([associatedData, cipherWithIv, octetLength]));
-        return full.slice(0, constants_1.APP_STATE_VALUE_MAC_LENGTH);
+        return full.subarray(0, constants_1.APP_STATE_VALUE_MAC_LENGTH);
     }
     touchDerivedKeysCacheEntry(cacheKey, keys) {
         if (this.derivedKeysCacheMaxSize <= 0) {

package/dist/appstate/WaAppStateSyncClient.js

@@ -168,7 +168,12 @@ 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();
@@ -184,21 +189,26 @@ 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);
@@ -225,7 +235,7 @@ class WaAppStateSyncClient {
             blockedCollections
         };
     }
-    async buildCollectionSyncRequest(collection, pendingByCollection) {
+    async buildCollectionSyncRequest(collection, pendingByCollection, activeSyncKey) {
         const collectionState = await this.getCollectionState(collection);
         const hasPersistedState = collectionState.initialized;
         const attrs = {
@@ -246,7 +256,7 @@ class WaAppStateSyncClient {
                 });
             }
             else {
-                const outgoing = await this.buildOutgoingPatch(collection, collectionState, pendingMutations);
+                const outgoing = await this.buildOutgoingPatch(collection, collectionState, pendingMutations, activeSyncKey);
                 outgoingContext = outgoing.context;
                 children.push({
                     tag: constants_2.WA_NODE_TAGS.PATCH,
@@ -332,14 +342,14 @@ class WaAppStateSyncClient {
                 const snapshotBytes = await downloader(payload.collection, 'snapshot', payload.snapshotReference);
                 const snapshot = this.validateSnapshot(payload.collection, _proto_1.proto.SyncdSnapshot.decode(snapshotBytes));
                 const snapshotMutations = await this.applySnapshot(payload.collection, snapshot);
-                appliedMutations = appliedMutations.concat(snapshotMutations);
+                appliedMutations.push(...snapshotMutations);
                 collectionStateChanged = true;
             }
             if (payload.patches.length > 0) {
                 const readyPatches = await this.resolveReadyPatches(payload, options);
                 for (const readyPatch of readyPatches) {
                     const patchMutations = await this.applyPatch(payload.collection, readyPatch);
-                    appliedMutations = appliedMutations.concat(patchMutations);
+                    appliedMutations.push(...patchMutations);
                     collectionStateChanged = true;
                 }
             }
@@ -428,13 +438,12 @@ class WaAppStateSyncClient {
         }
     }
     async resolveReadyPatches(payload, options) {
-        const sortedPatches = payload.patches
-            .map((patch) => ({
-            patch,
-            sortVersion: this.parseCollectionPatchVersion(payload.collection, patch)
-        }))
-            .sort((left, right) => left.sortVersion - right.sortVersion)
-            .map((entry) => entry.patch);
+        const sortedPatches = payload.patches.slice();
+        const sortVersions = new Map();
+        for (const patch of sortedPatches) {
+            sortVersions.set(patch, this.parseCollectionPatchVersion(payload.collection, patch));
+        }
+        sortedPatches.sort((left, right) => sortVersions.get(left) - sortVersions.get(right));
         return Promise.all(sortedPatches.map(async (patch) => {
             let readyPatch = patch;
             if ((!readyPatch.mutations || readyPatch.mutations.length === 0) &&
@@ -521,7 +530,13 @@ class WaAppStateSyncClient {
                 timestamp: this.normalizeProtoLong(decrypted.value?.timestamp, `snapshot.record.value.timestamp (${collection})`)
             });
         }
-        const ltHash = await this.crypto.ltHashAdd(constants_1.APP_STATE_EMPTY_LT_HASH, Array.from(indexValueMap.values()));
+        const ltHashInput = new Array(indexValueMap.size);
+        let ltHashInputIndex = 0;
+        for (const valueMac of indexValueMap.values()) {
+            ltHashInput[ltHashInputIndex] = valueMac;
+            ltHashInputIndex += 1;
+        }
+        const ltHash = await this.crypto.ltHashAdd(constants_1.APP_STATE_EMPTY_LT_HASH, ltHashInput);
         const expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
         if (!(0, bytes_2.uint8Equal)(expectedSnapshotMac, snapshot.mac)) {
             throw new Error(`snapshot MAC mismatch for ${collection}`);
@@ -555,35 +570,52 @@ class WaAppStateSyncClient {
         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.slice();
+        return decryptedMutations;
     }
     async decryptSnapshotRecords(collection, snapshot) {
-        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, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
-            }
-            const decrypted = await this.crypto.decryptMutation({
-                operation: _proto_1.proto.SyncdMutation.SyncdOperation.SET,
-                keyId: recordKeyId,
-                keyData: recordKeyData,
-                indexMac,
-                valueBlob
-            });
-            return {
-                decrypted,
+        const rawRecords = snapshot.records ?? [];
+        const records = new Array(rawRecords.length);
+        const recordKeyIds = new Array(rawRecords.length);
+        for (let i = 0; i < rawRecords.length; i += 1) {
+            const record = rawRecords[i];
+            const recordKeyId = (0, bytes_1.decodeProtoBytes)(record.keyId?.id, `snapshot.record.keyId.id (${collection})`);
+            records[i] = {
+                indexMac: (0, bytes_1.decodeProtoBytes)(record.index?.blob, `snapshot.record.index.blob (${collection})`),
+                valueBlob: (0, bytes_1.decodeProtoBytes)(record.value?.blob, `snapshot.record.value.blob (${collection})`),
                 recordKeyId
             };
-        }));
+            recordKeyIds[i] = recordKeyId;
+        }
+        await this.preloadKeyData(recordKeyIds);
+        const decryptTasks = new Array(records.length);
+        for (let i = 0; i < records.length; i += 1) {
+            const { indexMac, valueBlob, recordKeyId } = records[i];
+            decryptTasks[i] = (async () => {
+                const recordKeyData = await this.getKeyData(recordKeyId);
+                if (!recordKeyData) {
+                    throw new WaAppStateMissingKeyError(`missing snapshot mutation key ${(0, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                }
+                const decrypted = await this.crypto.decryptMutation({
+                    operation: _proto_1.proto.SyncdMutation.SyncdOperation.SET,
+                    keyId: recordKeyId,
+                    keyData: recordKeyData,
+                    indexMac,
+                    valueBlob
+                });
+                return {
+                    decrypted,
+                    recordKeyId
+                };
+            })();
+        }
+        return Promise.all(decryptTasks);
     }
     async decryptPatchMutations(collection, patch) {
-        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})`);
@@ -592,42 +624,49 @@ class WaAppStateSyncClient {
             if (!record) {
                 throw new Error(`patch mutation is missing record (${collection})`);
             }
-            return {
+            const recordKeyId = (0, bytes_1.decodeProtoBytes)(record.keyId?.id, `patch.record.keyId.id (${collection})`);
+            parsedMutations[i] = {
                 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, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
-            }
-            const decrypted = await this.crypto.decryptMutation({
-                operation: operationCode,
-                keyId: recordKeyId,
-                keyData: recordKeyData,
-                indexMac,
-                valueBlob
-            });
-            return {
-                collection,
-                operation: operationCode === _proto_1.proto.SyncdMutation.SyncdOperation.REMOVE
-                    ? 'remove'
-                    : 'set',
-                source: 'patch',
-                operationCode,
-                index: decrypted.index,
-                value: decrypted.value,
-                version: decrypted.version,
-                indexMac: decrypted.indexMac,
-                valueMac: decrypted.valueMac,
-                keyId: recordKeyId,
-                timestamp: this.normalizeProtoLong(decrypted.value?.timestamp, `patch.record.value.timestamp (${collection})`)
+                recordKeyId
             };
-        }));
+            mutationKeyIds[i] = recordKeyId;
+        }
+        await this.preloadKeyData(mutationKeyIds);
+        const decryptTasks = new Array(parsedMutations.length);
+        for (let i = 0; i < parsedMutations.length; i += 1) {
+            const { operationCode, indexMac, valueBlob, recordKeyId } = parsedMutations[i];
+            decryptTasks[i] = (async () => {
+                const recordKeyData = await this.getKeyData(recordKeyId);
+                if (!recordKeyData) {
+                    throw new WaAppStateMissingKeyError(`missing mutation key ${(0, bytes_2.bytesToHex)(recordKeyId)} for ${collection}`, recordKeyId, collection);
+                }
+                const decrypted = await this.crypto.decryptMutation({
+                    operation: operationCode,
+                    keyId: recordKeyId,
+                    keyData: recordKeyData,
+                    indexMac,
+                    valueBlob
+                });
+                return {
+                    collection,
+                    operation: operationCode === _proto_1.proto.SyncdMutation.SyncdOperation.REMOVE
+                        ? 'remove'
+                        : 'set',
+                    source: 'patch',
+                    operationCode,
+                    index: decrypted.index,
+                    value: decrypted.value,
+                    version: decrypted.version,
+                    indexMac: decrypted.indexMac,
+                    valueMac: decrypted.valueMac,
+                    keyId: recordKeyId,
+                    timestamp: this.normalizeProtoLong(decrypted.value?.timestamp, `patch.record.value.timestamp (${collection})`)
+                };
+            })();
+        }
+        return Promise.all(decryptTasks);
     }
     async assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextHash, valueMacs) {
         const snapshotMac = (0, bytes_1.decodeProtoBytes)(patch.snapshotMac, `patch.snapshotMac (${collection})`);
@@ -641,8 +680,7 @@ 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);
         }
@@ -661,23 +699,30 @@ class WaAppStateSyncClient {
             });
             return { operationCode, encrypted };
         }));
-        const encryptedMutations = encryptedResults.map(({ operationCode, encrypted }) => ({
-            operation: operationCode,
-            record: {
-                keyId: { id: activeKey.keyId },
-                index: { blob: encrypted.indexMac },
-                value: { blob: encrypted.valueBlob }
-            }
-        }));
-        const macMutations = encryptedResults.map(({ operationCode, encrypted }) => ({
-            operation: operationCode,
-            indexMac: encrypted.indexMac,
-            valueMac: encrypted.valueMac
-        }));
+        const encryptedMutations = new Array(encryptedResults.length);
+        const macMutations = new Array(encryptedResults.length);
+        const valueMacs = new Array(encryptedResults.length);
+        for (let i = 0; i < encryptedResults.length; i += 1) {
+            const { operationCode, encrypted } = encryptedResults[i];
+            encryptedMutations[i] = {
+                operation: operationCode,
+                record: {
+                    keyId: { id: activeKey.keyId },
+                    index: { blob: encrypted.indexMac },
+                    value: { blob: encrypted.valueBlob }
+                }
+            };
+            macMutations[i] = {
+                operation: operationCode,
+                indexMac: encrypted.indexMac,
+                valueMac: encrypted.valueMac
+            };
+            valueMacs[i] = encrypted.valueMac;
+        }
         const nextState = await this.computeNextCollectionState(snapshot.hash, snapshot.indexValueMap, macMutations, collection);
         const patchVersion = snapshot.version + 1;
         const snapshotMac = await this.crypto.generateSnapshotMac(activeKey.keyData, nextState.hash, patchVersion, collection);
-        const patchMac = await this.crypto.generatePatchMac(activeKey.keyData, snapshotMac, macMutations.map((item) => item.valueMac), patchVersion, collection);
+        const patchMac = await this.crypto.generatePatchMac(activeKey.keyData, snapshotMac, valueMacs, patchVersion, collection);
         const deviceIndex = this.resolveDeviceIndex();
         const clientDebugData = this.buildPatchClientDebugData();
         const encodedPatch = _proto_1.proto.SyncdPatch.encode({

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

@@ -4,8 +4,8 @@ exports.encodeAppStateFingerprint = encodeAppStateFingerprint;
 exports.decodeAppStateFingerprint = decodeAppStateFingerprint;
 exports.decodeAppStateSyncKeys = decodeAppStateSyncKeys;
 exports.decodeAppStateCollections = decodeAppStateCollections;
-const _proto_1 = require("../../proto.js");
-const coercion_1 = require("../../util/coercion");
+const _proto_1 = require("../proto.js");
+const coercion_1 = require("../util/coercion");
 function encodeAppStateFingerprint(fingerprint) {
     if (!fingerprint) {
         return null;
@@ -26,12 +26,17 @@ function decodeAppStateFingerprint(raw) {
     }
 }
 function decodeAppStateSyncKeys(rows) {
-    return rows.map((row) => ({
-        keyId: (0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id'),
-        keyData: (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'),
-        timestamp: (0, coercion_1.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: (0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id'),
+            keyData: (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'),
+            timestamp: (0, coercion_1.asNumber)(row.timestamp, 'appstate_sync_keys.timestamp'),
+            fingerprint: decodeAppStateFingerprint(row.fingerprint)
+        };
+    }
+    return decoded;
 }
 function decodeAppStateCollections(versionRows, valueRows) {
     const valueMapByCollection = new Map();

package/dist/appstate/index.js

@@ -14,15 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaAppStateSyncClient = exports.parseSyncResponse = exports.parseCollectionState = exports.WaAppStateMissingKeyError = exports.WaAppStateCrypto = void 0;
+exports.WaAppStateSyncClient = exports.parseSyncResponse = exports.WaAppStateCrypto = exports.decodeAppStateSyncKeys = exports.decodeAppStateCollections = exports.decodeAppStateFingerprint = exports.encodeAppStateFingerprint = void 0;
 __exportStar(require("./constants"), exports);
+var encoding_1 = require("./encoding");
+Object.defineProperty(exports, "encodeAppStateFingerprint", { enumerable: true, get: function () { return encoding_1.encodeAppStateFingerprint; } });
+Object.defineProperty(exports, "decodeAppStateFingerprint", { enumerable: true, get: function () { return encoding_1.decodeAppStateFingerprint; } });
+Object.defineProperty(exports, "decodeAppStateCollections", { enumerable: true, get: function () { return encoding_1.decodeAppStateCollections; } });
+Object.defineProperty(exports, "decodeAppStateSyncKeys", { enumerable: true, get: function () { return encoding_1.decodeAppStateSyncKeys; } });
 __exportStar(require("./utils"), exports);
 var WaAppStateCrypto_1 = require("./WaAppStateCrypto");
 Object.defineProperty(exports, "WaAppStateCrypto", { enumerable: true, get: function () { return WaAppStateCrypto_1.WaAppStateCrypto; } });
-var WaAppStateSyncClient_1 = require("./WaAppStateSyncClient");
-Object.defineProperty(exports, "WaAppStateMissingKeyError", { enumerable: true, get: function () { return WaAppStateSyncClient_1.WaAppStateMissingKeyError; } });
 var WaAppStateSyncResponseParser_1 = require("./WaAppStateSyncResponseParser");
-Object.defineProperty(exports, "parseCollectionState", { enumerable: true, get: function () { return WaAppStateSyncResponseParser_1.parseCollectionState; } });
 Object.defineProperty(exports, "parseSyncResponse", { enumerable: true, get: function () { return WaAppStateSyncResponseParser_1.parseSyncResponse; } });
-var WaAppStateSyncClient_2 = require("./WaAppStateSyncClient");
-Object.defineProperty(exports, "WaAppStateSyncClient", { enumerable: true, get: function () { return WaAppStateSyncClient_2.WaAppStateSyncClient; } });
+var WaAppStateSyncClient_1 = require("./WaAppStateSyncClient");
+Object.defineProperty(exports, "WaAppStateSyncClient", { enumerable: true, get: function () { return WaAppStateSyncClient_1.WaAppStateSyncClient; } });

package/dist/appstate/utils.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCollectionName = parseCollectionName;
-exports.keyDeviceId = keyDeviceId;
 exports.keyEpoch = keyEpoch;
 exports.pickActiveSyncKey = pickActiveSyncKey;
-exports.toNetworkOrder64 = toNetworkOrder64;
 exports.downloadExternalBlobReference = downloadExternalBlobReference;
 const constants_1 = require("../protocol/constants");
 const bytes_1 = require("../util/bytes");
@@ -44,9 +42,6 @@ function pickActiveSyncKey(keys) {
     }
     return active;
 }
-function toNetworkOrder64(value) {
-    return (0, bytes_1.intToBytes)(8, value);
-}
 async function downloadExternalBlobReference(mediaTransfer, reference) {
     if (!reference.directPath) {
         throw new Error('external blob reference is missing directPath');

package/dist/auth/WaAuthClient.js

@@ -53,7 +53,7 @@ class WaAuthClient {
     getState(connected = false) {
         return {
             connected,
-            registered: hasMeJid(this.credentials),
+            registered: this.credentials?.meJid !== null && this.credentials?.meJid !== undefined,
             hasQr: this.qrFlow.hasQr(),
             hasPairingCode: this.pairingFlow.hasPairingSession()
         };
@@ -70,7 +70,7 @@ class WaAuthClient {
                 signalStore: this.signalStore
             });
             this.logger.info('auth client credentials ready', {
-                registered: hasMeJid(this.credentials)
+                registered: this.credentials?.meJid !== null && this.credentials?.meJid !== undefined
             });
             return this.credentials;
         });
@@ -80,7 +80,8 @@ class WaAuthClient {
         return (0, WaAuthCredentialsFlow_1.buildCommsConfig)(this.logger, this.requireCredentials(), socketOptions, {
             deviceBrowser: this.options.deviceBrowser,
             deviceOsDisplayName: this.options.deviceOsDisplayName,
-            requireFullSync: this.options.requireFullSync
+            requireFullSync: this.options.requireFullSync,
+            version: this.options.version
         });
     }
     async clearTransientState() {
@@ -90,9 +91,8 @@ class WaAuthClient {
     }
     async clearStoredCredentials() {
         this.logger.warn('auth client clearing stored credentials');
-        await this.authStore.clear();
         this.credentials = null;
-        await this.clearTransientState();
+        await Promise.all([this.authStore.clear(), this.clearTransientState()]);
     }
     async persistServerStaticKey(serverStaticKey) {
         this.logger.debug('persisting server static key', {
@@ -145,46 +145,38 @@ class WaAuthClient {
         });
     }
     async persistSuccessAttributes(attributes) {
-        await this.patchCredentials((credentials) => {
-            return {
-                ...credentials,
-                meLid: attributes.meLid ?? credentials.meLid,
-                meDisplayName: attributes.meDisplayName ?? credentials.meDisplayName,
-                companionEncStatic: attributes.companionEncStatic ?? credentials.companionEncStatic,
-                lastSuccessTs: attributes.lastSuccessTs ?? credentials.lastSuccessTs,
-                propsVersion: attributes.propsVersion ?? credentials.propsVersion,
-                abPropsVersion: attributes.abPropsVersion ?? credentials.abPropsVersion,
-                connectionLocation: attributes.connectionLocation ?? credentials.connectionLocation,
-                accountCreationTs: attributes.accountCreationTs ?? credentials.accountCreationTs
-            };
-        }, {
-            shouldPersist: (current, next) => next.meLid !== current.meLid ||
-                next.meDisplayName !== current.meDisplayName ||
-                (current.companionEncStatic === undefined) !==
-                    (next.companionEncStatic === undefined) ||
+        let persistDiff;
+        const computeDiff = (current, next) => ({
+            lidChanged: next.meLid !== current.meLid,
+            displayNameChanged: next.meDisplayName !== current.meDisplayName,
+            companionChanged: (current.companionEncStatic === undefined) !==
+                (next.companionEncStatic === undefined) ||
                 (current.companionEncStatic !== undefined &&
                     next.companionEncStatic !== undefined &&
-                    !(0, bytes_1.uint8Equal)(current.companionEncStatic, next.companionEncStatic)) ||
-                next.lastSuccessTs !== current.lastSuccessTs ||
-                next.propsVersion !== current.propsVersion ||
-                next.abPropsVersion !== current.abPropsVersion ||
-                next.connectionLocation !== current.connectionLocation ||
-                next.accountCreationTs !== current.accountCreationTs,
-            onPersist: (current, next) => {
-                this.logger.debug('persisting success attributes', {
-                    lidChanged: next.meLid !== current.meLid,
-                    displayNameChanged: next.meDisplayName !== current.meDisplayName,
-                    companionChanged: (current.companionEncStatic === undefined) !==
-                        (next.companionEncStatic === undefined) ||
-                        (current.companionEncStatic !== undefined &&
-                            next.companionEncStatic !== undefined &&
-                            !(0, bytes_1.uint8Equal)(current.companionEncStatic, next.companionEncStatic)),
-                    lastSuccessTsChanged: next.lastSuccessTs !== current.lastSuccessTs,
-                    propsVersionChanged: next.propsVersion !== current.propsVersion,
-                    abPropsVersionChanged: next.abPropsVersion !== current.abPropsVersion,
-                    connectionLocationChanged: next.connectionLocation !== current.connectionLocation,
-                    accountCreationTsChanged: next.accountCreationTs !== current.accountCreationTs
-                });
+                    !(0, bytes_1.uint8Equal)(current.companionEncStatic, next.companionEncStatic)),
+            lastSuccessTsChanged: next.lastSuccessTs !== current.lastSuccessTs,
+            propsVersionChanged: next.propsVersion !== current.propsVersion,
+            abPropsVersionChanged: next.abPropsVersion !== current.abPropsVersion,
+            connectionLocationChanged: next.connectionLocation !== current.connectionLocation,
+            accountCreationTsChanged: next.accountCreationTs !== current.accountCreationTs
+        });
+        await this.patchCredentials((credentials) => ({
+            ...credentials,
+            meLid: attributes.meLid ?? credentials.meLid,
+            meDisplayName: attributes.meDisplayName ?? credentials.meDisplayName,
+            companionEncStatic: attributes.companionEncStatic ?? credentials.companionEncStatic,
+            lastSuccessTs: attributes.lastSuccessTs ?? credentials.lastSuccessTs,
+            propsVersion: attributes.propsVersion ?? credentials.propsVersion,
+            abPropsVersion: attributes.abPropsVersion ?? credentials.abPropsVersion,
+            connectionLocation: attributes.connectionLocation ?? credentials.connectionLocation,
+            accountCreationTs: attributes.accountCreationTs ?? credentials.accountCreationTs
+        }), {
+            shouldPersist: (current, next) => {
+                persistDiff = computeDiff(current, next);
+                return Object.values(persistDiff).some(Boolean);
+            },
+            onPersist: () => {
+                this.logger.debug('persisting success attributes', persistDiff);
             }
         });
     }
@@ -233,7 +225,7 @@ class WaAuthClient {
     }
     async updateCredentials(credentials) {
         this.logger.trace('auth client update credentials', {
-            registered: hasMeJid(credentials)
+            registered: credentials?.meJid !== null && credentials?.meJid !== undefined
         });
         this.credentials = credentials;
         await (0, WaAuthCredentialsFlow_1.persistCredentials)({
@@ -254,6 +246,3 @@ class WaAuthClient {
     }
 }
 exports.WaAuthClient = WaAuthClient;
-function hasMeJid(credentials) {
-    return credentials?.meJid !== null && credentials?.meJid !== undefined;
-}

package/dist/auth/flow/WaAuthCredentialsFlow.js

@@ -20,7 +20,7 @@ async function loadOrCreateCredentials(args) {
         return credentials;
     }
     args.logger.debug('auth credentials loaded from store', {
-        registered: isRegistered(existing),
+        registered: existing.meJid !== null && existing.meJid !== undefined,
         hasServerStaticKey: existing.serverStaticKey !== null && existing.serverStaticKey !== undefined
     });
     if (!existing.meJid && !(await hasValidSignedPreKey(args.logger, existing))) {
@@ -35,7 +35,7 @@ async function loadOrCreateCredentials(args) {
 }
 async function persistCredentials(args, credentials) {
     args.logger.trace('persisting auth credentials', {
-        registered: isRegistered(credentials)
+        registered: credentials.meJid !== null && credentials.meJid !== undefined
     });
     await args.authStore.save(credentials);
 }
@@ -68,7 +68,8 @@ function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
                     username: loginIdentity.username,
                     device: loginIdentity.device,
                     deviceBrowser: clientOptions.deviceBrowser,
-                    deviceOsDisplayName: clientOptions.deviceOsDisplayName
+                    deviceOsDisplayName: clientOptions.deviceOsDisplayName,
+                    versionBase: clientOptions.version
                 }
                 : undefined,
             registrationPayloadConfig: !loginIdentity
@@ -77,7 +78,8 @@ function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
                     signedPreKey: credentials.signedPreKey,
                     deviceBrowser: clientOptions.deviceBrowser,
                     deviceOsDisplayName: clientOptions.deviceOsDisplayName,
-                    requireFullSync: clientOptions.requireFullSync
+                    requireFullSync: clientOptions.requireFullSync,
+                    versionBase: clientOptions.version
                 }
                 : undefined
         }
@@ -100,6 +102,7 @@ async function createFreshCredentials(signalStore, logger) {
 }
 async function createFreshAndPersistCredentials(args) {
     const credentials = await createFreshCredentials(args.signalStore, args.logger);
+    // Persist credentials first so signal restore never commits state for credentials that failed to save.
     await args.authStore.save(credentials);
     await restoreSignalStore(args.signalStore, credentials);
     return credentials;
@@ -125,6 +128,3 @@ async function restoreSignalStore(signalStore, credentials) {
         signalStore.setServerHasPreKeys(credentials.serverHasPreKeys === true)
     ]);
 }
-function isRegistered(credentials) {
-    return credentials.meJid !== null && credentials.meJid !== undefined;
-}