zapo-js 0.2.0 → 1.0.0

package/dist/appstate-spec.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WA_APPSTATE_SCHEMA_BY_ACTION_NAME = exports.WA_APPSTATE_SCHEMAS = exports.WA_APPSTATE_COLLECTIONS = void 0;
+exports.getAppstateSchemaByActionName = getAppstateSchemaByActionName;
+exports.resolveEnumObject = resolveEnumObject;
+exports.encodeEnumValue = encodeEnumValue;
+exports.decodeEnumValue = decodeEnumValue;
+exports.decodeIndexArgsFromSchema = decodeIndexArgsFromSchema;
+const _proto_1 = require("./proto.js");
+const appstate_1 = require("../spec/appstate");
+var appstate_2 = require("../spec/appstate");
+Object.defineProperty(exports, "WA_APPSTATE_COLLECTIONS", { enumerable: true, get: function () { return appstate_2.WA_APPSTATE_COLLECTIONS; } });
+Object.defineProperty(exports, "WA_APPSTATE_SCHEMAS", { enumerable: true, get: function () { return appstate_2.WA_APPSTATE_SCHEMAS; } });
+const SCHEMA_BY_ACTION_NAME_BUILDER = {};
+for (const key of Object.keys(appstate_1.WA_APPSTATE_SCHEMAS)) {
+    SCHEMA_BY_ACTION_NAME_BUILDER[appstate_1.WA_APPSTATE_SCHEMAS[key].name] = key;
+}
+exports.WA_APPSTATE_SCHEMA_BY_ACTION_NAME = Object.freeze(SCHEMA_BY_ACTION_NAME_BUILDER);
+function getAppstateSchemaByActionName(actionName) {
+    const key = exports.WA_APPSTATE_SCHEMA_BY_ACTION_NAME[actionName];
+    if (!key) {
+        return null;
+    }
+    return { key, schema: appstate_1.WA_APPSTATE_SCHEMAS[key] };
+}
+function resolveEnumObject(protoEnumPath) {
+    const segments = protoEnumPath.split('.');
+    let cursor = _proto_1.proto.SyncActionValue;
+    for (const seg of segments) {
+        if (cursor === null || cursor === undefined)
+            return null;
+        if (typeof cursor !== 'object' && typeof cursor !== 'function')
+            return null;
+        cursor = cursor[seg];
+    }
+    if (cursor === null || cursor === undefined)
+        return null;
+    if (typeof cursor !== 'object' && typeof cursor !== 'function')
+        return null;
+    return cursor;
+}
+function encodeEnumValue(protoEnumPath, name) {
+    const enumObj = resolveEnumObject(protoEnumPath);
+    if (!enumObj)
+        return null;
+    const value = enumObj[name];
+    return typeof value === 'number' ? value : null;
+}
+function decodeEnumValue(protoEnumPath, value) {
+    const enumObj = resolveEnumObject(protoEnumPath);
+    if (!enumObj)
+        return null;
+    for (const key of Object.keys(enumObj)) {
+        if (enumObj[key] === value)
+            return key;
+    }
+    return null;
+}
+function decodeIndexArgsFromSchema(schema, parts) {
+    if (parts.length !== schema.indexParts.length) {
+        return null;
+    }
+    const args = {};
+    for (let i = 0; i < schema.indexParts.length; i += 1) {
+        const part = schema.indexParts[i];
+        const raw = parts[i];
+        if (part.type === 'literal') {
+            continue;
+        }
+        if (part.type === 'boolString') {
+            if (raw !== '0' && raw !== '1')
+                return null;
+            args[part.name] = raw === '1';
+            continue;
+        }
+        if (part.type === 'jidOrZero') {
+            args[part.name] = raw === '0' ? null : raw;
+            continue;
+        }
+        if (part.type === 'enum') {
+            const numeric = Number(raw);
+            const name = Number.isFinite(numeric) ? decodeEnumValue(part.protoEnum, numeric) : null;
+            args[part.name] = name ?? raw;
+            continue;
+        }
+        args[part.name] = raw;
+    }
+    return args;
+}

package/dist/auth/WaAuthClient.js

@@ -1,15 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaAuthClient = void 0;
-const WaAuthCredentialsFlow_1 = require("./flow/WaAuthCredentialsFlow");
+const credentials_flow_1 = require("./credentials-flow");
 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");
+/**
+ * Owns the auth/pairing lifecycle and persistence of {@link WaAuthCredentials}.
+ * Exposed as `client.auth` on a {@link WaClient}.
+ *
+ * Lifecycle: construct with options + dependencies, call
+ * {@link loadOrCreateCredentials} to bring credentials online, then either
+ * follow the QR flow (`onQr` callback) or call {@link requestPairingCode} for
+ * the link-code flow.
+ */
 class WaAuthClient {
     constructor(options, deps) {
+        this.versionOverride = null;
         const deviceBrowser = options.deviceBrowser ?? constants_1.WA_DEFAULTS.DEVICE_BROWSER;
         const device = Object.freeze({
             browser: deviceBrowser,
@@ -27,6 +37,8 @@ class WaAuthClient {
         this.callbacks = deps.callbacks ?? {};
         this.authStore = deps.authStore;
         this.signalStore = deps.signalStore;
+        this.preKeyStore = deps.preKeyStore;
+        this.isConnected = deps.isConnected;
         this.credentials = null;
         this.qrFlow = new WaQrFlow_1.WaQrFlow({
             logger: this.logger,
@@ -47,9 +59,14 @@ class WaAuthClient {
                 emitPairingCode: (code) => this.callbacks.onPairingCode?.(code),
                 emitPairingRefresh: (forceManual) => this.callbacks.onPairingRefresh?.(forceManual),
                 emitPaired: (credentials) => this.callbacks.onPaired?.(credentials)
-            }
+            },
+            dangerous: options.dangerous
         });
     }
+    /**
+     * Returns a snapshot of auth readiness flags (connection, registration,
+     * pending QR/pairing prompts).
+     */
     getState(connected = false) {
         return {
             connected,
@@ -58,16 +75,23 @@ class WaAuthClient {
             hasPairingCode: this.pairingFlow.hasPairingSession()
         };
     }
+    /** Returns the currently-loaded credentials, or `null` before initialization. */
     getCurrentCredentials() {
         return this.credentials;
     }
+    /**
+     * Loads persisted credentials from the auth store, or generates a fresh
+     * set when none exist. Must be called before connecting.
+     */
     async loadOrCreateCredentials() {
         return this.runHandled(async () => {
             this.logger.debug('auth client loadOrCreateCredentials start');
-            this.credentials = await (0, WaAuthCredentialsFlow_1.loadOrCreateCredentials)({
+            this.credentials = await (0, credentials_flow_1.loadOrCreateCredentials)({
                 logger: this.logger,
                 authStore: this.authStore,
-                signalStore: this.signalStore
+                signalStore: this.signalStore,
+                preKeyStore: this.preKeyStore,
+                skipSignedPreKeySignatureVerification: this.options.dangerous?.disableSignedPreKeySignatureVerification
             });
             this.logger.info('auth client credentials ready', {
                 registered: this.credentials?.meJid !== null && this.credentials?.meJid !== undefined
@@ -75,25 +99,56 @@ class WaAuthClient {
             return this.credentials;
         });
     }
-    buildCommsConfig(socketOptions) {
+    /**
+     * Builds a {@link WaCommsConfig} from the current credentials and the
+     * runtime device/transport options – feeds {@link WaComms}.
+     */
+    async buildCommsConfig(socketOptions, overrides = {}) {
         this.logger.trace('auth client building comms config');
-        return (0, WaAuthCredentialsFlow_1.buildCommsConfig)(this.logger, this.requireCredentials(), socketOptions, {
+        const override = this.versionOverride;
+        this.versionOverride = null;
+        return (0, credentials_flow_1.buildCommsConfig)(this.logger, this.requireCredentials(), socketOptions, {
             deviceBrowser: this.options.deviceBrowser,
             deviceOsDisplayName: this.options.deviceOsDisplayName,
             requireFullSync: this.options.requireFullSync,
-            version: this.options.version
+            version: override ?? this.options.version,
+            mobileTransport: this.options.mobileTransport,
+            noiseTrustedRootCa: overrides.noiseTrustedRootCa,
+            disableNoiseCertificateChainVerification: overrides.disableNoiseCertificateChainVerification ??
+                this.options.dangerous?.disableNoiseCertificateChainVerification
         });
     }
+    /**
+     * One-shot override for the next {@link buildCommsConfig} call: takes
+     * precedence over the user-supplied `version` option, then clears. Used
+     * by the `recoverFromClientTooOld` auto-retry to inject a fresh version
+     * string fetched from `web.whatsapp.com` without mutating the user's
+     * options.
+     */
+    setNextConnectVersion(version) {
+        this.versionOverride = version;
+    }
+    /** Clears the in-memory QR and pairing sessions without touching storage. */
+    // eslint-disable-next-line @typescript-eslint/require-await
     async clearTransientState() {
         this.logger.trace('auth client clear transient state');
         this.qrFlow.clear();
         this.pairingFlow.clearSession();
     }
+    /**
+     * Wipes credentials from memory **and** from the auth store. Does
+     * **not** touch the other store domains (signal, app-state, ...) -
+     * those are cleared separately when {@link WaClient.logout} triggers
+     * the server-side logout path, honoring `options.logoutStoreClear`.
+     * Call this manually only when you want to force a re-pair without
+     * going through the server logout IQ.
+     */
     async clearStoredCredentials() {
         this.logger.warn('auth client clearing stored credentials');
         this.credentials = null;
         await Promise.all([this.authStore.clear(), this.clearTransientState()]);
     }
+    /** Stores the server's noise static key for subsequent handshakes. */
     async persistServerStaticKey(serverStaticKey) {
         this.logger.debug('persisting server static key', {
             keyLength: serverStaticKey.byteLength
@@ -103,6 +158,7 @@ class WaAuthClient {
             serverStaticKey
         }));
     }
+    /** Stores the "server holds prekeys" flag; persists only when the value changes. */
     async persistServerHasPreKeys(serverHasPreKeys) {
         await this.patchCredentials((credentials) => ({
             ...credentials,
@@ -116,6 +172,10 @@ class WaAuthClient {
             }
         });
     }
+    /**
+     * Stores the routing-info blob received from the server. Skips persistence
+     * when the value matches the one already on disk.
+     */
     async persistRoutingInfo(routingInfo) {
         this.logger.trace('persisting routing info', {
             byteLength: routingInfo.byteLength
@@ -133,6 +193,7 @@ class WaAuthClient {
             }
         });
     }
+    /** Clears the persisted routing-info blob (used after a routing error). */
     async clearRoutingInfo() {
         return this.patchCredentials((credentials) => ({
             ...credentials,
@@ -144,6 +205,11 @@ class WaAuthClient {
             }
         });
     }
+    /**
+     * Persists the per-connection success attributes from the server (LID,
+     * display name, companion key, last-success ts, props versions, ...). Only
+     * persists when at least one attribute actually changed.
+     */
     async persistSuccessAttributes(attributes) {
         let persistDiff;
         const computeDiff = (current, next) => ({
@@ -180,24 +246,56 @@ class WaAuthClient {
             }
         });
     }
-    async requestPairingCode(phoneNumber, shouldShowPushNotification = false) {
+    /**
+     * Requests an 8-character pairing code for `phoneNumber` (link-code flow).
+     * Pass `customCode` to suggest a specific code; the server still validates
+     * and may return a different one.
+     *
+     * The client must already be connected – kick off `WaClient.connect()` in
+     * parallel, wait for the `auth_pairing_required` event (or any QR), then
+     * call this. The user then enters the returned code in WhatsApp on their
+     * phone under *Linked Devices → Link with phone number instead*.
+     *
+     * @example
+     * ```ts
+     * // Start the handshake; do NOT await – connect() resolves only after pairing
+     * void client.connect()
+     *
+     * // Wait until the pairing screen is ready on the server side
+     * await new Promise<void>((resolve) => client.once('auth_pairing_required', () => resolve()))
+     *
+     * // Phone number in international format, digits only
+     * const code = await client.auth.requestPairingCode('5511999999999')
+     * console.log(`enter this on your phone: ${code.match(/.{1,4}/g)!.join('-')}`)
+     *
+     * // The `connect()` promise resolves after the user types the code:
+     * await new Promise<void>((resolve) => client.once('auth_paired', () => resolve()))
+     * ```
+     */
+    async requestPairingCode(phoneNumber, shouldShowPushNotification = true, customCode) {
+        this.requireConnected();
         this.requireCredentials();
-        this.logger.info('auth client requesting pairing code');
-        return this.runHandled(() => this.pairingFlow.requestPairingCode(phoneNumber, shouldShowPushNotification));
+        this.logger.debug('auth client requesting pairing code');
+        return this.runHandled(() => this.pairingFlow.requestPairingCode(phoneNumber, shouldShowPushNotification, customCode));
     }
+    /** Fetches the ISO country code the server resolved for the current account. */
     async fetchPairingCountryCodeIso() {
+        this.requireConnected();
         this.requireCredentials();
         this.logger.trace('auth client fetching pairing country code ISO');
         return this.runHandled(() => this.pairingFlow.fetchPairingCountryCodeIso());
     }
+    /** Dispatcher: returns `true` when `node` is a pairing-related IQ-set we handled. */
     async handleIncomingIqSet(node) {
         this.logger.trace('auth client handleIncomingIqSet', { id: node.attrs.id });
         return this.runHandled(() => this.pairingFlow.handleIncomingIqSet(node));
     }
+    /** Dispatcher: returns `true` when `node` is a link-code companion notification. */
     async handleLinkCodeNotification(node) {
         this.logger.trace('auth client handleLinkCodeNotification', { id: node.attrs.id });
         return this.runHandled(() => this.pairingFlow.handleLinkCodeNotification(node));
     }
+    /** Dispatcher: returns `true` when `node` is a companion-registration refresh notification. */
     async handleCompanionRegRefreshNotification(node) {
         this.logger.trace('auth client handleCompanionRegRefreshNotification', {
             id: node.attrs.id
@@ -225,15 +323,21 @@ class WaAuthClient {
     }
     async updateCredentials(credentials) {
         this.logger.trace('auth client update credentials', {
-            registered: credentials?.meJid !== null && credentials?.meJid !== undefined
+            registered: !!credentials?.meJid
         });
         this.credentials = credentials;
-        await (0, WaAuthCredentialsFlow_1.persistCredentials)({
+        await (0, credentials_flow_1.persistCredentials)({
             logger: this.logger,
             authStore: this.authStore,
-            signalStore: this.signalStore
+            signalStore: this.signalStore,
+            preKeyStore: this.preKeyStore
         }, credentials);
     }
+    requireConnected() {
+        if (this.isConnected && !this.isConnected()) {
+            throw new Error('client is not connected');
+        }
+    }
     requireCredentials() {
         if (!this.credentials) {
             throw new Error('credentials are not initialized');

package/dist/auth/credentials-flow.js

@@ -0,0 +1,207 @@
+"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 _signal_1 = require("../signal/index.js");
+const WaMobileTcpSocket_1 = require("../transport/node/WaMobileTcpSocket");
+const WaMobileClientPayload_1 = require("../transport/noise/WaMobileClientPayload");
+const proxy_1 = require("../transport/proxy");
+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 createFreshAndPersistCredentials(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
+    });
+    const skipSignedPreKeyCheck = args.skipSignedPreKeySignatureVerification === true;
+    if (!existing.meJid &&
+        !skipSignedPreKeyCheck &&
+        !(await hasValidSignedPreKey(args.logger, existing))) {
+        args.logger.warn('signed pre-key is invalid, regenerating credentials');
+        const fresh = await createFreshAndPersistCredentials(args);
+        args.logger.info('regenerated credentials due to invalid signed pre-key');
+        return fresh;
+    }
+    await restoreSignalStore(args.signalStore, args.preKeyStore, 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 mobileTransportFromCredentials(credentials) {
+    if (!credentials.deviceInfo)
+        return undefined;
+    return {
+        deviceInfo: credentials.deviceInfo,
+        ...(credentials.pushName !== undefined ? { pushName: credentials.pushName } : {}),
+        ...(credentials.yearClass !== undefined ? { yearClass: credentials.yearClass } : {}),
+        ...(credentials.memClass !== undefined ? { memClass: credentials.memClass } : {})
+    };
+}
+async function resolveVersion(version) {
+    if (version === undefined)
+        return undefined;
+    if (typeof version === 'string')
+        return version;
+    const resolved = await version();
+    if (typeof resolved !== 'string' || resolved.length === 0) {
+        throw new Error('version resolver returned a non-string value');
+    }
+    return resolved;
+}
+async function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
+    const meJid = credentials.meJid;
+    const registered = meJid !== null && meJid !== undefined;
+    const loginIdentity = registered ? (0, jid_1.getLoginIdentity)(meJid) : null;
+    const wsProxy = socketOptions.proxy?.ws;
+    // Resolve the effective mobile transport: explicit option wins, otherwise
+    // synthesize one from persisted credentials.deviceInfo so a registered
+    // mobile session boots in mobile mode without the caller re-passing
+    // deviceInfo on every `new WaClient(...)` call.
+    const effectiveMobileTransport = clientOptions.mobileTransport ?? mobileTransportFromCredentials(credentials);
+    logger.debug('building comms config from credentials', {
+        registered,
+        hasServerStaticKey: credentials.serverStaticKey !== null && credentials.serverStaticKey !== undefined,
+        mobile: Boolean(effectiveMobileTransport),
+        mobileSource: clientOptions.mobileTransport
+            ? 'option'
+            : effectiveMobileTransport
+                ? 'credentials'
+                : 'none'
+    });
+    if (effectiveMobileTransport) {
+        if (wsProxy) {
+            throw new Error('mobileTransport does not support socketOptions.proxy.ws – remove the proxy option or open an issue to add TCP proxy support');
+        }
+        if (!loginIdentity) {
+            throw new Error('mobileTransport requires registered credentials (meJid) – run the mobile bridge flow first');
+        }
+        const loginPayload = (0, WaMobileClientPayload_1.buildMobileLoginPayload)({
+            username: loginIdentity.username,
+            device: loginIdentity.device,
+            passive: effectiveMobileTransport.passive ?? false,
+            deviceInfo: effectiveMobileTransport.deviceInfo,
+            pushName: effectiveMobileTransport.pushName,
+            yearClass: effectiveMobileTransport.yearClass,
+            memClass: effectiveMobileTransport.memClass
+        });
+        return {
+            url: effectiveMobileTransport.tcpUrl ?? 'tcp://g.whatsapp.net:443',
+            rawWebSocketConstructor: WaMobileTcpSocket_1.WaMobileTcpSocketCtor,
+            connectTimeoutMs: socketOptions.connectTimeoutMs,
+            reconnectIntervalMs: socketOptions.reconnectIntervalMs,
+            timeoutIntervalMs: socketOptions.timeoutIntervalMs,
+            maxReconnectAttempts: socketOptions.maxReconnectAttempts,
+            noise: {
+                clientStaticKeyPair: credentials.noiseKeyPair,
+                isRegistered: true,
+                serverStaticKey: credentials.serverStaticKey,
+                routingInfo: credentials.routingInfo,
+                trustedRootCa: clientOptions.noiseTrustedRootCa,
+                verifyCertificateChain: clientOptions.disableNoiseCertificateChainVerification
+                    ? false
+                    : undefined,
+                loginPayload
+            }
+        };
+    }
+    const versionBase = await resolveVersion(clientOptions.version);
+    return {
+        url: socketOptions.url,
+        urls: socketOptions.urls,
+        protocols: socketOptions.protocols,
+        dispatcher: (0, proxy_1.toProxyDispatcher)(wsProxy),
+        agent: (0, proxy_1.toProxyAgent)(wsProxy),
+        connectTimeoutMs: socketOptions.connectTimeoutMs,
+        reconnectIntervalMs: socketOptions.reconnectIntervalMs,
+        timeoutIntervalMs: socketOptions.timeoutIntervalMs,
+        maxReconnectAttempts: socketOptions.maxReconnectAttempts,
+        noise: {
+            clientStaticKeyPair: credentials.noiseKeyPair,
+            isRegistered: registered,
+            serverStaticKey: credentials.serverStaticKey,
+            routingInfo: credentials.routingInfo,
+            trustedRootCa: clientOptions.noiseTrustedRootCa,
+            verifyCertificateChain: clientOptions.disableNoiseCertificateChainVerification
+                ? false
+                : undefined,
+            loginPayloadConfig: loginIdentity
+                ? {
+                    username: loginIdentity.username,
+                    device: loginIdentity.device,
+                    deviceBrowser: clientOptions.deviceBrowser,
+                    deviceOsDisplayName: clientOptions.deviceOsDisplayName,
+                    versionBase
+                }
+                : undefined,
+            registrationPayloadConfig: !loginIdentity
+                ? {
+                    registrationInfo: credentials.registrationInfo,
+                    signedPreKey: credentials.signedPreKey,
+                    deviceBrowser: clientOptions.deviceBrowser,
+                    deviceOsDisplayName: clientOptions.deviceOsDisplayName,
+                    requireFullSync: clientOptions.requireFullSync,
+                    versionBase
+                }
+                : undefined
+        }
+    };
+}
+async function createFreshCredentials(signalStore, preKeyStore, logger) {
+    logger.trace('creating fresh credentials');
+    const [noiseKeyPair, registrationBundle, advSecretKey] = await Promise.all([
+        X25519_1.X25519.generateKeyPair(),
+        (0, _signal_1.createAndStoreInitialKeys)(signalStore, preKeyStore),
+        (0, _crypto_1.randomBytesAsync)(32)
+    ]);
+    return {
+        noiseKeyPair,
+        registrationInfo: registrationBundle.registrationInfo,
+        signedPreKey: registrationBundle.signedPreKey,
+        serverHasPreKeys: false,
+        advSecretKey
+    };
+}
+async function createFreshAndPersistCredentials(args) {
+    const credentials = await createFreshCredentials(args.signalStore, args.preKeyStore, 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, args.preKeyStore, credentials);
+    return credentials;
+}
+async function hasValidSignedPreKey(logger, credentials) {
+    try {
+        const serializedPubKey = (0, keys_1.toSerializedPubKey)(credentials.signedPreKey.keyPair.pubKey);
+        const valid = await (0, _crypto_1.xeddsaVerify)((0, _crypto_1.toRawPubKey)(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, preKeyStore, credentials) {
+    await Promise.all([
+        signalStore.setRegistrationInfo(credentials.registrationInfo),
+        signalStore.setSignedPreKey(credentials.signedPreKey),
+        preKeyStore.setServerHasPreKeys(credentials.serverHasPreKeys === true)
+    ]);
+}