zapo-js 0.1.0

package/dist/appstate/WaAppStateSyncResponseParser.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSyncResponse = parseSyncResponse;
+exports.parseCollectionState = parseCollectionState;
+const utils_1 = require("./utils");
+const _proto_1 = require("../proto.js");
+const constants_1 = require("../protocol/constants");
+const helpers_1 = require("../transport/node/helpers");
+function parseSyncResponse(iqNode) {
+    if (iqNode.tag !== constants_1.WA_NODE_TAGS.IQ) {
+        throw new Error(`invalid sync response tag ${iqNode.tag}`);
+    }
+    const syncNode = (0, helpers_1.findNodeChild)(iqNode, constants_1.WA_NODE_TAGS.SYNC);
+    if (!syncNode) {
+        throw new Error('sync response is missing <sync> node');
+    }
+    const payloads = [];
+    for (const collectionNode of (0, helpers_1.getNodeChildrenByTag)(syncNode, constants_1.WA_NODE_TAGS.COLLECTION)) {
+        const collection = (0, utils_1.parseCollectionName)(collectionNode.attrs.name);
+        if (!collection) {
+            throw new Error(`invalid app-state collection name: ${collectionNode.attrs.name}`);
+        }
+        const state = parseCollectionState(collectionNode);
+        const versionAttr = collectionNode.attrs.version;
+        let version;
+        if (versionAttr) {
+            const parsedVersion = Number.parseInt(versionAttr, 10);
+            if (!Number.isSafeInteger(parsedVersion) || parsedVersion < 0) {
+                throw new Error(`invalid app-state collection version "${versionAttr}"`);
+            }
+            version = parsedVersion;
+        }
+        const patchesNode = (0, helpers_1.findNodeChild)(collectionNode, constants_1.WA_NODE_TAGS.PATCHES);
+        const patches = patchesNode
+            ? (0, helpers_1.getNodeChildrenByTag)(patchesNode, constants_1.WA_NODE_TAGS.PATCH).map((node) => _proto_1.proto.SyncdPatch.decode((0, helpers_1.decodeNodeContentBase64OrBytes)(node.content, 'collection.patches.patch')))
+            : [];
+        const snapshotNode = (0, helpers_1.findNodeChild)(collectionNode, constants_1.WA_NODE_TAGS.SNAPSHOT);
+        const snapshotReference = snapshotNode
+            ? _proto_1.proto.ExternalBlobReference.decode((0, helpers_1.decodeNodeContentBase64OrBytes)(snapshotNode.content, 'collection.snapshot'))
+            : undefined;
+        payloads.push({
+            collection,
+            state,
+            version,
+            patches,
+            snapshotReference
+        });
+    }
+    return payloads;
+}
+function parseCollectionState(node) {
+    const type = node.attrs.type;
+    const hasMorePatches = node.attrs.has_more_patches === 'true';
+    if (type !== constants_1.WA_IQ_TYPES.ERROR) {
+        return hasMorePatches
+            ? constants_1.WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE
+            : constants_1.WA_APP_STATE_COLLECTION_STATES.SUCCESS;
+    }
+    const errorNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.ERROR);
+    const code = errorNode?.attrs.code;
+    if (code === constants_1.WA_APP_STATE_ERROR_CODES.CONFLICT) {
+        return hasMorePatches
+            ? constants_1.WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE
+            : constants_1.WA_APP_STATE_COLLECTION_STATES.CONFLICT;
+    }
+    if (code === constants_1.WA_APP_STATE_ERROR_CODES.BAD_REQUEST ||
+        code === constants_1.WA_APP_STATE_ERROR_CODES.NOT_FOUND) {
+        return constants_1.WA_APP_STATE_COLLECTION_STATES.ERROR_FATAL;
+    }
+    return constants_1.WA_APP_STATE_COLLECTION_STATES.ERROR_RETRY;
+}

package/dist/appstate/constants.js

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

package/dist/appstate/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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;
+__exportStar(require("./constants"), exports);
+__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; } });

package/dist/appstate/store/sqlite.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeAppStateFingerprint = encodeAppStateFingerprint;
+exports.decodeAppStateFingerprint = decodeAppStateFingerprint;
+exports.decodeAppStateSyncKeys = decodeAppStateSyncKeys;
+exports.decodeAppStateCollections = decodeAppStateCollections;
+const _proto_1 = require("../../proto.js");
+const coercion_1 = require("../../util/coercion");
+function encodeAppStateFingerprint(fingerprint) {
+    if (!fingerprint) {
+        return null;
+    }
+    return _proto_1.proto.Message.AppStateSyncKeyFingerprint.encode(fingerprint).finish();
+}
+function decodeAppStateFingerprint(raw) {
+    const bytes = (0, coercion_1.asOptionalBytes)(raw, 'appstate_sync_keys.fingerprint');
+    if (!bytes) {
+        return undefined;
+    }
+    try {
+        return _proto_1.proto.Message.AppStateSyncKeyFingerprint.decode(bytes);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid appstate_sync_keys.fingerprint protobuf payload: ${reason}`);
+    }
+}
+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)
+    }));
+}
+function decodeAppStateCollections(versionRows, valueRows) {
+    const valueMapByCollection = new Map();
+    for (const row of valueRows) {
+        const collection = (0, coercion_1.asString)(row.collection, 'appstate_collection_index_values.collection');
+        const byIndex = valueMapByCollection.get(collection) ?? {};
+        byIndex[(0, coercion_1.asString)(row.index_mac_hex, 'appstate_collection_index_values.index_mac_hex')] =
+            (0, coercion_1.asBytes)(row.value_mac, 'appstate_collection_index_values.value_mac');
+        valueMapByCollection.set(collection, byIndex);
+    }
+    const collections = {};
+    for (const row of versionRows) {
+        const collection = (0, coercion_1.asString)(row.collection, 'appstate_collection_versions.collection');
+        collections[collection] = {
+            version: (0, coercion_1.asNumber)(row.version, 'appstate_collection_versions.version'),
+            hash: (0, coercion_1.asBytes)(row.hash, 'appstate_collection_versions.hash'),
+            indexValueMap: valueMapByCollection.get(collection) ?? {}
+        };
+    }
+    return collections;
+}

package/dist/appstate/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/appstate/utils.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyIdToHex = keyIdToHex;
+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 base64_1 = require("../util/base64");
+const bytes_1 = require("../util/bytes");
+function keyIdToHex(keyId) {
+    return (0, bytes_1.bytesToHex)(keyId);
+}
+function parseCollectionName(value) {
+    if (!value) {
+        return null;
+    }
+    for (const collection of Object.values(constants_1.WA_APP_STATE_COLLECTIONS)) {
+        if (collection === value) {
+            return collection;
+        }
+    }
+    return null;
+}
+function keyDeviceId(keyId) {
+    if (keyId.byteLength < 6) {
+        return null;
+    }
+    return (keyId[0] << 8) | keyId[1];
+}
+function keyEpoch(keyId) {
+    if (keyId.byteLength < 6) {
+        return -1;
+    }
+    return new DataView(keyId.buffer, keyId.byteOffset, keyId.byteLength).getUint32(2, false);
+}
+function pickActiveSyncKey(keys) {
+    let active = null;
+    for (const key of keys) {
+        if (!active) {
+            active = key;
+            continue;
+        }
+        const currentEpoch = keyEpoch(active.keyId);
+        const nextEpoch = keyEpoch(key.keyId);
+        if (nextEpoch > currentEpoch) {
+            active = key;
+            continue;
+        }
+        if (nextEpoch < currentEpoch) {
+            continue;
+        }
+        const nextDeviceId = keyDeviceId(key.keyId);
+        const currentDeviceId = keyDeviceId(active.keyId);
+        if (nextDeviceId !== null && currentDeviceId !== null && nextDeviceId < currentDeviceId) {
+            active = key;
+        }
+    }
+    return active;
+}
+function toNetworkOrder64(value) {
+    const out = new Uint8Array(8);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, Math.floor(value / 4294967296), false);
+    view.setUint32(4, value >>> 0, false);
+    return out;
+}
+async function downloadExternalBlobReference(mediaTransfer, reference) {
+    if (!reference.directPath) {
+        throw new Error('external blob reference is missing directPath');
+    }
+    const mediaKey = (0, base64_1.decodeProtoBytes)(reference.mediaKey, 'external blob mediaKey');
+    const fileSha256 = (0, base64_1.decodeProtoBytes)(reference.fileSha256, 'external blob fileSha256');
+    const fileEncSha256 = (0, base64_1.decodeProtoBytes)(reference.fileEncSha256, 'external blob fileEncSha256');
+    return mediaTransfer.downloadAndDecrypt({
+        directPath: reference.directPath,
+        mediaType: constants_1.WA_APP_STATE_KEY_TYPES.MD_APP_STATE,
+        mediaKey,
+        fileSha256,
+        fileEncSha256
+    });
+}

package/dist/auth/WaAuthClient.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaAuthClient = void 0;
+const WaAuthCredentialsFlow_1 = require("./flow/WaAuthCredentialsFlow");
+const WaPairingFlow_1 = require("./pairing/WaPairingFlow");
+const WaQrFlow_1 = require("./pairing/WaQrFlow");
+const constants_1 = require("../protocol/constants");
+const bytes_1 = require("../util/bytes");
+const primitives_1 = require("../util/primitives");
+const runtime_1 = require("../util/runtime");
+class WaAuthClient {
+    constructor(options, deps) {
+        const deviceBrowser = options.deviceBrowser ?? constants_1.WA_DEFAULTS.DEVICE_BROWSER;
+        const device = Object.freeze({
+            browser: deviceBrowser,
+            osDisplayName: options.deviceOsDisplayName ?? (0, runtime_1.getRuntimeOsDisplayName)(),
+            platform: options.devicePlatform ?? (0, constants_1.getWaCompanionPlatformId)(deviceBrowser)
+        });
+        this.options = Object.freeze({
+            ...options,
+            deviceBrowser: device.browser,
+            deviceOsDisplayName: device.osDisplayName,
+            devicePlatform: device.platform,
+            requireFullSync: options.requireFullSync
+        });
+        this.logger = deps.logger;
+        this.callbacks = deps.callbacks ?? {};
+        this.authStore = deps.authStore;
+        this.signalStore = deps.signalStore;
+        this.credentials = null;
+        this.qrFlow = new WaQrFlow_1.WaQrFlow({
+            logger: this.logger,
+            getCredentials: () => this.credentials,
+            getDevicePlatform: () => device.platform,
+            emitQr: (qr, ttlMs) => this.callbacks.onQr?.(qr, ttlMs)
+        });
+        this.pairingFlow = new WaPairingFlow_1.WaPairingFlow({
+            logger: this.logger,
+            auth: {
+                getCredentials: () => this.credentials,
+                updateCredentials: this.updateCredentials.bind(this)
+            },
+            socket: deps.socket,
+            qrFlow: this.qrFlow,
+            device,
+            callbacks: {
+                emitPairingCode: (code) => this.callbacks.onPairingCode?.(code),
+                emitPairingRefresh: (forceManual) => this.callbacks.onPairingRefresh?.(forceManual),
+                emitPaired: (credentials) => this.callbacks.onPaired?.(credentials)
+            }
+        });
+    }
+    getState(connected = false) {
+        return {
+            connected,
+            registered: this.credentials?.meJid !== null && this.credentials?.meJid !== undefined,
+            hasQr: this.qrFlow.hasQr(),
+            hasPairingCode: this.pairingFlow.hasPairingSession()
+        };
+    }
+    getCurrentCredentials() {
+        return this.credentials;
+    }
+    async loadOrCreateCredentials() {
+        return this.runHandled(async () => {
+            this.logger.debug('auth client loadOrCreateCredentials start');
+            this.credentials = await (0, WaAuthCredentialsFlow_1.loadOrCreateCredentials)({
+                logger: this.logger,
+                authStore: this.authStore,
+                signalStore: this.signalStore
+            });
+            this.logger.info('auth client credentials ready', {
+                registered: this.credentials.meJid !== null && this.credentials.meJid !== undefined
+            });
+            return this.credentials;
+        });
+    }
+    buildCommsConfig(socketOptions) {
+        this.logger.trace('auth client building comms config');
+        return (0, WaAuthCredentialsFlow_1.buildCommsConfig)(this.logger, this.requireCredentials(), socketOptions, {
+            deviceBrowser: this.options.deviceBrowser,
+            deviceOsDisplayName: this.options.deviceOsDisplayName,
+            requireFullSync: this.options.requireFullSync
+        });
+    }
+    async clearTransientState() {
+        this.logger.trace('auth client clear transient state');
+        this.qrFlow.clear();
+        this.pairingFlow.clearSession();
+    }
+    async clearStoredCredentials() {
+        this.logger.warn('auth client clearing stored credentials');
+        await this.authStore.clear();
+        this.credentials = null;
+        await this.clearTransientState();
+    }
+    async persistServerStaticKey(serverStaticKey) {
+        this.logger.debug('persisting server static key', {
+            keyLength: serverStaticKey.byteLength
+        });
+        await this.patchCredentials((credentials) => ({
+            ...credentials,
+            serverStaticKey
+        }));
+    }
+    async persistServerHasPreKeys(serverHasPreKeys) {
+        await this.patchCredentials((credentials) => ({
+            ...credentials,
+            serverHasPreKeys
+        }), {
+            shouldPersist: (current) => current.serverHasPreKeys !== serverHasPreKeys,
+            onPersist: () => {
+                this.logger.debug('persisting serverHasPreKeys', {
+                    serverHasPreKeys
+                });
+            }
+        });
+    }
+    async persistRoutingInfo(routingInfo) {
+        this.logger.trace('persisting routing info', {
+            byteLength: routingInfo.byteLength
+        });
+        await this.patchCredentials((credentials) => ({
+            ...credentials,
+            routingInfo
+        }), {
+            shouldPersist: (current) => {
+                if (current.routingInfo && (0, bytes_1.uint8Equal)(current.routingInfo, routingInfo)) {
+                    this.logger.trace('routing info unchanged, skipping persistence');
+                    return false;
+                }
+                return true;
+            }
+        });
+    }
+    async clearRoutingInfo() {
+        return this.patchCredentials((credentials) => ({
+            ...credentials,
+            routingInfo: undefined
+        }), {
+            shouldPersist: (current) => current.routingInfo !== undefined,
+            onPersist: () => {
+                this.logger.warn('clearing persisted routing info');
+            }
+        });
+    }
+    async persistMeLid(meLid) {
+        await this.persistSuccessAttributes({
+            meLid
+        });
+    }
+    async persistSuccessAttributes(attributes) {
+        let changes = {};
+        await this.patchCredentials((credentials) => {
+            const nextMeLid = attributes.meLid ?? credentials.meLid;
+            const nextMeDisplayName = attributes.meDisplayName ?? credentials.meDisplayName;
+            const nextCompanionEncStatic = attributes.companionEncStatic ?? credentials.companionEncStatic;
+            const nextLastSuccessTs = attributes.lastSuccessTs ?? credentials.lastSuccessTs;
+            const nextPropsVersion = attributes.propsVersion ?? credentials.propsVersion;
+            const nextAbPropsVersion = attributes.abPropsVersion ?? credentials.abPropsVersion;
+            const nextConnectionLocation = attributes.connectionLocation ?? credentials.connectionLocation;
+            const nextAccountCreationTs = attributes.accountCreationTs ?? credentials.accountCreationTs;
+            changes = {
+                lidChanged: nextMeLid !== credentials.meLid,
+                displayNameChanged: nextMeDisplayName !== credentials.meDisplayName,
+                companionChanged: (credentials.companionEncStatic === undefined) !==
+                    (nextCompanionEncStatic === undefined) ||
+                    (credentials.companionEncStatic !== undefined &&
+                        nextCompanionEncStatic !== undefined &&
+                        !(0, bytes_1.uint8Equal)(credentials.companionEncStatic, nextCompanionEncStatic)),
+                lastSuccessTsChanged: nextLastSuccessTs !== credentials.lastSuccessTs,
+                propsVersionChanged: nextPropsVersion !== credentials.propsVersion,
+                abPropsVersionChanged: nextAbPropsVersion !== credentials.abPropsVersion,
+                connectionLocationChanged: nextConnectionLocation !== credentials.connectionLocation,
+                accountCreationTsChanged: nextAccountCreationTs !== credentials.accountCreationTs
+            };
+            return {
+                ...credentials,
+                meLid: nextMeLid,
+                meDisplayName: nextMeDisplayName,
+                companionEncStatic: nextCompanionEncStatic,
+                lastSuccessTs: nextLastSuccessTs,
+                propsVersion: nextPropsVersion,
+                abPropsVersion: nextAbPropsVersion,
+                connectionLocation: nextConnectionLocation,
+                accountCreationTs: nextAccountCreationTs
+            };
+        }, {
+            shouldPersist: () => Object.values(changes).some(Boolean),
+            onPersist: () => {
+                this.logger.debug('persisting success attributes', changes);
+            }
+        });
+    }
+    async requestPairingCode(phoneNumber, shouldShowPushNotification = false) {
+        this.requireCredentials();
+        this.logger.info('auth client requesting pairing code');
+        return this.runHandled(() => this.pairingFlow.requestPairingCode(phoneNumber, shouldShowPushNotification));
+    }
+    async fetchPairingCountryCodeIso() {
+        this.requireCredentials();
+        this.logger.trace('auth client fetching pairing country code ISO');
+        return this.runHandled(() => this.pairingFlow.fetchPairingCountryCodeIso());
+    }
+    async handleIncomingIqSet(node) {
+        return this.runHandled(async () => {
+            this.logger.trace('auth client handleIncomingIqSet', { id: node.attrs.id });
+            return this.pairingFlow.handleIncomingIqSet(node);
+        });
+    }
+    async handleLinkCodeNotification(node) {
+        return this.runHandled(async () => {
+            this.logger.trace('auth client handleLinkCodeNotification', { id: node.attrs.id });
+            return this.pairingFlow.handleLinkCodeNotification(node);
+        });
+    }
+    async handleCompanionRegRefreshNotification(node) {
+        return this.runHandled(async () => {
+            this.logger.trace('auth client handleCompanionRegRefreshNotification', {
+                id: node.attrs.id
+            });
+            return this.pairingFlow.handleCompanionRegRefreshNotification(node);
+        });
+    }
+    async patchCredentials(buildNext, options = {}) {
+        const current = this.requireCredentials();
+        const next = buildNext(current);
+        if (options.shouldPersist && !options.shouldPersist(current, next)) {
+            return current;
+        }
+        options.onPersist?.(current, next);
+        await this.updateCredentials(next);
+        return next;
+    }
+    async runHandled(action) {
+        try {
+            return await action();
+        }
+        catch (error) {
+            this.handleError((0, primitives_1.toError)(error));
+            throw error;
+        }
+    }
+    async updateCredentials(credentials) {
+        this.logger.trace('auth client update credentials', {
+            registered: credentials.meJid !== null && credentials.meJid !== undefined
+        });
+        this.credentials = credentials;
+        await (0, WaAuthCredentialsFlow_1.persistCredentials)({
+            logger: this.logger,
+            authStore: this.authStore,
+            signalStore: this.signalStore
+        }, credentials);
+    }
+    requireCredentials() {
+        if (!this.credentials) {
+            throw new Error('credentials are not initialized');
+        }
+        return this.credentials;
+    }
+    handleError(error) {
+        this.logger.error('wa auth client error', { message: error.message });
+        this.callbacks.onError?.(error);
+    }
+}
+exports.WaAuthClient = WaAuthClient;

package/dist/auth/flow/WaAuthCredentialsFlow.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOrCreateCredentials = loadOrCreateCredentials;
+exports.persistCredentials = persistCredentials;
+exports.buildCommsConfig = buildCommsConfig;
+const _crypto_1 = require("../../crypto/index.js");
+const keys_1 = require("../../crypto/core/keys");
+const X25519_1 = require("../../crypto/curves/X25519");
+const jid_1 = require("../../protocol/jid");
+const WaAdvSignature_1 = require("../../signal/crypto/WaAdvSignature");
+const utils_1 = require("../../signal/registration/utils");
+const primitives_1 = require("../../util/primitives");
+async function loadOrCreateCredentials(args) {
+    args.logger.trace('auth credentials loadOrCreate start');
+    const existing = await args.authStore.load();
+    if (!existing) {
+        const credentials = await createAndPersistFreshCredentials(args);
+        args.logger.info('created fresh auth credentials');
+        return credentials;
+    }
+    args.logger.debug('auth credentials loaded from store', {
+        registered: existing.meJid !== null && existing.meJid !== undefined,
+        hasServerStaticKey: existing.serverStaticKey !== null && existing.serverStaticKey !== undefined
+    });
+    if (!existing.meJid && !(await hasValidSignedPreKey(args.logger, existing))) {
+        args.logger.warn('signed pre-key is invalid, regenerating credentials');
+        const fresh = await createAndPersistFreshCredentials(args);
+        args.logger.info('regenerated credentials due to invalid signed pre-key');
+        return fresh;
+    }
+    await restoreSignalStore(args.signalStore, existing);
+    args.logger.trace('auth credentials restored into signal store');
+    return existing;
+}
+async function persistCredentials(args, credentials) {
+    args.logger.trace('persisting auth credentials', {
+        registered: credentials.meJid !== null && credentials.meJid !== undefined
+    });
+    await args.authStore.save(credentials);
+}
+function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
+    const registered = credentials.meJid !== null && credentials.meJid !== undefined;
+    const loginIdentity = registered ? (0, jid_1.getLoginIdentity)(credentials.meJid) : null;
+    logger.debug('building comms config from credentials', {
+        registered,
+        hasServerStaticKey: credentials.serverStaticKey !== null && credentials.serverStaticKey !== undefined
+    });
+    return {
+        url: socketOptions.url,
+        urls: socketOptions.urls,
+        protocols: socketOptions.protocols,
+        connectTimeoutMs: socketOptions.connectTimeoutMs,
+        reconnectIntervalMs: socketOptions.reconnectIntervalMs,
+        timeoutIntervalMs: socketOptions.timeoutIntervalMs,
+        maxReconnectAttempts: socketOptions.maxReconnectAttempts,
+        noise: {
+            clientStaticKeyPair: credentials.noiseKeyPair,
+            isRegistered: registered,
+            serverStaticKey: credentials.serverStaticKey,
+            routingInfo: credentials.routingInfo,
+            loginPayloadConfig: loginIdentity
+                ? {
+                    username: loginIdentity.username,
+                    device: loginIdentity.device,
+                    deviceBrowser: clientOptions.deviceBrowser,
+                    deviceOsDisplayName: clientOptions.deviceOsDisplayName
+                }
+                : undefined,
+            registrationPayloadConfig: !loginIdentity
+                ? {
+                    registrationInfo: credentials.registrationInfo,
+                    signedPreKey: credentials.signedPreKey,
+                    deviceBrowser: clientOptions.deviceBrowser,
+                    deviceOsDisplayName: clientOptions.deviceOsDisplayName,
+                    requireFullSync: clientOptions.requireFullSync
+                }
+                : undefined
+        }
+    };
+}
+async function createFreshCredentials(signalStore, logger) {
+    logger.trace('creating fresh credentials');
+    const [noiseKeyPair, registrationBundle, advSecretKey] = await Promise.all([
+        X25519_1.X25519.generateKeyPair(),
+        (0, utils_1.createAndStoreInitialKeys)(signalStore),
+        (0, _crypto_1.randomBytesAsync)(32)
+    ]);
+    return {
+        noiseKeyPair,
+        registrationInfo: registrationBundle.registrationInfo,
+        signedPreKey: registrationBundle.signedPreKey,
+        serverHasPreKeys: false,
+        advSecretKey
+    };
+}
+async function createAndPersistFreshCredentials(args) {
+    const credentials = await createFreshCredentials(args.signalStore, args.logger);
+    await persistFreshCredentials(args, credentials);
+    return credentials;
+}
+async function hasValidSignedPreKey(logger, credentials) {
+    try {
+        const serializedPubKey = (0, keys_1.toSerializedPubKey)(credentials.signedPreKey.keyPair.pubKey);
+        const valid = await (0, WaAdvSignature_1.verifySignalSignature)(credentials.registrationInfo.identityKeyPair.pubKey, serializedPubKey, credentials.signedPreKey.signature);
+        logger.trace('signed pre-key validation completed', { valid });
+        return valid;
+    }
+    catch (error) {
+        logger.warn('signed pre-key validation failed with exception', {
+            message: (0, primitives_1.toError)(error).message
+        });
+        return false;
+    }
+}
+async function restoreSignalStore(signalStore, credentials) {
+    await signalStore.setRegistrationInfo(credentials.registrationInfo);
+    await signalStore.setSignedPreKey(credentials.signedPreKey);
+    await signalStore.setServerHasPreKeys(credentials.serverHasPreKeys === true);
+}
+async function persistFreshCredentials(args, credentials) {
+    await args.authStore.save(credentials);
+    await restoreSignalStore(args.signalStore, credentials);
+}