zapo-js 0.1.1 → 0.2.0

package/dist/transport/noise/WaNoiseSession.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaNoiseSession = void 0;
 const _crypto_1 = require("../../crypto/index.js");
 const ConsoleLogger_1 = require("../../infra/log/ConsoleLogger");
-const BoundedTaskQueue_1 = require("../../infra/perf/BoundedTaskQueue");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../../protocol/constants");
 const constants_2 = require("../noise/constants");
@@ -51,12 +50,11 @@ function buildRoutingInfoPrefix(routingInfo) {
 }
 class WaNoiseSession {
     constructor(sendWire, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
-        this.sendWire = sendWire;
-        this.logger = logger;
-        this.writeQueue = new BoundedTaskQueue_1.BoundedTaskQueue(4096, 1);
-        this.readQueue = new BoundedTaskQueue_1.BoundedTaskQueue(4096, 1);
+        this.writeChain = Promise.resolve();
+        this.readChain = Promise.resolve();
         this.frameCodec = null;
         this.handshakeInbox = [];
+        this.handshakeInboxHead = 0;
         this.handshakeWaiter = null;
         this.handshakeRejecter = null;
         this.pendingDecryptedFrames = [];
@@ -64,6 +62,8 @@ class WaNoiseSession {
         this.noiseSocket = null;
         this.serverStaticKey = null;
         this.handshakeFrameTimeoutMs = constants_1.WA_DEFAULTS.CONNECT_TIMEOUT_MS;
+        this.sendWire = sendWire;
+        this.logger = logger;
     }
     async start(config) {
         this.reset();
@@ -95,12 +95,24 @@ class WaNoiseSession {
         await this.decodeBufferedPostHandshakeFrames();
         this.logger.info('noise session established via full handshake');
     }
-    async encryptFrame(frame) {
-        if (!this.noiseSocket || !this.frameCodec) {
-            throw new Error('noise session is not established');
+    encryptFrame(frame) {
+        const socket = this.noiseSocket;
+        const codec = this.frameCodec;
+        if (!socket || !codec) {
+            return Promise.reject(new Error('noise session is not established'));
         }
-        const encrypted = await this.writeQueue.enqueue(() => this.noiseSocket.encrypt(frame));
-        return this.frameCodec.encodeFrame(encrypted);
+        let encryptPromise;
+        try {
+            encryptPromise = socket.encrypt(socket.reserveWriteNonce(), frame);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const result = this.writeChain
+            .then(() => encryptPromise)
+            .then((encrypted) => codec.encodeFrame(encrypted));
+        this.writeChain = result.then(() => { }, () => { });
+        return result;
     }
     async pushWireChunk(chunk) {
         const codec = this.frameCodec;
@@ -109,7 +121,9 @@ class WaNoiseSession {
         }
         const out = [];
         if (this.pendingDecryptedFrames.length > 0) {
-            out.push(...this.pendingDecryptedFrames);
+            for (let i = 0; i < this.pendingDecryptedFrames.length; i += 1) {
+                out.push(this.pendingDecryptedFrames[i]);
+            }
             this.pendingDecryptedFrames = [];
         }
         const frames = codec.pushWireChunk(chunk);
@@ -127,9 +141,15 @@ class WaNoiseSession {
             }
             return out;
         }
-        for (const frame of frames) {
-            const decrypted = await this.readQueue.enqueue(() => this.noiseSocket.decrypt(frame));
-            out.push(decrypted);
+        if (frames.length > 0) {
+            const decryptBatch = this.decryptFramesBatch(this.noiseSocket, frames);
+            this.readChain = this.readChain
+                .then(() => decryptBatch)
+                .then(() => { }, () => { });
+            const decrypted = await decryptBatch;
+            for (let i = 0; i < decrypted.length; i++) {
+                out.push(decrypted[i]);
+            }
         }
         return out;
     }
@@ -144,21 +164,30 @@ class WaNoiseSession {
             rejecter(closeError);
         }
     }
+    async decryptFramesBatch(socket, frames) {
+        if (frames.length === 1) {
+            return [await socket.decrypt(socket.reserveReadNonce(), frames[0])];
+        }
+        const pending = new Array(frames.length);
+        for (let i = 0; i < frames.length; i++) {
+            pending[i] = socket.decrypt(socket.reserveReadNonce(), frames[i]);
+        }
+        return Promise.all(pending);
+    }
     reset() {
         this.logger.trace('noise session reset');
         this.frameCodec = null;
-        this.handshakeInbox = [];
+        this.handshakeInbox.length = this.handshakeInboxHead = 0;
         this.handshakeWaiter = null;
         this.handshakeRejecter = null;
         this.pendingDecryptedFrames = [];
         this.closedError = null;
         this.noiseSocket = null;
         this.serverStaticKey = null;
+        this.writeChain = Promise.resolve();
+        this.readChain = Promise.resolve();
     }
     getServerStaticKey() {
-        if (!this.serverStaticKey) {
-            return null;
-        }
         return this.serverStaticKey;
     }
     async fullHandshake(clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates) {
@@ -188,10 +217,12 @@ class WaNoiseSession {
         await handshake.start(constants_2.NOISE_IK_NAME, protocolHeader);
         await handshake.authenticate(serverStaticKey);
         await handshake.authenticate(ephemeralKeyPair.pubKey);
-        const agreement1 = await _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverStaticKey);
+        const [agreement1, agreement2] = await Promise.all([
+            _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverStaticKey),
+            _crypto_1.X25519.scalarMult(clientStaticKeyPair.privKey, serverStaticKey)
+        ]);
         await handshake.mixIntoKey(agreement1);
         const encryptedClientStatic = await handshake.encrypt(clientStaticKeyPair.pubKey);
-        const agreement2 = await _crypto_1.X25519.scalarMult(clientStaticKeyPair.privKey, serverStaticKey);
         await handshake.mixIntoKey(agreement2);
         const encryptedPayload = await handshake.encrypt(payload);
         const clientHello = _proto_1.proto.HandshakeMessage.encode({
@@ -218,8 +249,12 @@ class WaNoiseSession {
         }
         const serverEphemeral = (0, bytes_1.toBytesView)(serverHello.ephemeral);
         await handshake.authenticate(serverEphemeral);
-        await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral));
-        await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(clientStaticKeyPair.privKey, serverEphemeral));
+        const [dh1, dh2] = await Promise.all([
+            _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral),
+            _crypto_1.X25519.scalarMult(clientStaticKeyPair.privKey, serverEphemeral)
+        ]);
+        await handshake.mixIntoKey(dh1);
+        await handshake.mixIntoKey(dh2);
         await handshake.decrypt((0, bytes_1.toBytesView)(serverHello.payload));
         this.serverStaticKey = serverStaticKey;
         this.logger.info('noise resume handshake successful without fallback');
@@ -278,8 +313,13 @@ class WaNoiseSession {
         if (this.closedError) {
             throw this.closedError;
         }
-        const queued = this.handshakeInbox.shift();
+        const queued = this.handshakeInboxHead < this.handshakeInbox.length
+            ? this.handshakeInbox[this.handshakeInboxHead++]
+            : undefined;
         if (queued) {
+            if (this.handshakeInboxHead === this.handshakeInbox.length) {
+                this.handshakeInbox.length = this.handshakeInboxHead = 0;
+            }
             this.logger.trace('noise handshake frame consumed from queue');
             return queued;
         }
@@ -310,17 +350,25 @@ class WaNoiseSession {
         });
     }
     async decodeBufferedPostHandshakeFrames() {
-        if (!this.noiseSocket || this.handshakeInbox.length === 0) {
+        if (!this.noiseSocket || this.handshakeInboxHead >= this.handshakeInbox.length) {
             return;
         }
         this.logger.debug('decoding buffered post-handshake frames', {
-            count: this.handshakeInbox.length
+            count: this.handshakeInbox.length - this.handshakeInboxHead
         });
-        const buffered = this.handshakeInbox.splice(0, this.handshakeInbox.length);
-        for (const frame of buffered) {
-            const decrypted = await this.readQueue.enqueue(() => this.noiseSocket.decrypt(frame));
-            this.pendingDecryptedFrames.push(decrypted);
+        const start = this.handshakeInboxHead;
+        const frames = this.handshakeInbox.slice(start);
+        if (frames.length > 0) {
+            const decryptBatch = this.decryptFramesBatch(this.noiseSocket, frames);
+            this.readChain = this.readChain
+                .then(() => decryptBatch)
+                .then(() => { }, () => { });
+            const decrypted = await decryptBatch;
+            for (let i = 0; i < decrypted.length; i++) {
+                this.pendingDecryptedFrames.push(decrypted[i]);
+            }
         }
+        this.handshakeInbox.length = this.handshakeInboxHead = 0;
     }
 }
 exports.WaNoiseSession = WaNoiseSession;

package/dist/transport/noise/WaNoiseSocket.js

@@ -9,12 +9,16 @@ class WaNoiseSocket {
         this.writeCounter = 0;
         this.readCounter = 0;
     }
-    async encrypt(frame, additionalData) {
-        const nonce = (0, _crypto_1.buildNonce)(this.writeCounter++);
+    reserveWriteNonce() {
+        return (0, _crypto_1.buildNonce)(this.writeCounter++);
+    }
+    encrypt(nonce, frame, additionalData) {
         return (0, _crypto_1.aesGcmEncrypt)(this.encryptKey, nonce, frame, additionalData);
     }
-    async decrypt(frame, additionalData) {
-        const nonce = (0, _crypto_1.buildNonce)(this.readCounter++);
+    reserveReadNonce() {
+        return (0, _crypto_1.buildNonce)(this.readCounter++);
+    }
+    decrypt(nonce, frame, additionalData) {
         return (0, _crypto_1.aesGcmDecrypt)(this.decryptKey, nonce, frame, additionalData);
     }
 }

package/dist/transport/proxy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProxyDispatcher = isProxyDispatcher;
+exports.isProxyAgent = isProxyAgent;
+exports.isProxyTransport = isProxyTransport;
+exports.toProxyDispatcher = toProxyDispatcher;
+exports.toProxyAgent = toProxyAgent;
+function isProxyDispatcher(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'dispatch' in value &&
+        typeof value.dispatch === 'function');
+}
+function isProxyAgent(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'addRequest' in value &&
+        typeof value.addRequest === 'function');
+}
+function isProxyTransport(value) {
+    return isProxyDispatcher(value) || isProxyAgent(value);
+}
+function toProxyDispatcher(proxy) {
+    if (!proxy || !isProxyDispatcher(proxy)) {
+        return undefined;
+    }
+    return proxy;
+}
+function toProxyAgent(proxy) {
+    if (!proxy || !isProxyAgent(proxy)) {
+        return undefined;
+    }
+    return proxy;
+}

package/dist/transport/stream/parse.js

@@ -1,80 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStreamControlNode = parseStreamControlNode;
-exports.parseOptionalInt = parseOptionalInt;
 exports.parseCompanionEncStatic = parseCompanionEncStatic;
 exports.parseSuccessPersistAttributes = parseSuccessPersistAttributes;
 const constants_1 = require("../../protocol/constants");
 const helpers_1 = require("../node/helpers");
-const base64_1 = require("../../util/base64");
-function parseStrictUnsignedInt(value) {
-    if (!/^\d+$/.test(value)) {
-        return undefined;
-    }
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed)) {
-        return undefined;
-    }
-    return parsed;
-}
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
+const DIGITS_ONLY_RE = /^\d+$/;
 function parseStreamControlNode(node) {
     if (node.tag === constants_1.WA_STREAM_SIGNALING.XML_STREAM_END_TAG) {
-        return {
-            kind: 'xmlstreamend'
-        };
+        return { kind: 'xmlstreamend' };
     }
     if (node.tag !== constants_1.WA_STREAM_SIGNALING.STREAM_ERROR_TAG) {
         return null;
     }
     const conflictNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_STREAM_SIGNALING.CONFLICT_TAG);
     if (conflictNode) {
-        if (conflictNode.attrs.type === constants_1.WA_STREAM_SIGNALING.REPLACED_TYPE) {
-            return {
-                kind: 'stream_error_replaced'
-            };
-        }
-        return {
-            kind: 'stream_error_device_removed'
-        };
+        return conflictNode.attrs.type === constants_1.WA_STREAM_SIGNALING.REPLACED_TYPE
+            ? { kind: 'stream_error_replaced' }
+            : { kind: 'stream_error_device_removed' };
     }
-    const codeRaw = node.attrs.code;
-    if (codeRaw) {
-        const code = parseStrictUnsignedInt(codeRaw);
-        if (code !== undefined) {
-            return {
-                kind: 'stream_error_code',
-                code
-            };
+    const codeStr = node.attrs.code;
+    if (codeStr && DIGITS_ONLY_RE.test(codeStr)) {
+        const code = Number(codeStr);
+        if (Number.isSafeInteger(code)) {
+            return { kind: 'stream_error_code', code };
         }
     }
     const ackNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_STREAM_SIGNALING.ACK_TAG);
     if (ackNode) {
-        return {
-            kind: 'stream_error_ack',
-            id: ackNode.attrs.id
-        };
+        return { kind: 'stream_error_ack', id: ackNode.attrs.id };
     }
     if ((0, helpers_1.hasNodeChild)(node, constants_1.WA_STREAM_SIGNALING.XML_NOT_WELL_FORMED_TAG)) {
-        return {
-            kind: 'stream_error_xml_not_well_formed'
-        };
-    }
-    return {
-        kind: 'stream_error_other'
-    };
-}
-function parseOptionalInt(value) {
-    if (!value) {
-        return undefined;
+        return { kind: 'stream_error_xml_not_well_formed' };
     }
-    return parseStrictUnsignedInt(value);
+    return { kind: 'stream_error_other' };
 }
 function parseCompanionEncStatic(value, onError) {
     if (!value) {
         return undefined;
     }
     try {
-        return (0, base64_1.base64ToBytes)(value, 'success.companion_enc_static');
+        return (0, bytes_1.base64ToBytesChecked)(value, 'success.companion_enc_static');
     }
     catch (error) {
         if (error instanceof Error) {
@@ -88,10 +56,10 @@ function parseSuccessPersistAttributes(node, onCompanionParseError) {
         meLid: node.attrs.lid,
         meDisplayName: node.attrs.display_name,
         companionEncStatic: parseCompanionEncStatic(node.attrs.companion_enc_static, onCompanionParseError),
-        lastSuccessTs: parseOptionalInt(node.attrs.t),
-        propsVersion: parseOptionalInt(node.attrs.props),
-        abPropsVersion: parseOptionalInt(node.attrs.abprops),
+        lastSuccessTs: (0, primitives_1.parseOptionalInt)(node.attrs.t),
+        propsVersion: (0, primitives_1.parseOptionalInt)(node.attrs.props),
+        abPropsVersion: (0, primitives_1.parseOptionalInt)(node.attrs.abprops),
         connectionLocation: node.attrs.location,
-        accountCreationTs: parseOptionalInt(node.attrs.creation)
+        accountCreationTs: (0, primitives_1.parseOptionalInt)(node.attrs.creation)
     };
 }

package/dist/types/appstate/WaAppStateCrypto.d.ts

@@ -53,7 +53,6 @@ export declare class WaAppStateCrypto {
     private pointwiseWithOverflow;
     private generateAssociatedData;
     private generateValueMac;
-    private normalizeDerivedKeysCacheMaxSize;
     private touchDerivedKeysCacheEntry;
 }
 export {};

package/dist/types/appstate/WaAppStateSyncClient.d.ts

@@ -7,6 +7,7 @@ interface WaAppStateSyncClientOptions {
     readonly logger: Logger;
     readonly query: (node: BinaryNode, timeoutMs: number) => Promise<BinaryNode>;
     readonly store: WaAppStateStore;
+    readonly getCurrentMeJid?: () => string | null | undefined;
     readonly hostDomain?: string;
     readonly defaultTimeoutMs?: number;
     readonly onMissingKeys?: (event: WaAppStateMissingKeysEvent) => Promise<void>;
@@ -20,6 +21,7 @@ export declare class WaAppStateSyncClient {
     private readonly logger;
     private readonly query;
     private readonly store;
+    private readonly getCurrentMeJid?;
     private readonly hostDomain;
     private readonly defaultTimeoutMs;
     private readonly onMissingKeys?;
@@ -33,13 +35,11 @@ export declare class WaAppStateSyncClient {
     sync(options?: WaAppStateSyncOptions): Promise<WaAppStateSyncResult>;
     private syncOnce;
     private syncCollectionsRound;
-    private prepareSyncRoundRequest;
     private buildCollectionSyncRequest;
     private buildSyncIqNode;
     private fetchSyncPayloadByCollection;
     private processCollectionRound;
     private createCollectionOutcome;
-    private collectDistinctMissingKeyIds;
     private notifyMissingKeys;
     private resolveReadyPatches;
     private validateSnapshot;
@@ -51,9 +51,12 @@ export declare class WaAppStateSyncClient {
     private decryptPatchMutations;
     private assertPatchMacsMatch;
     private buildOutgoingPatch;
+    private resolveDeviceIndex;
+    private buildPatchClientDebugData;
     private computeNextCollectionState;
     private normalizeProtoLong;
     private groupPendingMutations;
+    private preloadKeyData;
     private getKeyData;
     private getCollectionState;
     private setCollectionState;

package/dist/types/appstate/constants.d.ts

@@ -11,4 +11,5 @@ export declare const APP_STATE_IV_LENGTH = 16;
 export declare const APP_STATE_LT_HASH_SIZE = 128;
 export declare const APP_STATE_POINT_SIZE = 2;
 export declare const APP_STATE_EMPTY_LT_HASH: Uint8Array<ArrayBuffer>;
+export declare const APP_STATE_DEFAULT_COLLECTION_VERSION = 0;
 export declare const APP_STATE_DEFAULT_COLLECTIONS: readonly AppStateCollectionName[];

package/dist/types/appstate/encoding.d.ts

@@ -0,0 +1,7 @@
+import type { WaAppStateStoreData, WaAppStateSyncKey } from './types';
+type StoreRow = Readonly<Record<string, unknown>>;
+export declare function encodeAppStateFingerprint(fingerprint: WaAppStateSyncKey['fingerprint']): Uint8Array | null;
+export declare function decodeAppStateFingerprint(raw: unknown): WaAppStateSyncKey['fingerprint'] | undefined;
+export declare function decodeAppStateSyncKeys(rows: readonly StoreRow[]): readonly WaAppStateSyncKey[];
+export declare function decodeAppStateCollections(versionRows: readonly StoreRow[], valueRows: readonly StoreRow[]): WaAppStateStoreData['collections'];
+export {};

package/dist/types/appstate/index.d.ts

@@ -1,7 +1,7 @@
 export * from './constants';
-export type { WaAppStateSyncOptions } from './types';
+export type { AppStateCollectionName, WaAppStateStoreData, WaAppStateSyncKey, WaAppStateSyncOptions } from './types';
+export { encodeAppStateFingerprint, decodeAppStateFingerprint, decodeAppStateCollections, decodeAppStateSyncKeys } from './encoding';
 export * from './utils';
 export { WaAppStateCrypto } from './WaAppStateCrypto';
-export { WaAppStateMissingKeyError } from './WaAppStateSyncClient';
-export { parseCollectionState, parseSyncResponse, type CollectionResponsePayload } from './WaAppStateSyncResponseParser';
+export { parseSyncResponse } from './WaAppStateSyncResponseParser';
 export { WaAppStateSyncClient } from './WaAppStateSyncClient';

package/dist/types/appstate/utils.d.ts

@@ -1,10 +1,7 @@
 import type { AppStateCollectionName, WaAppStateSyncKey } from './types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import type { Proto } from '..';
-export declare function keyIdToHex(keyId: Uint8Array): string;
 export declare function parseCollectionName(value: string | undefined): AppStateCollectionName | null;
-export declare function keyDeviceId(keyId: Uint8Array): number | null;
 export declare function keyEpoch(keyId: Uint8Array): number;
 export declare function pickActiveSyncKey(keys: Iterable<WaAppStateSyncKey>): WaAppStateSyncKey | null;
-export declare function toNetworkOrder64(value: number): Uint8Array;
 export declare function downloadExternalBlobReference(mediaTransfer: WaMediaTransferClient, reference: Proto.IExternalBlobReference): Promise<Uint8Array>;

package/dist/types/auth/WaAuthClient.d.ts

@@ -3,14 +3,7 @@ import type { Logger } from '../infra/log/types';
 import type { WaAuthStore } from '../store/contracts/auth.store';
 import type { WaSignalStore } from '../store/contracts/signal.store';
 import type { BinaryNode } from '../transport/types';
-interface WaAuthClientCallbacks {
-    readonly onQr?: (qr: string, ttlMs: number) => void;
-    readonly onPairingCode?: (code: string) => void;
-    readonly onPairingRefresh?: (forceManual: boolean) => void;
-    readonly onPaired?: (credentials: WaAuthCredentials) => void;
-    readonly onError?: (error: Error) => void;
-}
-interface WaAuthClientDependencies {
+type WaAuthClientDeps = Readonly<{
     readonly logger: Logger;
     readonly authStore: WaAuthStore;
     readonly signalStore: WaSignalStore;
@@ -18,8 +11,14 @@ interface WaAuthClientDependencies {
         readonly sendNode: (node: BinaryNode) => Promise<void>;
         readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
     };
-    readonly callbacks?: WaAuthClientCallbacks;
-}
+    readonly callbacks?: {
+        readonly onQr?: (qr: string, ttlMs: number) => void;
+        readonly onPairingCode?: (code: string) => void;
+        readonly onPairingRefresh?: (forceManual: boolean) => void;
+        readonly onPaired?: (credentials: WaAuthCredentials) => void;
+        readonly onError?: (error: Error) => void;
+    };
+}>;
 export declare class WaAuthClient {
     private readonly options;
     private readonly logger;
@@ -29,7 +28,7 @@ export declare class WaAuthClient {
     private readonly qrFlow;
     private readonly pairingFlow;
     private credentials;
-    constructor(options: WaAuthClientOptions, deps: WaAuthClientDependencies);
+    constructor(options: WaAuthClientOptions, deps: WaAuthClientDeps);
     getState(connected?: boolean): {
         connected: boolean;
         registered: boolean;
@@ -45,7 +44,6 @@ export declare class WaAuthClient {
     persistServerHasPreKeys(serverHasPreKeys: boolean): Promise<void>;
     persistRoutingInfo(routingInfo: Uint8Array): Promise<void>;
     clearRoutingInfo(): Promise<WaAuthCredentials>;
-    persistMeLid(meLid: string): Promise<void>;
     persistSuccessAttributes(attributes: WaSuccessPersistAttributes): Promise<void>;
     requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
     fetchPairingCountryCodeIso(): Promise<string>;

package/dist/types/auth/flow/WaAuthCredentialsFlow.d.ts

@@ -10,5 +10,5 @@ interface WaAuthCredentialsFlowArgs {
 }
 export declare function loadOrCreateCredentials(args: WaAuthCredentialsFlowArgs): Promise<WaAuthCredentials>;
 export declare function persistCredentials(args: WaAuthCredentialsFlowArgs, credentials: WaAuthCredentials): Promise<void>;
-export declare function buildCommsConfig(logger: Logger, credentials: WaAuthCredentials, socketOptions: WaAuthSocketOptions, clientOptions: Pick<WaAuthClientOptions, 'deviceBrowser' | 'deviceOsDisplayName' | 'requireFullSync'>): WaCommsConfig;
+export declare function buildCommsConfig(logger: Logger, credentials: WaAuthCredentials, socketOptions: WaAuthSocketOptions, clientOptions: Pick<WaAuthClientOptions, 'deviceBrowser' | 'deviceOsDisplayName' | 'requireFullSync' | 'version'>): WaCommsConfig;
 export {};

package/dist/types/auth/index.d.ts

@@ -1,6 +1,2 @@
 export * from './types';
-export { getLoginIdentity } from '../protocol/jid';
 export { WaAuthClient } from './WaAuthClient';
-export { completeCompanionFinish, createCompanionHello } from './pairing/WaPairingCodeCrypto';
-export { WaAuthSqliteStore } from '../store/providers/sqlite/auth.store';
-export type { WaAuthStore } from '../store/contracts/auth.store';

package/dist/types/auth/pairing/WaQrFlow.d.ts

@@ -6,7 +6,7 @@ export declare class WaQrFlow {
     private readonly getDevicePlatform;
     private readonly emitQr;
     private qrRefs;
-    private currentRef;
+    private qrRefIndex;
     private currentQrTimer;
     constructor(args: {
         readonly logger: Logger;

package/dist/types/auth/types.d.ts

@@ -1,6 +1,7 @@
 import type { SignalKeyPair } from '../crypto/curves/types';
 import type { Proto } from '..';
 import type { RegistrationInfo, SignedPreKeyRecord } from '../signal/types';
+import type { WaCommsConfig, WaProxyTransport } from '../transport/types';
 export interface WaAuthCredentials {
     readonly noiseKeyPair: SignalKeyPair;
     readonly registrationInfo: RegistrationInfo;
@@ -21,20 +22,17 @@ export interface WaAuthCredentials {
     readonly connectionLocation?: string;
     readonly accountCreationTs?: number;
 }
-export interface WaAuthSocketOptions {
-    readonly url?: string;
-    readonly urls?: readonly string[];
-    readonly protocols?: readonly string[];
-    readonly connectTimeoutMs?: number;
-    readonly reconnectIntervalMs?: number;
-    readonly timeoutIntervalMs?: number;
-    readonly maxReconnectAttempts?: number;
-}
+export type WaAuthSocketOptions = Pick<WaCommsConfig, 'url' | 'urls' | 'protocols' | 'connectTimeoutMs' | 'reconnectIntervalMs' | 'timeoutIntervalMs' | 'maxReconnectAttempts'> & {
+    readonly proxy?: {
+        readonly ws?: WaProxyTransport;
+    };
+};
 export interface WaAuthClientOptions {
     readonly deviceBrowser?: string;
     readonly devicePlatform?: string;
     readonly deviceOsDisplayName?: string;
     readonly requireFullSync?: boolean;
+    readonly version?: string;
 }
 export interface WaSuccessPersistAttributes {
     readonly meLid?: string;