zapo-js 0.2.0 → 0.3.0

package/dist/esm/transport/node/builders/email.js

@@ -0,0 +1,65 @@
+import { WA_DEFAULTS } from '../../../protocol/defaults.js';
+import { WA_EMAIL_LIMITS, WA_EMAIL_TAGS, WA_EMAIL_XMLNS } from '../../../protocol/email.js';
+import { buildIqNode } from '../../node/query.js';
+export function buildGetEmailIq() {
+    return buildIqNode('get', WA_DEFAULTS.HOST_DOMAIN, WA_EMAIL_XMLNS, [
+        { tag: WA_EMAIL_TAGS.EMAIL, attrs: {} }
+    ]);
+}
+export function buildSetEmailIq(email, context) {
+    if (email.length === 0 || email.length > WA_EMAIL_LIMITS.EMAIL_MAX_LENGTH) {
+        throw new Error(`email length must be between 1 and ${WA_EMAIL_LIMITS.EMAIL_MAX_LENGTH} chars`);
+    }
+    const emailChildren = [];
+    if (context !== undefined) {
+        emailChildren.push({ tag: WA_EMAIL_TAGS.CONTEXT, attrs: {}, content: context });
+    }
+    emailChildren.push({ tag: WA_EMAIL_TAGS.EMAIL_ADDRESS, attrs: {}, content: email });
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_EMAIL_XMLNS, [
+        { tag: WA_EMAIL_TAGS.EMAIL, attrs: {}, content: emailChildren }
+    ]);
+}
+export function buildRequestEmailVerificationCodeIq(input) {
+    assertLocaleField('languageCode', input.languageCode);
+    assertLocaleField('localeCode', input.localeCode);
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_EMAIL_XMLNS, [
+        {
+            tag: WA_EMAIL_TAGS.VERIFY_EMAIL,
+            attrs: {},
+            content: [
+                { tag: WA_EMAIL_TAGS.LG, attrs: {}, content: input.languageCode },
+                { tag: WA_EMAIL_TAGS.LC, attrs: {}, content: input.localeCode }
+            ]
+        }
+    ]);
+}
+export function buildVerifyEmailCodeIq(code) {
+    if (code.length !== WA_EMAIL_LIMITS.CODE_LENGTH) {
+        throw new Error(`verification code must be exactly ${WA_EMAIL_LIMITS.CODE_LENGTH} chars`);
+    }
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_EMAIL_XMLNS, [
+        {
+            tag: WA_EMAIL_TAGS.VERIFY_EMAIL,
+            attrs: {},
+            content: [{ tag: WA_EMAIL_TAGS.CODE, attrs: {}, content: code }]
+        }
+    ]);
+}
+export function buildConfirmEmailIq(context) {
+    const children = context !== undefined
+        ? [{ tag: WA_EMAIL_TAGS.CONTEXT, attrs: {}, content: context }]
+        : undefined;
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_EMAIL_XMLNS, [
+        {
+            tag: WA_EMAIL_TAGS.CONFIRM_EMAIL,
+            attrs: {},
+            ...(children !== undefined ? { content: children } : {})
+        }
+    ]);
+}
+function assertLocaleField(field, value) {
+    if (value.length < WA_EMAIL_LIMITS.LOCALE_MIN_LENGTH ||
+        value.length > WA_EMAIL_LIMITS.LOCALE_MAX_LENGTH) {
+        throw new Error(`${field} must be between ${WA_EMAIL_LIMITS.LOCALE_MIN_LENGTH} and ${WA_EMAIL_LIMITS.LOCALE_MAX_LENGTH} chars`);
+    }
+}

package/dist/esm/transport/node/builders/offline.js

@@ -0,0 +1,14 @@
+import { WA_NODE_TAGS } from '../../../protocol/constants.js';
+export function buildOfflineBatchNode(count) {
+    return {
+        tag: WA_NODE_TAGS.INFO_BULLETIN,
+        attrs: {},
+        content: [
+            {
+                tag: 'offline_batch',
+                attrs: { count: String(count) },
+                content: undefined
+            }
+        ]
+    };
+}

package/dist/esm/transport/node/builders/prekeys.js

@@ -1,7 +1,8 @@
+import { toRawPubKey } from '../../../crypto/core/keys.js';
 import { WA_DEFAULTS, WA_NODE_TAGS, WA_XMLNS } from '../../../protocol/constants.js';
 import { SIGNAL_KEY_BUNDLE_TYPE_BYTES } from '../../../signal/api/constants.js';
 import { buildIqNode } from '../../node/query.js';
-import { intToBytes, toBytesView } from '../../../util/bytes.js';
+import { intToBytes } from '../../../util/bytes.js';
 function buildSignedPreKeyNode(signedPreKey) {
     return {
         tag: WA_NODE_TAGS.SKEY,
@@ -15,55 +16,51 @@ function buildSignedPreKeyNode(signedPreKey) {
             {
                 tag: WA_NODE_TAGS.VALUE,
                 attrs: {},
-                content: toBytesView(signedPreKey.keyPair.pubKey)
+                content: toRawPubKey(signedPreKey.keyPair.pubKey)
             },
             {
                 tag: WA_NODE_TAGS.SIGNATURE,
                 attrs: {},
-                content: toBytesView(signedPreKey.signature)
+                content: signedPreKey.signature
             }
         ]
     };
 }
 export function buildPreKeyUploadIq(registrationInfo, signedPreKey, preKeys) {
-    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.SIGNAL, [
-        {
-            tag: WA_NODE_TAGS.REGISTRATION,
-            attrs: {},
-            content: intToBytes(4, registrationInfo.registrationId)
-        },
-        {
-            tag: WA_NODE_TAGS.TYPE,
-            attrs: {},
-            content: SIGNAL_KEY_BUNDLE_TYPE_BYTES
-        },
-        {
-            tag: WA_NODE_TAGS.IDENTITY,
-            attrs: {},
-            content: toBytesView(registrationInfo.identityKeyPair.pubKey)
-        },
-        {
-            tag: WA_NODE_TAGS.LIST,
+    const children = [];
+    children.push({
+        tag: WA_NODE_TAGS.IDENTITY,
+        attrs: {},
+        content: toRawPubKey(registrationInfo.identityKeyPair.pubKey)
+    }, {
+        tag: WA_NODE_TAGS.REGISTRATION,
+        attrs: {},
+        content: intToBytes(4, registrationInfo.registrationId)
+    }, {
+        tag: WA_NODE_TAGS.TYPE,
+        attrs: {},
+        content: SIGNAL_KEY_BUNDLE_TYPE_BYTES
+    }, {
+        tag: WA_NODE_TAGS.LIST,
+        attrs: {},
+        content: preKeys.map((record) => ({
+            tag: WA_NODE_TAGS.KEY,
             attrs: {},
-            content: preKeys.map((record) => ({
-                tag: WA_NODE_TAGS.KEY,
-                attrs: {},
-                content: [
-                    {
-                        tag: WA_NODE_TAGS.ID,
-                        attrs: {},
-                        content: intToBytes(3, record.keyId)
-                    },
-                    {
-                        tag: WA_NODE_TAGS.VALUE,
-                        attrs: {},
-                        content: toBytesView(record.keyPair.pubKey)
-                    }
-                ]
-            }))
-        },
-        buildSignedPreKeyNode(signedPreKey)
-    ]);
+            content: [
+                {
+                    tag: WA_NODE_TAGS.ID,
+                    attrs: {},
+                    content: intToBytes(3, record.keyId)
+                },
+                {
+                    tag: WA_NODE_TAGS.VALUE,
+                    attrs: {},
+                    content: toRawPubKey(record.keyPair.pubKey)
+                }
+            ]
+        }))
+    }, buildSignedPreKeyNode(signedPreKey));
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.SIGNAL, children);
 }
 export function buildSignedPreKeyRotateIq(signedPreKey) {
     return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.SIGNAL, [

package/dist/esm/transport/node/builders/presence.js

@@ -0,0 +1,13 @@
+export function buildPresenceNode(input) {
+    const attrs = {};
+    if (input?.type) {
+        attrs.type = input.type;
+    }
+    if (input?.name) {
+        attrs.name = input.name;
+    }
+    return {
+        tag: 'presence',
+        attrs
+    };
+}

package/dist/esm/transport/node/builders/privacy-token.js

@@ -1,29 +1,25 @@
-import { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../../protocol/nodes.js';
+import { WA_DEFAULTS } from '../../../protocol/defaults.js';
+import { toUserJid } from '../../../protocol/jid.js';
+import { WA_XMLNS } from '../../../protocol/nodes.js';
 import { WA_PRIVACY_TOKEN_TAGS, WA_PRIVACY_TOKEN_TYPES } from '../../../protocol/privacy-token.js';
+import { buildIqNode } from '../../node/query.js';
 export function buildPrivacyTokenIqNode(input) {
-    return {
-        tag: WA_NODE_TAGS.IQ,
-        attrs: {
-            type: WA_IQ_TYPES.SET,
-            xmlns: WA_XMLNS.PRIVACY
-        },
-        content: [
-            {
-                tag: WA_PRIVACY_TOKEN_TAGS.TOKENS,
-                attrs: {},
-                content: [
-                    {
-                        tag: WA_PRIVACY_TOKEN_TAGS.TOKEN,
-                        attrs: {
-                            jid: input.jid,
-                            t: String(input.timestampS),
-                            type: input.type ?? WA_PRIVACY_TOKEN_TYPES.TRUSTED_CONTACT
-                        }
+    return buildIqNode('set', WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.PRIVACY, [
+        {
+            tag: WA_PRIVACY_TOKEN_TAGS.TOKENS,
+            attrs: {},
+            content: [
+                {
+                    tag: WA_PRIVACY_TOKEN_TAGS.TOKEN,
+                    attrs: {
+                        jid: toUserJid(input.jid),
+                        t: String(input.timestampS),
+                        type: input.type ?? WA_PRIVACY_TOKEN_TYPES.TRUSTED_CONTACT
                     }
-                ]
-            }
-        ]
-    };
+                }
+            ]
+        }
+    ]);
 }
 export function buildTcTokenMessageNode(token) {
     return {

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

@@ -75,7 +75,7 @@ export function buildRetryReceiptNode(input) {
         id: input.originalMsgId,
         t: input.t
     };
-    if (input.error !== undefined) {
+    if (input.error !== undefined && input.error !== 0) {
         retryAttrs.error = String(input.error);
     }
     const content = [

package/dist/esm/transport/node/helpers.js

@@ -126,6 +126,14 @@ export function decodeNodeContentUtf8OrBytes(value, field) {
     }
     throw new Error(`node ${field} has no binary content`);
 }
+export function getNodeTextContent(node) {
+    const content = node.content;
+    if (content instanceof Uint8Array)
+        return TEXT_DECODER.decode(content);
+    if (typeof content === 'string')
+        return content;
+    return undefined;
+}
 export function decodeNodeContentBase64OrBytes(value, field) {
     if (value === null || value === undefined) {
         throw new Error(`missing binary node content for ${field}`);
@@ -155,3 +163,19 @@ export async function createNodeIdGenerator() {
         }
     };
 }
+export function createMobileNodeIdGenerator() {
+    let featureCounter = 0;
+    let systemCounter = 0;
+    return {
+        prefix: '0',
+        next() {
+            const id = `0${featureCounter.toString(16)}`;
+            featureCounter = (featureCounter + 1) & 0xffff;
+            return id;
+        },
+        nextSystem() {
+            systemCounter = (systemCounter + 1) & 0xffff;
+            return systemCounter.toString(16);
+        }
+    };
+}

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

@@ -0,0 +1,152 @@
+import { TEXT_DECODER } from '../../../util/bytes.js';
+let cachedArgo;
+async function loadArgo() {
+    if (cachedArgo !== undefined)
+        return cachedArgo;
+    try {
+        cachedArgo = (await import('argo-codec'));
+    }
+    catch {
+        cachedArgo = null;
+    }
+    return cachedArgo;
+}
+export 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;
+export 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 = 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/esm/transport/node/mex/client.js

@@ -0,0 +1,83 @@
+import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../../protocol/constants.js';
+import { decodeNodeContentUtf8OrBytes, findNodeChild } from '../../node/helpers.js';
+import { decodeMexArgoResponse, isMexArgoDecoderAvailable } from '../../node/mex/argo-decoder.js';
+import { assertIqResult } from '../../node/query.js';
+import { TEXT_DECODER } from '../../../util/bytes.js';
+import { toError } from '../../../util/primitives.js';
+const MEX_DEFAULT_TIMEOUT_MS = 32000;
+export async function dispatchMexQuery(socket, args) {
+    const body = JSON.stringify({
+        queryId: args.clientDocId,
+        variables: args.variables
+    });
+    const node = {
+        tag: WA_NODE_TAGS.IQ,
+        attrs: {
+            ...(args.iqId ? { id: args.iqId } : {}),
+            to: WA_DEFAULTS.HOST_DOMAIN,
+            type: WA_IQ_TYPES.GET,
+            xmlns: 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);
+    assertIqResult(response, `mex/${args.opName}`);
+    const data = await parseMexResultPayload(response, args.opName);
+    return { raw: response, data };
+}
+async function parseMexResultPayload(node, opName) {
+    const result = findNodeChild(node, 'result');
+    if (!result) {
+        throw new Error(`mex/${opName} response missing <result>`);
+    }
+    const format = result.attrs.format ?? 'json';
+    const rawBytes = decodeNodeContentUtf8OrBytes(result.content, `mex/${opName}/result`);
+    if (format === 'argo') {
+        if (!(await 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 decodeMexArgoResponse(rawBytes);
+        }
+        catch (error) {
+            throw new Error(`mex/${opName} argo decode failed: ${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(TEXT_DECODER.decode(rawBytes)), opName);
+}
+function extractVisibleStrings(bytes) {
+    return 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/esm/transport/node/mex/persist-ids.js

@@ -0,0 +1,10 @@
+export const WA_MEX_PERSIST_IDS = Object.freeze({
+    WWWGetCertificates: Object.freeze({
+        docId: '25094190163544446',
+        clientDocId: '16428758503015954638431529919'
+    }),
+    WWWCreateUser: Object.freeze({
+        docId: '8548056818544135',
+        clientDocId: '25777518041400352865446016972'
+    })
+});

package/dist/esm/transport/noise/WaClientPayload.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { md5Bytes } from '../../crypto/core/primitives.js';
 import { proto } from '../../proto.js';
 import { DEFAULT_VERSION_BASE } from '../noise/constants.js';
-import { intToBytes, toBytesView } from '../../util/bytes.js';
+import { intToBytes } from '../../util/bytes.js';
 function parseVersion(versionBase) {
     const [p = '2', s = '3000', t = '0'] = versionBase.split('.');
     const primary = Number.parseInt(p, 10);
@@ -15,13 +15,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.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
@@ -144,16 +151,14 @@ export function buildRegistrationPayload(config) {
     const version = parseVersion(versionBase);
     const common = buildCommonPayload(config, version);
     const devicePairingData = {
-        buildHash: config.buildHash ? toBytesView(config.buildHash) : md5Bytes(versionBase),
-        deviceProps: config.deviceProps
-            ? toBytesView(config.deviceProps)
-            : defaultDeviceProps(versionBase, config, version),
+        buildHash: config.buildHash ?? md5Bytes(versionBase),
+        deviceProps: config.deviceProps ?? defaultDeviceProps(versionBase, config, version),
         eRegid: intToBytes(4, registrationId),
         eKeytype: intToBytes(1, 5),
-        eIdent: toBytesView(config.registrationInfo.identityKeyPair.pubKey),
+        eIdent: config.registrationInfo.identityKeyPair.pubKey,
         eSkeyId: intToBytes(3, signedPreKeyId),
-        eSkeyVal: toBytesView(config.signedPreKey.keyPair.pubKey),
-        eSkeySig: toBytesView(config.signedPreKey.signature)
+        eSkeyVal: config.signedPreKey.keyPair.pubKey,
+        eSkeySig: config.signedPreKey.signature
     };
     return proto.ClientPayload.encode({
         ...common,

package/dist/esm/transport/noise/WaFrameCodec.js

@@ -1,4 +1,4 @@
-import { EMPTY_BYTES, toBytesView } from '../../util/bytes.js';
+import { EMPTY_BYTES } from '../../util/bytes.js';
 const WA_MAX_FRAME_LENGTH = (1 << 24) - 1;
 function frameLength(header) {
     return (header[0] << 16) | (header[1] << 8) | header[2];
@@ -11,7 +11,7 @@ export class WaFrameCodec {
         if (maxFrameLength >= 1 << 24) {
             throw new Error('maxFrameLength must be lower than protocol limit (16777216)');
         }
-        this.introFrame = introFrame && introFrame.length > 0 ? toBytesView(introFrame) : null;
+        this.introFrame = introFrame && introFrame.length > 0 ? introFrame : null;
         this.maxFrameLength = maxFrameLength;
         this.introSent = false;
         this.buffered = EMPTY_BYTES;

package/dist/esm/transport/noise/WaMobileClientPayload.js

@@ -0,0 +1,53 @@
+import { randomUUID } from 'node:crypto';
+import { proto } from '../../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)
+    };
+}
+export 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.ClientPayload.UserAgent.Platform.ANDROID,
+        releaseChannel: 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 ?? randomUUID(),
+        localeLanguageIso6391: info.localeLanguageIso6391 ?? 'en',
+        localeCountryIso31661Alpha2: info.localeCountryIso31661Alpha2 ?? 'US',
+        deviceType: proto.ClientPayload.UserAgent.DeviceType.PHONE,
+        deviceBoard: info.deviceBoard,
+        deviceModelType: info.deviceModelType
+    };
+    return proto.ClientPayload.encode({
+        passive: config.passive === true,
+        pull: config.pull ?? true,
+        product: proto.ClientPayload.Product.WHATSAPP,
+        connectType: config.connectType ?? proto.ClientPayload.ConnectType.CELLULAR_UNKNOWN,
+        connectReason: config.connectReason ?? 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();
+}