zapo-js 0.1.0

package/dist/esm/appstate/WaAppStateSyncResponseParser.js

@@ -0,0 +1,67 @@
+import { parseCollectionName } from './utils.js';
+import { proto } from '../proto.js';
+import { WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_IQ_TYPES, WA_NODE_TAGS } from '../protocol/constants.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
+export function parseSyncResponse(iqNode) {
+    if (iqNode.tag !== WA_NODE_TAGS.IQ) {
+        throw new Error(`invalid sync response tag ${iqNode.tag}`);
+    }
+    const syncNode = findNodeChild(iqNode, WA_NODE_TAGS.SYNC);
+    if (!syncNode) {
+        throw new Error('sync response is missing <sync> node');
+    }
+    const payloads = [];
+    for (const collectionNode of getNodeChildrenByTag(syncNode, WA_NODE_TAGS.COLLECTION)) {
+        const collection = 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 = findNodeChild(collectionNode, WA_NODE_TAGS.PATCHES);
+        const patches = patchesNode
+            ? getNodeChildrenByTag(patchesNode, WA_NODE_TAGS.PATCH).map((node) => proto.SyncdPatch.decode(decodeNodeContentBase64OrBytes(node.content, 'collection.patches.patch')))
+            : [];
+        const snapshotNode = findNodeChild(collectionNode, WA_NODE_TAGS.SNAPSHOT);
+        const snapshotReference = snapshotNode
+            ? proto.ExternalBlobReference.decode(decodeNodeContentBase64OrBytes(snapshotNode.content, 'collection.snapshot'))
+            : undefined;
+        payloads.push({
+            collection,
+            state,
+            version,
+            patches,
+            snapshotReference
+        });
+    }
+    return payloads;
+}
+export function parseCollectionState(node) {
+    const type = node.attrs.type;
+    const hasMorePatches = node.attrs.has_more_patches === 'true';
+    if (type !== WA_IQ_TYPES.ERROR) {
+        return hasMorePatches
+            ? WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE
+            : WA_APP_STATE_COLLECTION_STATES.SUCCESS;
+    }
+    const errorNode = findNodeChild(node, WA_NODE_TAGS.ERROR);
+    const code = errorNode?.attrs.code;
+    if (code === WA_APP_STATE_ERROR_CODES.CONFLICT) {
+        return hasMorePatches
+            ? WA_APP_STATE_COLLECTION_STATES.CONFLICT_HAS_MORE
+            : WA_APP_STATE_COLLECTION_STATES.CONFLICT;
+    }
+    if (code === WA_APP_STATE_ERROR_CODES.BAD_REQUEST ||
+        code === WA_APP_STATE_ERROR_CODES.NOT_FOUND) {
+        return WA_APP_STATE_COLLECTION_STATES.ERROR_FATAL;
+    }
+    return WA_APP_STATE_COLLECTION_STATES.ERROR_RETRY;
+}

package/dist/esm/appstate/constants.js

@@ -0,0 +1,20 @@
+import { WA_APP_STATE_COLLECTIONS } from '../protocol/constants.js';
+export const APP_STATE_DERIVED_KEY_LENGTH = 160;
+export const APP_STATE_DERIVED_INDEX_KEY_END = 32;
+export const APP_STATE_DERIVED_VALUE_ENCRYPTION_KEY_END = 64;
+export const APP_STATE_DERIVED_VALUE_MAC_KEY_END = 96;
+export const APP_STATE_DERIVED_SNAPSHOT_MAC_KEY_END = 128;
+export const APP_STATE_DERIVED_PATCH_MAC_KEY_END = 160;
+export const APP_STATE_VALUE_MAC_LENGTH = 32;
+export const APP_STATE_MAC_OCTET_LENGTH = 8;
+export const APP_STATE_IV_LENGTH = 16;
+export const APP_STATE_LT_HASH_SIZE = 128;
+export const APP_STATE_POINT_SIZE = 2;
+export const APP_STATE_EMPTY_LT_HASH = new Uint8Array(APP_STATE_LT_HASH_SIZE);
+export const APP_STATE_DEFAULT_COLLECTIONS = [
+    WA_APP_STATE_COLLECTIONS.CRITICAL_UNBLOCK_LOW,
+    WA_APP_STATE_COLLECTIONS.CRITICAL_BLOCK,
+    WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
+    WA_APP_STATE_COLLECTIONS.REGULAR,
+    WA_APP_STATE_COLLECTIONS.REGULAR_HIGH
+];

package/dist/esm/appstate/index.js

@@ -0,0 +1,6 @@
+export * from './constants.js';
+export * from './utils.js';
+export { WaAppStateCrypto } from './WaAppStateCrypto.js';
+export { WaAppStateMissingKeyError } from './WaAppStateSyncClient.js';
+export { parseCollectionState, parseSyncResponse } from './WaAppStateSyncResponseParser.js';
+export { WaAppStateSyncClient } from './WaAppStateSyncClient.js';

package/dist/esm/appstate/store/sqlite.js

@@ -0,0 +1,49 @@
+import { proto } from '../../proto.js';
+import { asBytes, asNumber, asOptionalBytes, asString } from '../../util/coercion.js';
+export function encodeAppStateFingerprint(fingerprint) {
+    if (!fingerprint) {
+        return null;
+    }
+    return proto.Message.AppStateSyncKeyFingerprint.encode(fingerprint).finish();
+}
+export function decodeAppStateFingerprint(raw) {
+    const bytes = asOptionalBytes(raw, 'appstate_sync_keys.fingerprint');
+    if (!bytes) {
+        return undefined;
+    }
+    try {
+        return 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}`);
+    }
+}
+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)
+    }));
+}
+export function decodeAppStateCollections(versionRows, valueRows) {
+    const valueMapByCollection = new Map();
+    for (const row of valueRows) {
+        const collection = asString(row.collection, 'appstate_collection_index_values.collection');
+        const byIndex = valueMapByCollection.get(collection) ?? {};
+        byIndex[asString(row.index_mac_hex, 'appstate_collection_index_values.index_mac_hex')] =
+            asBytes(row.value_mac, 'appstate_collection_index_values.value_mac');
+        valueMapByCollection.set(collection, byIndex);
+    }
+    const collections = {};
+    for (const row of versionRows) {
+        const collection = asString(row.collection, 'appstate_collection_versions.collection');
+        collections[collection] = {
+            version: asNumber(row.version, 'appstate_collection_versions.version'),
+            hash: asBytes(row.hash, 'appstate_collection_versions.hash'),
+            indexValueMap: valueMapByCollection.get(collection) ?? {}
+        };
+    }
+    return collections;
+}

package/dist/esm/appstate/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/appstate/utils.js

@@ -0,0 +1,75 @@
+import { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_KEY_TYPES } from '../protocol/constants.js';
+import { decodeProtoBytes } from '../util/base64.js';
+import { bytesToHex } from '../util/bytes.js';
+export function keyIdToHex(keyId) {
+    return bytesToHex(keyId);
+}
+export function parseCollectionName(value) {
+    if (!value) {
+        return null;
+    }
+    for (const collection of Object.values(WA_APP_STATE_COLLECTIONS)) {
+        if (collection === value) {
+            return collection;
+        }
+    }
+    return null;
+}
+export function keyDeviceId(keyId) {
+    if (keyId.byteLength < 6) {
+        return null;
+    }
+    return (keyId[0] << 8) | keyId[1];
+}
+export function keyEpoch(keyId) {
+    if (keyId.byteLength < 6) {
+        return -1;
+    }
+    return new DataView(keyId.buffer, keyId.byteOffset, keyId.byteLength).getUint32(2, false);
+}
+export 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;
+}
+export function toNetworkOrder64(value) {
+    const out = new Uint8Array(8);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, Math.floor(value / 4294967296), false);
+    view.setUint32(4, value >>> 0, false);
+    return out;
+}
+export async function downloadExternalBlobReference(mediaTransfer, reference) {
+    if (!reference.directPath) {
+        throw new Error('external blob reference is missing directPath');
+    }
+    const mediaKey = decodeProtoBytes(reference.mediaKey, 'external blob mediaKey');
+    const fileSha256 = decodeProtoBytes(reference.fileSha256, 'external blob fileSha256');
+    const fileEncSha256 = decodeProtoBytes(reference.fileEncSha256, 'external blob fileEncSha256');
+    return mediaTransfer.downloadAndDecrypt({
+        directPath: reference.directPath,
+        mediaType: WA_APP_STATE_KEY_TYPES.MD_APP_STATE,
+        mediaKey,
+        fileSha256,
+        fileEncSha256
+    });
+}

package/dist/esm/auth/WaAuthClient.js

@@ -0,0 +1,262 @@
+import { buildCommsConfig, loadOrCreateCredentials, persistCredentials } from './flow/WaAuthCredentialsFlow.js';
+import { WaPairingFlow } from './pairing/WaPairingFlow.js';
+import { WaQrFlow } from './pairing/WaQrFlow.js';
+import { getWaCompanionPlatformId, WA_DEFAULTS } from '../protocol/constants.js';
+import { uint8Equal } from '../util/bytes.js';
+import { toError } from '../util/primitives.js';
+import { getRuntimeOsDisplayName } from '../util/runtime.js';
+export class WaAuthClient {
+    constructor(options, deps) {
+        const deviceBrowser = options.deviceBrowser ?? WA_DEFAULTS.DEVICE_BROWSER;
+        const device = Object.freeze({
+            browser: deviceBrowser,
+            osDisplayName: options.deviceOsDisplayName ?? getRuntimeOsDisplayName(),
+            platform: options.devicePlatform ?? 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({
+            logger: this.logger,
+            getCredentials: () => this.credentials,
+            getDevicePlatform: () => device.platform,
+            emitQr: (qr, ttlMs) => this.callbacks.onQr?.(qr, ttlMs)
+        });
+        this.pairingFlow = new 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 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 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 && 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 &&
+                        !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(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 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);
+    }
+}

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

@@ -0,0 +1,118 @@
+import { randomBytesAsync } from '../../crypto/index.js';
+import { toSerializedPubKey } from '../../crypto/core/keys.js';
+import { X25519 } from '../../crypto/curves/X25519.js';
+import { getLoginIdentity } from '../../protocol/jid.js';
+import { verifySignalSignature } from '../../signal/crypto/WaAdvSignature.js';
+import { createAndStoreInitialKeys } from '../../signal/registration/utils.js';
+import { toError } from '../../util/primitives.js';
+export 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;
+}
+export async function persistCredentials(args, credentials) {
+    args.logger.trace('persisting auth credentials', {
+        registered: credentials.meJid !== null && credentials.meJid !== undefined
+    });
+    await args.authStore.save(credentials);
+}
+export function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
+    const registered = credentials.meJid !== null && credentials.meJid !== undefined;
+    const loginIdentity = registered ? 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.generateKeyPair(),
+        createAndStoreInitialKeys(signalStore),
+        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 = toSerializedPubKey(credentials.signedPreKey.keyPair.pubKey);
+        const valid = await 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: 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);
+}

package/dist/esm/auth/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export { getLoginIdentity } from '../protocol/jid.js';
+export { WaAuthClient } from './WaAuthClient.js';
+export { completeCompanionFinish, createCompanionHello } from './pairing/WaPairingCodeCrypto.js';
+export { WaAuthSqliteStore } from '../store/providers/sqlite/auth.store.js';