zapo-js 0.1.2 → 0.3.0

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('.');
@@ -20,13 +19,20 @@ function parseVersion(versionBase) {
     }
     return { primary, secondary, tertiary };
 }
+let cachedLocale = null;
 function resolveLocale() {
+    // The first `Intl.DateTimeFormat()` call triggers V8's lazy ICU init
+    // (tens of ms). The process locale does not change at runtime, so
+    // memoize after the first resolve.
+    if (cachedLocale !== null)
+        return cachedLocale;
     const locale = Intl.DateTimeFormat().resolvedOptions().locale || 'en-US';
     const [language = 'en', country = 'US'] = locale.split('-');
-    return {
+    cachedLocale = Object.freeze({
         lg: language.toLowerCase(),
         lc: country.toUpperCase()
-    };
+    });
+    return cachedLocale;
 }
 function defaultWebSubPlatform() {
     return _proto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
@@ -64,8 +70,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 +92,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 +115,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,19 +151,18 @@ 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),
+        buildHash: config.buildHash ?? (0, primitives_1.md5Bytes)(versionBase),
+        deviceProps: config.deviceProps ?? defaultDeviceProps(versionBase, config, version),
         eRegid: (0, bytes_1.intToBytes)(4, registrationId),
-        eKeytype: (0, bytes_1.intToBytes)(1, constants_1.KEY_TYPE_CURVE25519),
-        eIdent: (0, bytes_1.toBytesView)(config.registrationInfo.identityKeyPair.pubKey),
+        eKeytype: (0, bytes_1.intToBytes)(1, 5),
+        eIdent: config.registrationInfo.identityKeyPair.pubKey,
         eSkeyId: (0, bytes_1.intToBytes)(3, signedPreKeyId),
-        eSkeyVal: (0, bytes_1.toBytesView)(config.signedPreKey.keyPair.pubKey),
-        eSkeySig: (0, bytes_1.toBytesView)(config.signedPreKey.signature)
+        eSkeyVal: config.signedPreKey.keyPair.pubKey,
+        eSkeySig: config.signedPreKey.signature
     };
     return _proto_1.proto.ClientPayload.encode({
         ...common,

package/dist/transport/noise/WaFrameCodec.js

@@ -14,7 +14,7 @@ class WaFrameCodec {
         if (maxFrameLength >= 1 << 24) {
             throw new Error('maxFrameLength must be lower than protocol limit (16777216)');
         }
-        this.introFrame = introFrame && introFrame.length > 0 ? (0, bytes_1.toBytesView)(introFrame) : null;
+        this.introFrame = introFrame && introFrame.length > 0 ? introFrame : null;
         this.maxFrameLength = maxFrameLength;
         this.introSent = false;
         this.buffered = bytes_1.EMPTY_BYTES;

package/dist/transport/noise/WaMobileClientPayload.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMobileLoginPayload = buildMobileLoginPayload;
+const node_crypto_1 = require("node:crypto");
+const _proto_1 = require("../../proto.js");
+function parseAppVersion(version) {
+    const parts = version.split('.');
+    const at = (i) => {
+        const n = Number(parts[i]);
+        return Number.isFinite(n) ? n : undefined;
+    };
+    return {
+        primary: at(0) ?? 2,
+        secondary: at(1) ?? 0,
+        tertiary: at(2) ?? 0,
+        quaternary: at(3)
+    };
+}
+function buildMobileLoginPayload(config) {
+    if (!Number.isSafeInteger(config.username) || config.username <= 0) {
+        throw new Error('mobile login payload requires a valid numeric username');
+    }
+    const info = config.deviceInfo;
+    const version = parseAppVersion(info.appVersion);
+    const userAgent = {
+        platform: _proto_1.proto.ClientPayload.UserAgent.Platform.ANDROID,
+        releaseChannel: _proto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        appVersion: version,
+        mcc: info.mcc ?? '000',
+        mnc: info.mnc ?? '000',
+        osVersion: info.osVersion,
+        manufacturer: info.manufacturer,
+        device: info.device,
+        osBuildNumber: info.osBuildNumber,
+        phoneId: info.phoneId ?? (0, node_crypto_1.randomUUID)(),
+        localeLanguageIso6391: info.localeLanguageIso6391 ?? 'en',
+        localeCountryIso31661Alpha2: info.localeCountryIso31661Alpha2 ?? 'US',
+        deviceType: _proto_1.proto.ClientPayload.UserAgent.DeviceType.PHONE,
+        deviceBoard: info.deviceBoard,
+        deviceModelType: info.deviceModelType
+    };
+    return _proto_1.proto.ClientPayload.encode({
+        passive: config.passive === true,
+        pull: config.pull ?? true,
+        product: _proto_1.proto.ClientPayload.Product.WHATSAPP,
+        connectType: config.connectType ?? _proto_1.proto.ClientPayload.ConnectType.CELLULAR_UNKNOWN,
+        connectReason: config.connectReason ?? _proto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent,
+        username: config.username,
+        device: config.device ?? 0,
+        lidDbMigrated: config.lidDbMigrated === true,
+        pushName: config.pushName,
+        yearClass: config.yearClass,
+        memClass: config.memClass
+    }).finish();
+}

package/dist/transport/noise/WaNoiseCert.js

@@ -2,26 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyNoiseCertificateChain = verifyNoiseCertificateChain;
 const _crypto_1 = require("../../crypto/index.js");
-const X25519_1 = require("../../crypto/curves/X25519");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../noise/constants");
 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)) {
-        return false;
-    }
-    const signature = new Uint8Array(signatureInput);
-    const lastByte = signature[63];
-    if ((lastByte & 0x60) !== 0) {
-        return false;
-    }
-    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);
-}
+const PRODUCTION_ROOT_CA = {
+    publicKey: (0, bytes_1.hexToBytes)(constants_1.ROOT_CA_PUBLIC_KEY_HEX),
+    serial: constants_1.ROOT_CA_SERIAL
+};
 function parseNoiseCertificate(certificate) {
     if (!certificate) {
         throw new Error('missing noise certificate');
@@ -41,21 +29,16 @@ function parseNoiseCertificate(certificate) {
         signature: signatureBytes
     };
 }
-function rootPublicKeySerialized() {
-    const raw = (0, bytes_1.hexToBytes)(constants_1.ROOT_CA_PUBLIC_KEY_HEX);
-    return (0, _crypto_1.toSerializedPubKey)(raw);
-}
-async function verifyNoiseCertificateChain(certificateChain, serverStatic) {
+async function verifyNoiseCertificateChain(certificateChain, serverStatic, rootCa = PRODUCTION_ROOT_CA) {
     const chain = _proto_1.proto.CertChain.decode(certificateChain);
     if (!chain.leaf || !chain.intermediate) {
         throw new Error('noise certificate chain is missing leaf/intermediate');
     }
     const intermediate = parseNoiseCertificate(chain.intermediate);
-    if (intermediate.issuerSerial !== constants_1.ROOT_CA_SERIAL) {
+    if (intermediate.issuerSerial !== rootCa.serial) {
         throw new Error('intermediate certificate issuer mismatch');
     }
-    const rootKey = rootPublicKeySerialized();
-    const validIntermediate = await verifySignalVariant(rootKey, intermediate.details, intermediate.signature);
+    const validIntermediate = await (0, _crypto_1.xeddsaVerify)(rootCa.publicKey, intermediate.details, intermediate.signature);
     if (!validIntermediate) {
         throw new Error('intermediate certificate signature is invalid');
     }
@@ -63,8 +46,7 @@ async function verifyNoiseCertificateChain(certificateChain, serverStatic) {
     if (leaf.issuerSerial !== intermediate.serial) {
         throw new Error('leaf certificate issuer mismatch');
     }
-    const intermediatePublicSerialized = (0, _crypto_1.toSerializedPubKey)(intermediate.key);
-    const validLeaf = await verifySignalVariant(intermediatePublicSerialized, leaf.details, leaf.signature);
+    const validLeaf = await (0, _crypto_1.xeddsaVerify)(intermediate.key, leaf.details, leaf.signature);
     if (!validLeaf) {
         throw new Error('leaf certificate signature is invalid');
     }

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");
@@ -17,7 +16,7 @@ function resolvePayload(payload) {
     if (payload instanceof Uint8Array) {
         return Promise.resolve(payload);
     }
-    return Promise.resolve(payload()).then((value) => (0, bytes_1.toBytesView)(value));
+    return Promise.resolve(payload());
 }
 async function resolveHandshakePayload(config) {
     if (config.isRegistered) {
@@ -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;
@@ -60,11 +61,10 @@ class WaNoiseSession {
         this.closedError = null;
         this.noiseSocket = null;
         this.serverStaticKey = null;
+        this.trustedRootCa = undefined;
         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();
@@ -72,9 +72,7 @@ class WaNoiseSession {
             isRegistered: config.isRegistered,
             hasServerStaticKey: !!config.serverStaticKey
         });
-        const protocolHeader = config.protocolHeader
-            ? (0, bytes_1.toBytesView)(config.protocolHeader)
-            : constants_2.WA_PROTO_HEADER;
+        const protocolHeader = config.protocolHeader ?? constants_2.WA_PROTO_HEADER;
         const introFrame = config.routingInfo && config.routingInfo.length > 0
             ? (0, bytes_1.concatBytes)([buildRoutingInfoPrefix(config.routingInfo), protocolHeader])
             : protocolHeader;
@@ -84,6 +82,7 @@ class WaNoiseSession {
             resolveHandshakePayload(config)
         ]);
         const verifyCertificates = config.verifyCertificateChain !== false;
+        this.trustedRootCa = config.trustedRootCa;
         if (config.serverStaticKey && config.serverStaticKey.length === 32) {
             this.logger.info('noise session attempting resume handshake (IK)');
             this.noiseSocket = await this.resumeHandshake(config.serverStaticKey, config.clientStaticKeyPair, ephemeralKeyPair, payload, protocolHeader, verifyCertificates);
@@ -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,11 @@ class WaNoiseSession {
         this.closedError = null;
         this.noiseSocket = null;
         this.serverStaticKey = null;
+        this.trustedRootCa = undefined;
+        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 +218,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({
@@ -217,11 +248,15 @@ class WaNoiseSession {
         if (!serverHello.payload) {
             throw new Error('noise resume handshake missing certificate payload');
         }
-        const serverEphemeral = (0, bytes_1.toBytesView)(serverHello.ephemeral);
+        const serverEphemeral = 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));
-        await handshake.decrypt((0, bytes_1.toBytesView)(serverHello.payload));
+        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(serverHello.payload);
         this.serverStaticKey = serverStaticKey;
         this.logger.info('noise resume handshake successful without fallback');
         return { socket: await handshake.finish(), serverHelloFrame: null };
@@ -239,14 +274,14 @@ class WaNoiseSession {
         if (!serverHello?.ephemeral || !serverHello.static || !serverHello.payload) {
             throw new Error('noise full handshake missing server hello fields');
         }
-        const serverEphemeral = (0, bytes_1.toBytesView)(serverHello.ephemeral);
+        const serverEphemeral = serverHello.ephemeral;
         await handshake.authenticate(serverEphemeral);
         await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral));
-        const serverStatic = await handshake.decrypt((0, bytes_1.toBytesView)(serverHello.static));
+        const serverStatic = await handshake.decrypt(serverHello.static);
         await handshake.mixIntoKey(await _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverStatic));
-        const certificate = await handshake.decrypt((0, bytes_1.toBytesView)(serverHello.payload));
+        const certificate = await handshake.decrypt(serverHello.payload);
         if (verifyCertificates) {
-            await (0, WaNoiseCert_1.verifyNoiseCertificateChain)(certificate, serverStatic);
+            await (0, WaNoiseCert_1.verifyNoiseCertificateChain)(certificate, serverStatic, this.trustedRootCa);
             this.logger.trace('noise certificate chain verified');
         }
         this.serverStaticKey = serverStatic;
@@ -322,10 +357,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/WaAppStateCrypto.d.ts

@@ -1,10 +1,11 @@
-import type { Proto } from '..';
+import { type CryptoKey } from '../crypto/core/primitives';
+import { type Proto } from '..';
 interface WaAppStateDerivedKeys {
-    readonly indexKey: Uint8Array;
-    readonly valueEncryptionKey: Uint8Array;
-    readonly valueMacKey: Uint8Array;
-    readonly snapshotMacKey: Uint8Array;
-    readonly patchMacKey: Uint8Array;
+    readonly indexHmacKey: CryptoKey;
+    readonly valueEncryptionAesKey: CryptoKey;
+    readonly valueMacHmacKey: CryptoKey;
+    readonly snapshotMacHmacKey: CryptoKey;
+    readonly patchMacHmacKey: CryptoKey;
 }
 interface WaAppStateEncryptedMutation {
     readonly indexMac: Uint8Array;
@@ -21,10 +22,12 @@ interface WaAppStateDecryptedMutation {
 export declare class WaAppStateCrypto {
     private readonly derivedKeysCache;
     private readonly derivedKeysCacheMaxSize;
-    constructor(derivedKeysCacheMaxSize?: number);
+    private readonly skipMacVerification;
+    constructor(derivedKeysCacheMaxSize?: number, skipMacVerification?: boolean);
+    get isMacVerificationSkipped(): boolean;
     clearCache(): void;
     deriveKeys(keyData: Uint8Array): Promise<WaAppStateDerivedKeys>;
-    generateIndexMac(indexKey: Uint8Array, indexBytes: Uint8Array): Promise<Uint8Array>;
+    generateIndexMac(indexHmacKey: CryptoKey, indexBytes: Uint8Array): Promise<Uint8Array>;
     encryptMutation(args: {
         readonly operation: number;
         readonly keyId: Uint8Array;

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

@@ -1,6 +1,6 @@
-import type { AppStateCollectionName, WaAppStateMissingKeysEvent, WaAppStateSyncOptions, WaAppStateStoreData, WaAppStateSyncResult, WaAppStateSyncKey } from './types';
+import type { AppStateCollectionName, WaAppStateMissingKeysEvent, WaAppStateStoreData, WaAppStateSyncKey, WaAppStateSyncOptions, WaAppStateSyncResult } from './types';
 import type { Logger } from '../infra/log/types';
-import type { Proto } from '..';
+import { type Proto } from '..';
 import type { WaAppStateStore } from '../store/contracts/appstate.store';
 import type { BinaryNode } from '../transport/types';
 interface WaAppStateSyncClientOptions {
@@ -11,6 +11,8 @@ interface WaAppStateSyncClientOptions {
     readonly hostDomain?: string;
     readonly defaultTimeoutMs?: number;
     readonly onMissingKeys?: (event: WaAppStateMissingKeysEvent) => Promise<void>;
+    readonly skipMacVerification?: boolean;
+    readonly mobilePrimary?: boolean;
 }
 export declare class WaAppStateMissingKeyError extends Error {
     readonly keyId: Uint8Array | null;
@@ -26,10 +28,12 @@ export declare class WaAppStateSyncClient {
     private readonly defaultTimeoutMs;
     private readonly onMissingKeys?;
     private readonly crypto;
+    private readonly mobilePrimary;
     private syncContext;
     private syncPromise;
     constructor(options: WaAppStateSyncClientOptions);
     exportState(): Promise<WaAppStateStoreData>;
+    ensureInitialSyncKey(): Promise<WaAppStateSyncKey>;
     importSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
     importSyncKeyShare(share: Proto.Message.IAppStateSyncKeyShare): Promise<number>;
     sync(options?: WaAppStateSyncOptions): Promise<WaAppStateSyncResult>;

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 './response-parser';
 export { WaAppStateSyncClient } from './WaAppStateSyncClient';

package/dist/types/appstate/{WaAppStateSyncResponseParser.d.ts → response-parser.d.ts}

@@ -1,5 +1,5 @@
 import type { AppStateCollectionName, AppStateCollectionState } from './types';
-import type { Proto } from '..';
+import { type Proto } from '..';
 import type { BinaryNode } from '../transport/types';
 export interface CollectionResponsePayload {
     readonly collection: AppStateCollectionName;

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

@@ -1,5 +1,5 @@
 import type { Proto } from '..';
-import type { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES } from '../protocol/constants';
+import type { WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_COLLECTIONS } from '../protocol/constants';
 export type AppStateCollectionName = (typeof WA_APP_STATE_COLLECTIONS)[keyof typeof WA_APP_STATE_COLLECTIONS];
 export type AppStateCollectionState = (typeof WA_APP_STATE_COLLECTION_STATES)[keyof typeof WA_APP_STATE_COLLECTION_STATES];
 export interface WaAppStateSyncKey {

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>;