zapo-js 0.1.2 → 0.2.0

package/dist/transport/node/builders/retry.js

@@ -4,6 +4,7 @@ exports.buildRetryReceiptNode = buildRetryReceiptNode;
 const constants_1 = require("../../../protocol/constants");
 const constants_2 = require("../../../retry/constants");
 const constants_3 = require("../../../signal/api/constants");
+const global_1 = require("../../node/builders/global");
 const bytes_1 = require("../../../util/bytes");
 function buildRetryKeysNode(keys) {
     const content = [
@@ -71,23 +72,6 @@ function buildRetryKeysNode(keys) {
     };
 }
 function buildRetryReceiptNode(input) {
-    const attrs = {
-        id: input.stanzaId,
-        to: input.to,
-        type: 'retry'
-    };
-    if (input.participant) {
-        attrs.participant = input.participant;
-    }
-    if (input.recipient) {
-        attrs.recipient = input.recipient;
-    }
-    if (input.from) {
-        attrs.from = input.from;
-    }
-    if (input.categoryPeer) {
-        attrs.category = 'peer';
-    }
     const retryAttrs = {
         v: constants_2.RETRY_RECEIPT_VERSION,
         count: String(input.retryCount),
@@ -111,9 +95,13 @@ function buildRetryReceiptNode(input) {
     if (input.keys) {
         content.push(buildRetryKeysNode(input.keys));
     }
-    return {
-        tag: constants_1.WA_MESSAGE_TAGS.RECEIPT,
-        attrs,
+    return (0, global_1.buildReceiptNode)({
+        kind: 'retry_custom',
+        id: input.stanzaId,
+        to: input.to,
+        participant: input.participant,
+        recipient: input.recipient,
+        categoryPeer: input.categoryPeer,
         content
-    };
+    });
 }

package/dist/transport/node/builders/usync.js

@@ -18,6 +18,10 @@ function buildUsyncIq(input) {
     if (input.queryProtocolNodes.length === 0) {
         throw new Error('usync query must include at least one protocol node');
     }
+    const users = new Array(input.users.length);
+    for (let index = 0; index < input.users.length; index += 1) {
+        users[index] = buildUsyncUserNode(input.users[index]);
+    }
     return (0, query_1.buildIqNode)('get', input.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.USYNC, [
         {
             tag: constants_1.WA_NODE_TAGS.USYNC,
@@ -32,12 +36,12 @@ function buildUsyncIq(input) {
                 {
                     tag: constants_1.WA_NODE_TAGS.QUERY,
                     attrs: {},
-                    content: [...input.queryProtocolNodes]
+                    content: input.queryProtocolNodes
                 },
                 {
                     tag: constants_1.WA_NODE_TAGS.LIST,
                     attrs: {},
-                    content: input.users.map((user) => buildUsyncUserNode(user))
+                    content: users
                 }
             ]
         }

package/dist/transport/node/helpers.js

@@ -13,10 +13,13 @@ exports.hasNodeChild = hasNodeChild;
 exports.decodeNodeContentUtf8OrBytes = decodeNodeContentUtf8OrBytes;
 exports.decodeNodeContentBase64OrBytes = decodeNodeContentBase64OrBytes;
 exports.formatNodeIdPrefixFromSeed = formatNodeIdPrefixFromSeed;
+exports.createNodeIdGenerator = createNodeIdGenerator;
+const _crypto_1 = require("../../crypto/index.js");
 const bytes_1 = require("../../util/bytes");
 const EMPTY_NODE_CHILDREN = Object.freeze([]);
 const EMPTY_NODE_TAGS = Object.freeze([]);
 const EMPTY_NODE_VALUES = Object.freeze([]);
+const NODE_ID_PREFIX_SEED = new Uint8Array(4);
 function getNodeChildren(node) {
     return Array.isArray(node.content) ? node.content : EMPTY_NODE_CHILDREN;
 }
@@ -69,7 +72,11 @@ function getNodeChildrenTags(node) {
     const content = node.content;
     if (!Array.isArray(content) || content.length === 0)
         return EMPTY_NODE_TAGS;
-    return content.map((c) => c.tag);
+    const tags = new Array(content.length);
+    for (let i = 0; i < content.length; i += 1) {
+        tags[i] = content[i].tag;
+    }
+    return tags;
 }
 function getNodeChildrenNonEmptyAttrValuesByTag(node, tag, attr) {
     let values = null;
@@ -152,3 +159,15 @@ function formatNodeIdPrefixFromSeed(seed) {
     const right = ((seed[2] << 8) | seed[3]) >>> 0;
     return `${left}.${right}-`;
 }
+async function createNodeIdGenerator() {
+    await (0, _crypto_1.randomFillAsync)(NODE_ID_PREFIX_SEED);
+    const prefix = formatNodeIdPrefixFromSeed(NODE_ID_PREFIX_SEED);
+    let counter = 0;
+    return {
+        prefix,
+        next() {
+            counter += 1;
+            return `${prefix}${counter}`;
+        }
+    };
+}

package/dist/transport/node/usync.js

@@ -1,38 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUsyncSidGenerator = createUsyncSidGenerator;
-const _crypto_1 = require("../../crypto/index.js");
 const helpers_1 = require("./helpers");
 function createUsyncSidGenerator() {
-    const state = {
-        prefix: null,
-        prefixPromise: null,
-        counter: 1
-    };
-    return async () => {
-        const prefix = await getUsyncPrefix(state);
-        const sid = `${prefix}${state.counter}`;
-        state.counter += 1;
-        return sid;
-    };
-}
-async function getUsyncPrefix(state) {
-    if (state.prefix) {
-        return state.prefix;
-    }
-    if (!state.prefixPromise) {
-        state.prefixPromise = buildUsyncPrefix()
-            .then((prefix) => {
-            state.prefix = prefix;
-            return prefix;
-        })
-            .finally(() => {
-            state.prefixPromise = null;
-        });
-    }
-    return state.prefixPromise;
-}
-async function buildUsyncPrefix() {
-    const seed = await (0, _crypto_1.randomBytesAsync)(4);
-    return (0, helpers_1.formatNodeIdPrefixFromSeed)(seed);
+    const generatorPromise = (0, helpers_1.createNodeIdGenerator)();
+    return async () => (await generatorPromise).next();
 }

package/dist/transport/node/xml.js

@@ -4,23 +4,41 @@ exports.formatBinaryNodeAsXml = formatBinaryNodeAsXml;
 const bytes_1 = require("../../util/bytes");
 const XML_INDENT = '    ';
 function escapeXml(value) {
-    return value
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-function renderAttrs(attrs) {
-    const entries = Object.entries(attrs);
-    if (entries.length === 0) {
-        return '';
+    let out = '';
+    let last = 0;
+    for (let i = 0; i < value.length; i++) {
+        let esc;
+        switch (value.charCodeAt(i)) {
+            case 38:
+                esc = '&amp;';
+                break;
+            case 60:
+                esc = '&lt;';
+                break;
+            case 62:
+                esc = '&gt;';
+                break;
+            case 34:
+                esc = '&quot;';
+                break;
+            case 39:
+                esc = '&apos;';
+                break;
+        }
+        if (esc) {
+            out += value.slice(last, i) + esc;
+            last = i + 1;
+        }
     }
-    return entries.map(([key, value]) => ` ${key}='${escapeXml(value)}'`).join('');
+    return last === 0 ? value : out + value.slice(last);
 }
 function renderNode(node, depth) {
     const indent = XML_INDENT.repeat(depth);
-    const attrs = renderAttrs(node.attrs);
+    const keys = Object.keys(node.attrs);
+    let attrs = '';
+    for (let i = 0; i < keys.length; i++) {
+        attrs += ` ${keys[i]}='${escapeXml(node.attrs[keys[i]])}'`;
+    }
     const content = node.content;
     if (content === undefined) {
         return `${indent}<${node.tag}${attrs}/>`;
@@ -34,7 +52,10 @@ function renderNode(node, depth) {
     if (content.length === 0) {
         return `${indent}<${node.tag}${attrs}/>`;
     }
-    const children = content.map((child) => renderNode(child, depth + 1)).join('\n');
+    let children = renderNode(content[0], depth + 1);
+    for (let i = 1; i < content.length; i++) {
+        children += '\n' + renderNode(content[i], depth + 1);
+    }
     return `${indent}<${node.tag}${attrs}>\n${children}\n${indent}</${node.tag}>`;
 }
 function formatBinaryNodeAsXml(node) {

package/dist/transport/noise/WaClientPayload.js

@@ -5,8 +5,7 @@ exports.buildRegistrationPayload = buildRegistrationPayload;
 const node_crypto_1 = require("node:crypto");
 const primitives_1 = require("../../crypto/core/primitives");
 const _proto_1 = require("../../proto.js");
-const constants_1 = require("../../signal/constants");
-const constants_2 = require("../noise/constants");
+const constants_1 = require("../noise/constants");
 const bytes_1 = require("../../util/bytes");
 function parseVersion(versionBase) {
     const [p = '2', s = '3000', t = '0'] = versionBase.split('.');
@@ -64,8 +63,8 @@ function resolveDevicePropsPlatformType(deviceBrowser) {
             return _proto_1.proto.DeviceProps.PlatformType.UNKNOWN;
     }
 }
-function defaultUserAgent(versionBase, deviceOsDisplayName) {
-    const { primary, secondary, tertiary } = parseVersion(versionBase);
+function defaultUserAgent(versionBase, deviceOsDisplayName, version) {
+    const { primary, secondary, tertiary } = version ?? parseVersion(versionBase);
     const locale = resolveLocale();
     return {
         platform: _proto_1.proto.ClientPayload.UserAgent.Platform.WEB,
@@ -86,8 +85,8 @@ function defaultUserAgent(versionBase, deviceOsDisplayName) {
         localeCountryIso31661Alpha2: locale.lc
     };
 }
-function defaultDeviceProps(versionBase, config) {
-    const { primary, secondary, tertiary } = parseVersion(versionBase);
+function defaultDeviceProps(versionBase, config, version) {
+    const { primary, secondary, tertiary } = version ?? parseVersion(versionBase);
     return _proto_1.proto.DeviceProps.encode({
         os: config.deviceOsDisplayName ?? process.platform,
         version: {
@@ -109,15 +108,15 @@ function defaultDeviceProps(versionBase, config) {
         }
     }).finish();
 }
-function buildCommonPayload(config) {
-    const versionBase = config.versionBase ?? constants_2.DEFAULT_VERSION_BASE;
+function buildCommonPayload(config, version) {
+    const versionBase = config.versionBase ?? constants_1.DEFAULT_VERSION_BASE;
     const pull = config.pull ?? true;
     return {
         passive: config.passive === true,
         pull,
         connectType: _proto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
         connectReason: _proto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-        userAgent: config.userAgent ?? defaultUserAgent(versionBase, config.deviceOsDisplayName),
+        userAgent: config.userAgent ?? defaultUserAgent(versionBase, config.deviceOsDisplayName, version),
         webInfo: config.webInfo ??
             {
                 webSubPlatform: defaultWebSubPlatform()
@@ -145,15 +144,16 @@ function buildRegistrationPayload(config) {
     if (!Number.isSafeInteger(signedPreKeyId) || signedPreKeyId <= 0) {
         throw new Error('registration payload requires a valid signedPreKeyId');
     }
-    const versionBase = config.versionBase ?? constants_2.DEFAULT_VERSION_BASE;
-    const common = buildCommonPayload(config);
+    const versionBase = config.versionBase ?? constants_1.DEFAULT_VERSION_BASE;
+    const version = parseVersion(versionBase);
+    const common = buildCommonPayload(config, version);
     const devicePairingData = {
         buildHash: config.buildHash ? (0, bytes_1.toBytesView)(config.buildHash) : (0, primitives_1.md5Bytes)(versionBase),
         deviceProps: config.deviceProps
             ? (0, bytes_1.toBytesView)(config.deviceProps)
-            : defaultDeviceProps(versionBase, config),
+            : defaultDeviceProps(versionBase, config, version),
         eRegid: (0, bytes_1.intToBytes)(4, registrationId),
-        eKeytype: (0, bytes_1.intToBytes)(1, constants_1.KEY_TYPE_CURVE25519),
+        eKeytype: (0, bytes_1.intToBytes)(1, 5),
         eIdent: (0, bytes_1.toBytesView)(config.registrationInfo.identityKeyPair.pubKey),
         eSkeyId: (0, bytes_1.intToBytes)(3, signedPreKeyId),
         eSkeyVal: (0, bytes_1.toBytesView)(config.signedPreKey.keyPair.pubKey),

package/dist/transport/noise/WaNoiseCert.js

@@ -9,7 +9,7 @@ const bytes_1 = require("../../util/bytes");
 const primitives_1 = require("../../util/primitives");
 async function verifySignalVariant(serializedPublicKey, message, signatureInput) {
     const publicKey = (0, _crypto_1.toSerializedPubKey)(serializedPublicKey);
-    if (!(0, bytes_1.assertByteLength)(signatureInput, 64, 'invalid certificate signature size', false)) {
+    if (signatureInput.length !== 64) {
         return false;
     }
     const signature = new Uint8Array(signatureInput);
@@ -20,7 +20,7 @@ async function verifySignalVariant(serializedPublicKey, message, signatureInput)
     const signBit = lastByte & 0x80;
     signature[63] = lastByte & 0x7f;
     const edwardsPublicKey = (0, X25519_1.montgomeryToEdwardsPublic)(publicKey.subarray(1), signBit);
-    return (0, _crypto_1.ed25519VerifyRaw)(edwardsPublicKey, signature, message);
+    return _crypto_1.Ed25519.verify(message, signature, edwardsPublicKey);
 }
 function parseNoiseCertificate(certificate) {
     if (!certificate) {

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,6 +50,8 @@ function buildRoutingInfoPrefix(routingInfo) {
 }
 class WaNoiseSession {
     constructor(sendWire, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
+        this.writeChain = Promise.resolve();
+        this.readChain = Promise.resolve();
         this.frameCodec = null;
         this.handshakeInbox = [];
         this.handshakeInboxHead = 0;
@@ -63,8 +64,6 @@ class WaNoiseSession {
         this.handshakeFrameTimeoutMs = constants_1.WA_DEFAULTS.CONNECT_TIMEOUT_MS;
         this.sendWire = sendWire;
         this.logger = logger;
-        this.writeQueue = new BoundedTaskQueue_1.BoundedTaskQueue(4096, 1);
-        this.readQueue = new BoundedTaskQueue_1.BoundedTaskQueue(4096, 1);
     }
     async start(config) {
         this.reset();
@@ -96,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'));
+        }
+        let encryptPromise;
+        try {
+            encryptPromise = socket.encrypt(socket.reserveWriteNonce(), frame);
         }
-        const encrypted = await this.writeQueue.enqueue(() => this.noiseSocket.encrypt(frame));
-        return this.frameCodec.encodeFrame(encrypted);
+        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;
@@ -110,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);
@@ -128,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;
     }
@@ -145,6 +164,16 @@ 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;
@@ -155,11 +184,10 @@ class WaNoiseSession {
         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) {
@@ -189,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({
@@ -219,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');
@@ -322,10 +356,17 @@ class WaNoiseSession {
         this.logger.debug('decoding buffered post-handshake frames', {
             count: this.handshakeInbox.length - this.handshakeInboxHead
         });
-        for (let index = this.handshakeInboxHead; index < this.handshakeInbox.length; index += 1) {
-            const frame = this.handshakeInbox[index];
-            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;
     }

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/stream/parse.js

@@ -7,6 +7,7 @@ const constants_1 = require("../../protocol/constants");
 const helpers_1 = require("../node/helpers");
 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' };
@@ -20,9 +21,12 @@ function parseStreamControlNode(node) {
             ? { kind: 'stream_error_replaced' }
             : { kind: 'stream_error_device_removed' };
     }
-    const code = node.attrs.code ? (0, primitives_1.parseStrictUnsignedInt)(node.attrs.code) : undefined;
-    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) {

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

@@ -2,8 +2,6 @@ import type { AppStateCollectionName, WaAppStateSyncKey } from './types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import type { Proto } from '..';
 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/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,4 +1,2 @@
 export * from './types';
 export { WaAuthClient } from './WaAuthClient';
-export { completeCompanionFinish, createCompanionHello } from './pairing/WaPairingCodeCrypto';
-export { WaAuthSqliteStore } from '../store/providers/sqlite/auth.store';

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

@@ -32,6 +32,7 @@ export interface WaAuthClientOptions {
     readonly devicePlatform?: string;
     readonly deviceOsDisplayName?: string;
     readonly requireFullSync?: boolean;
+    readonly version?: string;
 }
 export interface WaSuccessPersistAttributes {
     readonly meLid?: string;