zapo-js 0.2.0 → 0.3.0

package/dist/transport/node/mex/argo-decoder.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMexArgoDecoderAvailable = isMexArgoDecoderAvailable;
+exports.decodeMexArgoResponse = decodeMexArgoResponse;
+const bytes_1 = require("../../../util/bytes");
+let cachedArgo;
+async function loadArgo() {
+    if (cachedArgo !== undefined)
+        return cachedArgo;
+    try {
+        cachedArgo = (await Promise.resolve().then(() => __importStar(require('argo-codec'))));
+    }
+    catch {
+        cachedArgo = null;
+    }
+    return cachedArgo;
+}
+async function isMexArgoDecoderAvailable() {
+    return (await loadArgo()) !== null;
+}
+const LABEL_NULL = -1;
+const LABEL_ABSENT = -2;
+const BACKREF_BASE = -4;
+const DESC_NULL = -1;
+const DESC_FALSE = 0;
+const DESC_TRUE = 1;
+const DESC_OBJECT = 2;
+const DESC_LIST = 3;
+const DESC_STRING = 4;
+const DESC_BYTES = 5;
+const DESC_INT = 6;
+const DESC_FLOAT = 7;
+const FLAG_INLINE_EVERYTHING = 1 << 0;
+const FLAG_HAS_USER_FLAGS = 1 << 6;
+async function decodeMexArgoResponse(bytes) {
+    const argo = await loadArgo();
+    if (!argo)
+        throw new Error('argo-codec not installed');
+    const r = new argo.Reader(bytes);
+    const flags = r.bitset();
+    const inline = (flags & FLAG_INLINE_EVERYTHING) !== 0;
+    if (flags & FLAG_HAS_USER_FLAGS)
+        r.bitset();
+    const segments = [];
+    if (!inline) {
+        while (r.pos < r.end) {
+            const len = r.label();
+            segments.push(new argo.Reader(r.bytes(len)));
+        }
+        if (segments.length === 0)
+            throw new Error('mex argo: missing core segment');
+    }
+    else {
+        segments.push(r);
+    }
+    const core = segments[segments.length - 1];
+    const blocks = inline ? new Map() : indexBlocks(segments.slice(0, -1));
+    const ctx = { core, blocks, stringSeen: [] };
+    const data = readDesc(ctx);
+    const errors = [];
+    if (core.pos < core.end) {
+        const errCount = core.label();
+        for (let i = 0; i < errCount; i++)
+            errors.push(readError(ctx));
+    }
+    return { data, errors };
+}
+function indexBlocks(slices) {
+    const m = new Map();
+    const keys = ['String', 'Int', 'Float', 'Bytes'];
+    for (let i = 0; i < slices.length && i < keys.length; i++)
+        m.set(keys[i], slices[i]);
+    return m;
+}
+function getBlock(ctx, key) {
+    const b = ctx.blocks.get(key);
+    if (!b)
+        throw new Error(`mex argo: block '${key}' missing`);
+    return b;
+}
+function readStringFromBlock(ctx) {
+    const lab = ctx.core.label();
+    if (lab < BACKREF_BASE + 1) {
+        const idx = -lab + BACKREF_BASE;
+        return ctx.stringSeen[idx];
+    }
+    const block = getBlock(ctx, 'String');
+    const s = bytes_1.TEXT_DECODER.decode(block.bytes(lab));
+    ctx.stringSeen.push(s);
+    return s;
+}
+function readDesc(ctx) {
+    const m = ctx.core.label();
+    switch (m) {
+        case DESC_NULL:
+            return null;
+        case DESC_FALSE:
+            return false;
+        case DESC_TRUE:
+            return true;
+        case DESC_STRING:
+            return readStringFromBlock(ctx);
+        case DESC_INT:
+            return getBlock(ctx, 'Int').label();
+        case DESC_FLOAT:
+            throw new Error('mex argo: DESC_FLOAT not implemented');
+        case DESC_BYTES:
+            throw new Error('mex argo: DESC_BYTES not implemented');
+        case DESC_LIST: {
+            const n = ctx.core.label();
+            const out = [];
+            for (let i = 0; i < n; i++)
+                out.push(readDesc(ctx));
+            return out;
+        }
+        case DESC_OBJECT: {
+            const n = ctx.core.label();
+            const out = {};
+            for (let i = 0; i < n; i++) {
+                const key = readStringFromBlock(ctx);
+                out[key] = readDesc(ctx);
+            }
+            return out;
+        }
+        default:
+            throw new Error(`mex argo: unknown DESC marker ${m}`);
+    }
+}
+function readError(ctx) {
+    const message = readStringFromBlock(ctx);
+    skipOptional(ctx); // location — never observed in MEX errors so far
+    const path = readPath(ctx);
+    const extensions = readOptionalDesc(ctx);
+    return { message, path, extensions };
+}
+function skipOptional(ctx) {
+    const lab = ctx.core.label();
+    if (lab !== LABEL_ABSENT && lab !== LABEL_NULL) {
+        // Present but not yet structurally decoded; would need a typed inner read here.
+        // For locations specifically we have no observed sample; bail loudly if hit.
+        throw new Error(`mex argo: unexpected optional present (lab=${lab}); add support`);
+    }
+}
+function readPath(ctx) {
+    const lab = ctx.core.label();
+    if (lab === LABEL_ABSENT || lab === LABEL_NULL)
+        return null;
+    return lab;
+}
+function readOptionalDesc(ctx) {
+    const lab = ctx.core.label();
+    if (lab === LABEL_ABSENT || lab === LABEL_NULL)
+        return null;
+    const v = readDesc(ctx);
+    return typeof v === 'object' && v !== null ? v : null;
+}

package/dist/transport/node/mex/client.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchMexQuery = dispatchMexQuery;
+const constants_1 = require("../../../protocol/constants");
+const helpers_1 = require("../../node/helpers");
+const argo_decoder_1 = require("../../node/mex/argo-decoder");
+const query_1 = require("../../node/query");
+const bytes_1 = require("../../../util/bytes");
+const primitives_1 = require("../../../util/primitives");
+const MEX_DEFAULT_TIMEOUT_MS = 32000;
+async function dispatchMexQuery(socket, args) {
+    const body = JSON.stringify({
+        queryId: args.clientDocId,
+        variables: args.variables
+    });
+    const node = {
+        tag: constants_1.WA_NODE_TAGS.IQ,
+        attrs: {
+            ...(args.iqId ? { id: args.iqId } : {}),
+            to: constants_1.WA_DEFAULTS.HOST_DOMAIN,
+            type: constants_1.WA_IQ_TYPES.GET,
+            xmlns: constants_1.WA_XMLNS.MEX
+        },
+        content: [
+            {
+                tag: 'query',
+                attrs: { query_id: args.docId },
+                content: body
+            }
+        ]
+    };
+    const response = await socket.query(node, args.timeoutMs ?? MEX_DEFAULT_TIMEOUT_MS);
+    (0, query_1.assertIqResult)(response, `mex/${args.opName}`);
+    const data = await parseMexResultPayload(response, args.opName);
+    return { raw: response, data };
+}
+async function parseMexResultPayload(node, opName) {
+    const result = (0, helpers_1.findNodeChild)(node, 'result');
+    if (!result) {
+        throw new Error(`mex/${opName} response missing <result>`);
+    }
+    const format = result.attrs.format ?? 'json';
+    const rawBytes = (0, helpers_1.decodeNodeContentUtf8OrBytes)(result.content, `mex/${opName}/result`);
+    if (format === 'argo') {
+        if (!(await (0, argo_decoder_1.isMexArgoDecoderAvailable)())) {
+            throw new Error(`mex/${opName} argo response received but 'argo-codec' not installed; ${rawBytes.length}B; ` +
+                `strings: ${extractVisibleStrings(rawBytes)}`);
+        }
+        let decoded;
+        try {
+            decoded = await (0, argo_decoder_1.decodeMexArgoResponse)(rawBytes);
+        }
+        catch (error) {
+            throw new Error(`mex/${opName} argo decode failed: ${(0, primitives_1.toError)(error).message}; ` +
+                `${rawBytes.length}B; strings: ${extractVisibleStrings(rawBytes)}`);
+        }
+        if (decoded.errors.length > 0) {
+            const summary = decoded.errors
+                .map((e) => {
+                const code = e.extensions?.error_code ?? e.extensions?.code ?? '?';
+                const sev = e.extensions?.severity;
+                return `${code}${sev ? `/${String(sev)}` : ''}: ${e.message} @${e.path ?? ''}`;
+            })
+                .join('; ');
+            throw new Error(`mex/${opName} errors: ${summary}`);
+        }
+        return decoded.data;
+    }
+    return extractGraphQlData(JSON.parse(bytes_1.TEXT_DECODER.decode(rawBytes)), opName);
+}
+function extractVisibleStrings(bytes) {
+    return bytes_1.TEXT_DECODER.decode(bytes)
+        .replace(/[\x00-\x1f\x7f-\xff]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function extractGraphQlData(payload, opName) {
+    const json = (payload ?? {});
+    if (json.errors && json.errors.length > 0) {
+        const summary = json.errors
+            .map((e) => `${e.extensions?.error_code ?? '?'}: ${e.message ?? '?'} @${(e.path ?? []).join('.')}`)
+            .join('; ');
+        throw new Error(`mex/${opName} errors: ${summary}`);
+    }
+    return json.data ?? null;
+}

package/dist/transport/node/mex/persist-ids.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WA_MEX_PERSIST_IDS = void 0;
+exports.WA_MEX_PERSIST_IDS = Object.freeze({
+    WWWGetCertificates: Object.freeze({
+        docId: '25094190163544446',
+        clientDocId: '16428758503015954638431529919'
+    }),
+    WWWCreateUser: Object.freeze({
+        docId: '8548056818544135',
+        clientDocId: '25777518041400352865446016972'
+    })
+});

package/dist/transport/noise/WaClientPayload.js

@@ -19,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;
@@ -148,16 +155,14 @@ function buildRegistrationPayload(config) {
     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, version),
+        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, 5),
-        eIdent: (0, bytes_1.toBytesView)(config.registrationInfo.identityKeyPair.pubKey),
+        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 (signatureInput.length !== 64) {
-        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 _crypto_1.Ed25519.verify(message, signature, edwardsPublicKey);
-}
+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

@@ -16,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) {
@@ -61,6 +61,7 @@ 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;
@@ -71,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;
@@ -83,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);
@@ -184,6 +184,7 @@ class WaNoiseSession {
         this.closedError = null;
         this.noiseSocket = null;
         this.serverStaticKey = null;
+        this.trustedRootCa = undefined;
         this.writeChain = Promise.resolve();
         this.readChain = Promise.resolve();
     }
@@ -247,7 +248,7 @@ 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);
         const [dh1, dh2] = await Promise.all([
             _crypto_1.X25519.scalarMult(ephemeralKeyPair.privKey, serverEphemeral),
@@ -255,7 +256,7 @@ class WaNoiseSession {
         ]);
         await handshake.mixIntoKey(dh1);
         await handshake.mixIntoKey(dh2);
-        await handshake.decrypt((0, bytes_1.toBytesView)(serverHello.payload));
+        await handshake.decrypt(serverHello.payload);
         this.serverStaticKey = serverStaticKey;
         this.logger.info('noise resume handshake successful without fallback');
         return { socket: await handshake.finish(), serverHelloFrame: null };
@@ -273,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;

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/index.d.ts

@@ -3,5 +3,5 @@ export type { AppStateCollectionName, WaAppStateStoreData, WaAppStateSyncKey, Wa
 export { encodeAppStateFingerprint, decodeAppStateFingerprint, decodeAppStateCollections, decodeAppStateSyncKeys } from './encoding';
 export * from './utils';
 export { WaAppStateCrypto } from './WaAppStateCrypto';
-export { parseSyncResponse } 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 {