zapo-js 0.3.0 → 1.0.0

package/dist/auth/WaAuthClient.js

@@ -8,8 +8,18 @@ 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,
@@ -28,6 +38,7 @@ class WaAuthClient {
         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,
@@ -52,6 +63,10 @@ class WaAuthClient {
             dangerous: options.dangerous
         });
     }
+    /**
+     * Returns a snapshot of auth readiness flags (connection, registration,
+     * pending QR/pairing prompts).
+     */
     getState(connected = false) {
         return {
             connected,
@@ -60,9 +75,14 @@ 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');
@@ -79,29 +99,56 @@ class WaAuthClient {
             return this.credentials;
         });
     }
-    buildCommsConfig(socketOptions, overrides = {}) {
+    /**
+     * 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');
+        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
@@ -111,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,
@@ -124,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
@@ -141,6 +193,7 @@ class WaAuthClient {
             }
         });
     }
+    /** Clears the persisted routing-info blob (used after a routing error). */
     async clearRoutingInfo() {
         return this.patchCredentials((credentials) => ({
             ...credentials,
@@ -152,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) => ({
@@ -188,24 +246,56 @@ class WaAuthClient {
             }
         });
     }
-    async requestPairingCode(phoneNumber, shouldShowPushNotification = false, customCode) {
+    /**
+     * 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');
+        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
@@ -233,7 +323,7 @@ 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, credentials_flow_1.persistCredentials)({
@@ -243,6 +333,11 @@ class WaAuthClient {
             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

@@ -7,7 +7,7 @@ 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 utils_1 = require("../signal/registration/utils");
+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");
@@ -53,7 +53,18 @@ function mobileTransportFromCredentials(credentials) {
         ...(credentials.memClass !== undefined ? { memClass: credentials.memClass } : {})
     };
 }
-function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
+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;
@@ -75,10 +86,10 @@ function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
     });
     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');
+            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');
+            throw new Error('mobileTransport requires registered credentials (meJid) – run the mobile bridge flow first');
         }
         const loginPayload = (0, WaMobileClientPayload_1.buildMobileLoginPayload)({
             username: loginIdentity.username,
@@ -109,6 +120,7 @@ function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
             }
         };
     }
+    const versionBase = await resolveVersion(clientOptions.version);
     return {
         url: socketOptions.url,
         urls: socketOptions.urls,
@@ -134,7 +146,7 @@ function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
                     device: loginIdentity.device,
                     deviceBrowser: clientOptions.deviceBrowser,
                     deviceOsDisplayName: clientOptions.deviceOsDisplayName,
-                    versionBase: clientOptions.version
+                    versionBase
                 }
                 : undefined,
             registrationPayloadConfig: !loginIdentity
@@ -144,7 +156,7 @@ function buildCommsConfig(logger, credentials, socketOptions, clientOptions) {
                     deviceBrowser: clientOptions.deviceBrowser,
                     deviceOsDisplayName: clientOptions.deviceOsDisplayName,
                     requireFullSync: clientOptions.requireFullSync,
-                    versionBase: clientOptions.version
+                    versionBase
                 }
                 : undefined
         }
@@ -154,7 +166,7 @@ async function createFreshCredentials(signalStore, preKeyStore, logger) {
     logger.trace('creating fresh credentials');
     const [noiseKeyPair, registrationBundle, advSecretKey] = await Promise.all([
         X25519_1.X25519.generateKeyPair(),
-        (0, utils_1.createAndStoreInitialKeys)(signalStore, preKeyStore),
+        (0, _signal_1.createAndStoreInitialKeys)(signalStore, preKeyStore),
         (0, _crypto_1.randomBytesAsync)(32)
     ]);
     return {

package/dist/auth/pairing/WaPairingFlow.js

@@ -7,7 +7,7 @@ const _proto_1 = require("../../proto.js");
 const browser_1 = require("../../protocol/browser");
 const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
-const WaAdvSignature_1 = require("../../signal/crypto/WaAdvSignature");
+const WaAdvSignature_1 = require("../../signal/attestation/WaAdvSignature");
 const global_1 = require("../../transport/node/builders/global");
 const pairing_1 = require("../../transport/node/builders/pairing");
 const helpers_1 = require("../../transport/node/helpers");
@@ -24,7 +24,7 @@ class WaPairingFlow {
         this.opts.logger.trace('pairing flow session cleared');
         this.pairingSession = null;
     }
-    async requestPairingCode(phoneNumber, shouldShowPushNotification = false, customCode) {
+    async requestPairingCode(phoneNumber, shouldShowPushNotification = true, customCode) {
         this.opts.logger.info('requesting pairing code', {
             shouldShowPushNotification,
             hasCustomCode: customCode !== undefined
@@ -68,7 +68,7 @@ class WaPairingFlow {
             finished: false
         };
         this.opts.callbacks.emitPairingCode(companionHello.pairingCode);
-        this.opts.logger.info('pairing code emitted', {
+        this.opts.logger.debug('pairing code emitted', {
             phoneJid,
             createdAtSeconds: this.pairingSession.createdAtSeconds
         });
@@ -86,21 +86,19 @@ class WaPairingFlow {
         return iso;
     }
     async handleIncomingIqSet(node) {
-        this.opts.logger.trace('pairing flow received iq:set', {
-            id: node.attrs.id,
-            from: node.attrs.from
-        });
+        const iqLogger = this.opts.logger.child({ id: node.attrs.id });
+        iqLogger.trace('pairing flow received iq:set', { from: node.attrs.from });
         const firstChild = (0, helpers_1.getFirstNodeChild)(node);
         if (!firstChild) {
             return false;
         }
         if (firstChild.tag === constants_1.WA_NODE_TAGS.PAIR_DEVICE) {
-            this.opts.logger.debug('handling pair-device stanza', { id: node.attrs.id });
+            iqLogger.debug('handling pair-device stanza');
             await this.handlePairDevice(node, firstChild);
             return true;
         }
         if (firstChild.tag === constants_1.WA_NODE_TAGS.PAIR_SUCCESS) {
-            this.opts.logger.debug('handling pair-success stanza', { id: node.attrs.id });
+            iqLogger.debug('handling pair-success stanza');
             await this.handlePairSuccess(node, firstChild);
             return true;
         }
@@ -127,7 +125,7 @@ class WaPairingFlow {
             }
             const ref = (0, helpers_1.decodeNodeContentUtf8OrBytes)(refNode.content, 'refresh_code.link_code_pairing_ref');
             if ((0, bytes_1.uint8Equal)(ref, this.pairingSession.ref)) {
-                this.opts.logger.info('received pairing refresh notification', {
+                this.opts.logger.debug('received pairing refresh notification', {
                     forceManualRefresh: linkCodeNode.attrs.force_manual_refresh === 'true'
                 });
                 this.opts.callbacks.emitPairingRefresh(linkCodeNode.attrs.force_manual_refresh === 'true');
@@ -153,7 +151,7 @@ class WaPairingFlow {
             node,
             typeOverride: constants_1.WA_SIGNALING.COMPANION_REG_REFRESH_NOTIFICATION
         }));
-        this.opts.logger.info('handled companion_reg_refresh notification');
+        this.opts.logger.debug('handled companion_reg_refresh notification');
         this.opts.qrFlow.refreshCurrentQr();
         return true;
     }
@@ -163,10 +161,10 @@ class WaPairingFlow {
         await this.rotateAdvSecret(this.requireCredentials());
         await this.opts.socket.sendNode((0, global_1.buildIqResultNode)(iqNode));
         this.opts.qrFlow.setRefs(refs);
-        this.opts.logger.info('pair-device refs updated', { refsCount: refs.length });
+        this.opts.logger.debug('pair-device refs updated', { refsCount: refs.length });
     }
     async handlePairSuccess(iqNode, pairSuccessNode) {
-        this.opts.logger.info('processing pair-success node');
+        this.opts.logger.debug('processing pair-success node');
         const credentials = this.requireCredentials();
         const [deviceIdentityNode, deviceNode, platformNode] = (0, helpers_1.findNodeChildrenByTags)(pairSuccessNode, [constants_1.WA_NODE_TAGS.DEVICE_IDENTITY, 'device', constants_1.WA_NODE_TAGS.PLATFORM]);
         if (!deviceIdentityNode || !deviceNode || !platformNode) {
@@ -186,13 +184,18 @@ class WaPairingFlow {
             const hmacInput = isHosted
                 ? (0, bytes_1.concatBytes)([WaAdvSignature_1.ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, wrappedDetails])
                 : wrappedDetails;
-            const expectedHmac = await (0, WaAdvSignature_1.computeAdvIdentityHmac)(credentials.advSecretKey, hmacInput);
-            if (!(0, bytes_1.uint8Equal)(expectedHmac, wrappedHmac)) {
-                this.opts.logger.error('pair-success hmac mismatch');
+            const expectedHmac = (0, WaAdvSignature_1.computeAdvIdentityHmac)(credentials.advSecretKey, hmacInput);
+            if (!(0, bytes_1.uint8TimingSafeEqual)(expectedHmac, wrappedHmac)) {
+                this.opts.logger.error('pair-success hmac mismatch', {
+                    meJid: deviceNode.attrs.jid,
+                    meLid: deviceNode.attrs.lid,
+                    platform: platformNode.attrs.name,
+                    isHosted
+                });
                 throw new Error('pair-success HMAC validation failed');
             }
         }
-        const { signedIdentity, keyIndex, responseIdentityBytes } = await this.buildPairSuccessResponseIdentity(credentials, wrappedDetails, isHosted);
+        const { signedIdentity, keyIndex, responseIdentityBytes } = await this.buildPairSuccessResponseIdentity(credentials, wrappedDetails);
         const nextCredentials = {
             ...credentials,
             signedIdentity,
@@ -233,21 +236,25 @@ class WaPairingFlow {
         this.opts.callbacks.emitPaired(nextCredentials);
         this.opts.logger.debug('pair-success completed and paired event emitted');
     }
-    async buildPairSuccessResponseIdentity(credentials, wrappedDetails, isHosted) {
+    async buildPairSuccessResponseIdentity(credentials, wrappedDetails) {
         const signedIdentity = _proto_1.proto.ADVSignedDeviceIdentity.decode(wrappedDetails);
         const details = (0, bytes_1.decodeProtoBytes)(signedIdentity.details, 'ADVSignedDeviceIdentity.details');
         const accountSignature = (0, bytes_1.decodeProtoBytes)(signedIdentity.accountSignature, 'ADVSignedDeviceIdentity.accountSignature');
         const accountSignatureKey = (0, bytes_1.decodeProtoBytes)(signedIdentity.accountSignatureKey, 'ADVSignedDeviceIdentity.accountSignatureKey');
         const localIdentity = credentials.registrationInfo.identityKeyPair;
+        const advDeviceIdentity = _proto_1.proto.ADVDeviceIdentity.decode(details);
+        const isDeviceHosted = advDeviceIdentity.deviceType === _proto_1.proto.ADVEncryptionType.HOSTED;
         if (this.opts.dangerous?.disableAdvSignatureVerification !== true) {
-            const validAccountSignature = await (0, WaAdvSignature_1.verifyDeviceIdentityAccountSignature)(details, accountSignature, localIdentity.pubKey, accountSignatureKey, isHosted);
+            const validAccountSignature = await (0, WaAdvSignature_1.verifyDeviceIdentityAccountSignature)(details, accountSignature, localIdentity.pubKey, accountSignatureKey, isDeviceHosted);
             if (!validAccountSignature) {
-                this.opts.logger.error('pair-success account signature invalid');
+                this.opts.logger.error('pair-success account signature invalid', {
+                    keyIndex: advDeviceIdentity.keyIndex ?? 0,
+                    isDeviceHosted
+                });
                 throw new Error('pair-success account signature validation failed');
             }
         }
-        signedIdentity.deviceSignature = await (0, WaAdvSignature_1.generateDeviceSignature)(details, localIdentity, accountSignatureKey, isHosted);
-        const advDeviceIdentity = _proto_1.proto.ADVDeviceIdentity.decode(details);
+        signedIdentity.deviceSignature = await (0, WaAdvSignature_1.generateDeviceSignature)(details, localIdentity, accountSignatureKey, false);
         const responseIdentityBytes = _proto_1.proto.ADVSignedDeviceIdentity.encode({
             details: signedIdentity.details,
             accountSignature: signedIdentity.accountSignature,
@@ -283,7 +290,9 @@ class WaPairingFlow {
         }
         const ref = (0, helpers_1.decodeNodeContentUtf8OrBytes)(refNode.content, 'primary_hello.link_code_pairing_ref');
         if (!pairingSession.ref || !(0, bytes_1.uint8Equal)(ref, pairingSession.ref)) {
-            this.opts.logger.warn('primary_hello ref mismatch ignored');
+            this.opts.logger.warn('primary_hello ref mismatch ignored', {
+                phoneJid: pairingSession.phoneJid
+            });
             return;
         }
         const nowSeconds = Math.floor(Date.now() / 1000);
@@ -312,7 +321,7 @@ class WaPairingFlow {
             advSecretKey: finish.advSecret
         });
         pairingSession.finished = true;
-        this.opts.logger.info('primary_hello completed with companion_finish success');
+        this.opts.logger.debug('primary_hello completed with companion_finish success');
     }
     async rotateAdvSecret(credentials) {
         const nextCredentials = {

package/dist/auth/pairing/pairing-code-crypto.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PBKDF2_ITERATIONS = exports.CROCKFORD_ALPHABET = void 0;
+exports.PBKDF2_ITERATIONS = void 0;
 exports.normalizeCustomPairingCode = normalizeCustomPairingCode;
 exports.createCompanionHello = createCompanionHello;
 exports.completeCompanionFinish = completeCompanionFinish;
@@ -8,8 +8,9 @@ const _crypto_1 = require("../../crypto/index.js");
 const X25519_1 = require("../../crypto/curves/X25519");
 const constants_1 = require("../../protocol/constants");
 const bytes_1 = require("../../util/bytes");
-exports.CROCKFORD_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTVWXYZ';
+const CROCKFORD_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTVWXYZ';
 exports.PBKDF2_ITERATIONS = 2 << 16;
+const PAIRING_AES_KEY_BYTES = 32;
 function bytesToCrockford(bytes) {
     let bitCount = 0;
     let value = 0;
@@ -18,12 +19,12 @@ function bytesToCrockford(bytes) {
         value = (value << 8) | bytes[i];
         bitCount += 8;
         while (bitCount >= 5) {
-            out += exports.CROCKFORD_ALPHABET[(value >>> (bitCount - 5)) & 31];
+            out += CROCKFORD_ALPHABET[(value >>> (bitCount - 5)) & 31];
             bitCount -= 5;
         }
     }
     if (bitCount > 0) {
-        out += exports.CROCKFORD_ALPHABET[(value << (5 - bitCount)) & 31];
+        out += CROCKFORD_ALPHABET[(value << (5 - bitCount)) & 31];
     }
     return out;
 }
@@ -33,8 +34,8 @@ function normalizeCustomPairingCode(input) {
         throw new Error(`custom pairing code must be 8 characters, got ${stripped.length}`);
     }
     for (let i = 0; i < stripped.length; i += 1) {
-        if (exports.CROCKFORD_ALPHABET.indexOf(stripped[i]) < 0) {
-            throw new Error(`custom pairing code contains invalid character "${stripped[i]}" (allowed: ${exports.CROCKFORD_ALPHABET})`);
+        if (CROCKFORD_ALPHABET.indexOf(stripped[i]) < 0) {
+            throw new Error(`custom pairing code contains invalid character "${stripped[i]}" (allowed: ${CROCKFORD_ALPHABET})`);
         }
     }
     return stripped;
@@ -48,8 +49,8 @@ async function createCompanionHello(options = {}) {
         normalizedCustomCode !== null ? Promise.resolve(null) : (0, _crypto_1.randomBytesAsync)(5)
     ]);
     const pairingCode = normalizedCustomCode ?? bytesToCrockford(codeBytes);
-    const cipher = await (0, _crypto_1.pbkdf2DeriveAesCtrKey)(bytes_1.TEXT_ENCODER.encode(pairingCode), salt, exports.PBKDF2_ITERATIONS);
-    const encrypted = await (0, _crypto_1.aesCtrEncrypt)(cipher, counter, companionEphemeralKeyPair.pubKey);
+    const cipherKey = await (0, _crypto_1.pbkdf2Sha256)(bytes_1.TEXT_ENCODER.encode(pairingCode), salt, exports.PBKDF2_ITERATIONS, PAIRING_AES_KEY_BYTES);
+    const encrypted = (0, _crypto_1.aesCtrEncrypt)(cipherKey, counter, companionEphemeralKeyPair.pubKey);
     return {
         pairingCode,
         companionEphemeralKeyPair,
@@ -60,31 +61,28 @@ async function completeCompanionFinish(args) {
     if (args.wrappedPrimaryEphemeralPub.length <= 48) {
         throw new Error('invalid wrapped primary payload');
     }
-    const pairingCipher = await (0, _crypto_1.pbkdf2DeriveAesCtrKey)(bytes_1.TEXT_ENCODER.encode(args.pairingCode), args.wrappedPrimaryEphemeralPub.subarray(0, 32), exports.PBKDF2_ITERATIONS);
-    const primaryEphemeralPub = await (0, _crypto_1.aesCtrDecrypt)(pairingCipher, args.wrappedPrimaryEphemeralPub.subarray(32, 48), args.wrappedPrimaryEphemeralPub.subarray(48));
+    const pairingCipherKey = await (0, _crypto_1.pbkdf2Sha256)(bytes_1.TEXT_ENCODER.encode(args.pairingCode), args.wrappedPrimaryEphemeralPub.subarray(0, 32), exports.PBKDF2_ITERATIONS, PAIRING_AES_KEY_BYTES);
+    const primaryEphemeralPub = (0, _crypto_1.aesCtrDecrypt)(pairingCipherKey, args.wrappedPrimaryEphemeralPub.subarray(32, 48), args.wrappedPrimaryEphemeralPub.subarray(48));
     if (primaryEphemeralPub.length === 0) {
         throw new Error('empty primary ephemeral public key');
     }
-    const [sharedEphemeral, bundleSalt, bundleSecret, bundleIv] = await Promise.all([
+    const [sharedEphemeral, sharedIdentity, bundleSalt, bundleSecret, bundleIv] = await Promise.all([
         X25519_1.X25519.scalarMult(args.companionEphemeralPrivKey, primaryEphemeralPub),
+        X25519_1.X25519.scalarMult(args.registrationIdentityKeyPair.privKey, args.primaryIdentityPub),
         (0, _crypto_1.randomBytesAsync)(32),
         (0, _crypto_1.randomBytesAsync)(32),
         (0, _crypto_1.randomBytesAsync)(12)
     ]);
-    const bundleEncryptionKeyRaw = await (0, _crypto_1.hkdf)(sharedEphemeral, bundleSalt, constants_1.WA_PAIRING_KDF_INFO.LINK_CODE_BUNDLE, 32);
-    const bundleEncryptionKey = await (0, _crypto_1.importAesGcmKey)(bundleEncryptionKeyRaw, ['encrypt']);
+    const bundleEncryptionKey = (0, _crypto_1.hkdf)(sharedEphemeral, bundleSalt, constants_1.WA_PAIRING_KDF_INFO.LINK_CODE_BUNDLE, 32);
     const plaintextBundle = (0, bytes_1.concatBytes)([
         args.registrationIdentityKeyPair.pubKey,
         args.primaryIdentityPub,
         bundleSecret
     ]);
-    const [encryptedBundle, sharedIdentity] = await Promise.all([
-        (0, _crypto_1.aesGcmEncrypt)(bundleEncryptionKey, bundleIv, plaintextBundle),
-        X25519_1.X25519.scalarMult(args.registrationIdentityKeyPair.privKey, args.primaryIdentityPub)
-    ]);
+    const encryptedBundle = (0, _crypto_1.aesGcmEncrypt)(bundleEncryptionKey, bundleIv, plaintextBundle);
     const wrappedKeyBundle = (0, bytes_1.concatBytes)([bundleSalt, bundleIv, encryptedBundle]);
     const advMaterial = (0, bytes_1.concatBytes)([sharedEphemeral, sharedIdentity, bundleSecret]);
-    const advSecret = await (0, _crypto_1.hkdf)(advMaterial, null, constants_1.WA_PAIRING_KDF_INFO.ADV_SECRET, 32);
+    const advSecret = (0, _crypto_1.hkdf)(advMaterial, null, constants_1.WA_PAIRING_KDF_INFO.ADV_SECRET, 32);
     return {
         wrappedKeyBundle,
         companionIdentityPublic: args.registrationIdentityKeyPair.pubKey,