zapo-js 0.1.2 → 0.2.0

package/dist/crypto/math/mod.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GROUP_L = exports.FIELD_P = void 0;
 exports.mod = mod;
 exports.modGroup = modGroup;
 exports.modInv = modInv;
 const constants_1 = require("../math/constants");
-Object.defineProperty(exports, "FIELD_P", { enumerable: true, get: function () { return constants_1.FIELD_P; } });
-Object.defineProperty(exports, "GROUP_L", { enumerable: true, get: function () { return constants_1.GROUP_L; } });
+const fe_1 = require("../math/fe");
 function mod(value, modulus = constants_1.FIELD_P) {
     const remainder = value % modulus;
     return remainder >= 0n ? remainder : remainder + modulus;
@@ -18,8 +16,17 @@ function modInv(value, modulus = constants_1.FIELD_P) {
     if (value === 0n) {
         throw new Error('field inversion by zero');
     }
+    if (modulus === constants_1.FIELD_P) {
+        return fieldInv(value);
+    }
     return modPow(value, modulus - 2n, modulus);
 }
+function fieldInv(x) {
+    const a = (0, fe_1.feFromBigInt)(mod(x));
+    const out = (0, fe_1.fe)();
+    (0, fe_1.feInv)(out, a);
+    return (0, fe_1.feToBigInt)(out);
+}
 function modPow(base, exponent, modulus) {
     if (modulus <= 0n) {
         throw new Error('modulus must be positive');

package/dist/esm/appstate/WaAppStateCrypto.js

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

package/dist/esm/appstate/WaAppStateSyncClient.js

@@ -164,7 +164,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 +185,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 +231,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 +252,7 @@ export class WaAppStateSyncClient {
                 });
             }
             else {
-                const outgoing = await this.buildOutgoingPatch(collection, collectionState, pendingMutations);
+                const outgoing = await this.buildOutgoingPatch(collection, collectionState, pendingMutations, activeSyncKey);
                 outgoingContext = outgoing.context;
                 children.push({
                     tag: WA_NODE_TAGS.PATCH,
@@ -328,14 +338,14 @@ export class WaAppStateSyncClient {
                 const snapshotBytes = await downloader(payload.collection, 'snapshot', payload.snapshotReference);
                 const snapshot = this.validateSnapshot(payload.collection, proto.SyncdSnapshot.decode(snapshotBytes));
                 const snapshotMutations = await this.applySnapshot(payload.collection, snapshot);
-                appliedMutations = appliedMutations.concat(snapshotMutations);
+                appliedMutations.push(...snapshotMutations);
                 collectionStateChanged = true;
             }
             if (payload.patches.length > 0) {
                 const readyPatches = await this.resolveReadyPatches(payload, options);
                 for (const readyPatch of readyPatches) {
                     const patchMutations = await this.applyPatch(payload.collection, readyPatch);
-                    appliedMutations = appliedMutations.concat(patchMutations);
+                    appliedMutations.push(...patchMutations);
                     collectionStateChanged = true;
                 }
             }
@@ -424,13 +434,12 @@ export class WaAppStateSyncClient {
         }
     }
     async resolveReadyPatches(payload, options) {
-        const sortedPatches = payload.patches
-            .map((patch) => ({
-            patch,
-            sortVersion: this.parseCollectionPatchVersion(payload.collection, patch)
-        }))
-            .sort((left, right) => left.sortVersion - right.sortVersion)
-            .map((entry) => entry.patch);
+        const sortedPatches = payload.patches.slice();
+        const sortVersions = new Map();
+        for (const patch of sortedPatches) {
+            sortVersions.set(patch, this.parseCollectionPatchVersion(payload.collection, patch));
+        }
+        sortedPatches.sort((left, right) => sortVersions.get(left) - sortVersions.get(right));
         return Promise.all(sortedPatches.map(async (patch) => {
             let readyPatch = patch;
             if ((!readyPatch.mutations || readyPatch.mutations.length === 0) &&
@@ -517,7 +526,13 @@ export class WaAppStateSyncClient {
                 timestamp: this.normalizeProtoLong(decrypted.value?.timestamp, `snapshot.record.value.timestamp (${collection})`)
             });
         }
-        const ltHash = await this.crypto.ltHashAdd(APP_STATE_EMPTY_LT_HASH, Array.from(indexValueMap.values()));
+        const ltHashInput = new Array(indexValueMap.size);
+        let ltHashInputIndex = 0;
+        for (const valueMac of indexValueMap.values()) {
+            ltHashInput[ltHashInputIndex] = valueMac;
+            ltHashInputIndex += 1;
+        }
+        const ltHash = await this.crypto.ltHashAdd(APP_STATE_EMPTY_LT_HASH, ltHashInput);
         const expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
         if (!uint8Equal(expectedSnapshotMac, snapshot.mac)) {
             throw new Error(`snapshot MAC mismatch for ${collection}`);
@@ -551,35 +566,52 @@ export 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: 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 +620,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 +676,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 +695,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 './WaAppStateSyncResponseParser.js';
 export { WaAppStateSyncClient } from './WaAppStateSyncClient.js';

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');

package/dist/esm/auth/WaAuthClient.js

@@ -50,7 +50,7 @@ export 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()
         };
@@ -67,7 +67,7 @@ export 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;
         });
@@ -77,7 +77,8 @@ export class WaAuthClient {
         return 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() {
@@ -87,9 +88,8 @@ export 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', {
@@ -142,46 +142,38 @@ export 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 &&
-                    !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 &&
-                            !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
-                });
+                    !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);
             }
         });
     }
@@ -230,7 +222,7 @@ export 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 persistCredentials({
@@ -250,6 +242,3 @@ export class WaAuthClient {
         this.callbacks.onError?.(error);
     }
 }
-function hasMeJid(credentials) {
-    return credentials?.meJid !== null && credentials?.meJid !== undefined;
-}

package/dist/esm/auth/flow/WaAuthCredentialsFlow.js

@@ -15,7 +15,7 @@ export 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))) {
@@ -30,7 +30,7 @@ export async function loadOrCreateCredentials(args) {
 }
 export 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);
 }
@@ -63,7 +63,8 @@ export function buildCommsConfig(logger, credentials, socketOptions, clientOptio
                     username: loginIdentity.username,
                     device: loginIdentity.device,
                     deviceBrowser: clientOptions.deviceBrowser,
-                    deviceOsDisplayName: clientOptions.deviceOsDisplayName
+                    deviceOsDisplayName: clientOptions.deviceOsDisplayName,
+                    versionBase: clientOptions.version
                 }
                 : undefined,
             registrationPayloadConfig: !loginIdentity
@@ -72,7 +73,8 @@ export function buildCommsConfig(logger, credentials, socketOptions, clientOptio
                     signedPreKey: credentials.signedPreKey,
                     deviceBrowser: clientOptions.deviceBrowser,
                     deviceOsDisplayName: clientOptions.deviceOsDisplayName,
-                    requireFullSync: clientOptions.requireFullSync
+                    requireFullSync: clientOptions.requireFullSync,
+                    versionBase: clientOptions.version
                 }
                 : undefined
         }
@@ -95,6 +97,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;
@@ -120,6 +123,3 @@ async function restoreSignalStore(signalStore, credentials) {
         signalStore.setServerHasPreKeys(credentials.serverHasPreKeys === true)
     ]);
 }
-function isRegistered(credentials) {
-    return credentials.meJid !== null && credentials.meJid !== undefined;
-}

package/dist/esm/auth/index.js

@@ -1,4 +1,2 @@
 export * from './types.js';
 export { WaAuthClient } from './WaAuthClient.js';
-export { completeCompanionFinish, createCompanionHello } from './pairing/WaPairingCodeCrypto.js';
-export { WaAuthSqliteStore } from '../store/providers/sqlite/auth.store.js';