zapo-js 0.1.2 → 0.3.0

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

@@ -1,6 +1,7 @@
-import { WA_MESSAGE_TAGS, WA_NODE_TAGS } from '../../../protocol/constants.js';
+import { WA_NODE_TAGS } from '../../../protocol/constants.js';
 import { RETRY_RECEIPT_VERSION } from '../../../retry/constants.js';
 import { SIGNAL_KEY_BUNDLE_TYPE_BYTES } from '../../../signal/api/constants.js';
+import { buildReceiptNode } from '../../node/builders/global.js';
 import { intToBytes } from '../../../util/bytes.js';
 function buildRetryKeysNode(keys) {
     const content = [
@@ -68,30 +69,13 @@ function buildRetryKeysNode(keys) {
     };
 }
 export 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: RETRY_RECEIPT_VERSION,
         count: String(input.retryCount),
         id: input.originalMsgId,
         t: input.t
     };
-    if (input.error !== undefined) {
+    if (input.error !== undefined && input.error !== 0) {
         retryAttrs.error = String(input.error);
     }
     const content = [
@@ -108,9 +92,13 @@ export function buildRetryReceiptNode(input) {
     if (input.keys) {
         content.push(buildRetryKeysNode(input.keys));
     }
-    return {
-        tag: WA_MESSAGE_TAGS.RECEIPT,
-        attrs,
+    return buildReceiptNode({
+        kind: 'retry_custom',
+        id: input.stanzaId,
+        to: input.to,
+        participant: input.participant,
+        recipient: input.recipient,
+        categoryPeer: input.categoryPeer,
         content
-    };
+    });
 }

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

@@ -14,6 +14,10 @@ export 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 buildIqNode('get', input.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN, WA_XMLNS.USYNC, [
         {
             tag: WA_NODE_TAGS.USYNC,
@@ -28,12 +32,12 @@ export function buildUsyncIq(input) {
                 {
                     tag: WA_NODE_TAGS.QUERY,
                     attrs: {},
-                    content: [...input.queryProtocolNodes]
+                    content: input.queryProtocolNodes
                 },
                 {
                     tag: WA_NODE_TAGS.LIST,
                     attrs: {},
-                    content: input.users.map((user) => buildUsyncUserNode(user))
+                    content: users
                 }
             ]
         }

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

@@ -1,7 +1,9 @@
+import { randomFillAsync } from '../../crypto/index.js';
 import { base64ToBytesChecked, TEXT_DECODER, TEXT_ENCODER } from '../../util/bytes.js';
 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);
 export function getNodeChildren(node) {
     return Array.isArray(node.content) ? node.content : EMPTY_NODE_CHILDREN;
 }
@@ -54,7 +56,11 @@ export 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;
 }
 export function getNodeChildrenNonEmptyAttrValuesByTag(node, tag, attr) {
     let values = null;
@@ -120,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}`);
@@ -137,3 +151,31 @@ export function formatNodeIdPrefixFromSeed(seed) {
     const right = ((seed[2] << 8) | seed[3]) >>> 0;
     return `${left}.${right}-`;
 }
+export async function createNodeIdGenerator() {
+    await randomFillAsync(NODE_ID_PREFIX_SEED);
+    const prefix = formatNodeIdPrefixFromSeed(NODE_ID_PREFIX_SEED);
+    let counter = 0;
+    return {
+        prefix,
+        next() {
+            counter += 1;
+            return `${prefix}${counter}`;
+        }
+    };
+}
+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/node/usync.js

@@ -1,35 +1,5 @@
-import { randomBytesAsync } from '../../crypto/index.js';
-import { formatNodeIdPrefixFromSeed } from './helpers.js';
+import { createNodeIdGenerator } from './helpers.js';
 export 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 randomBytesAsync(4);
-    return formatNodeIdPrefixFromSeed(seed);
+    const generatorPromise = createNodeIdGenerator();
+    return async () => (await generatorPromise).next();
 }

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

@@ -1,23 +1,41 @@
 import { bytesToBase64 } from '../../util/bytes.js';
 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}/>`;
@@ -31,7 +49,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}>`;
 }
 export function formatBinaryNodeAsXml(node) {

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

@@ -1,9 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { md5Bytes } from '../../crypto/core/primitives.js';
 import { proto } from '../../proto.js';
-import { KEY_TYPE_CURVE25519 } from '../../signal/constants.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);
@@ -16,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;
@@ -60,8 +66,8 @@ function resolveDevicePropsPlatformType(deviceBrowser) {
             return 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.ClientPayload.UserAgent.Platform.WEB,
@@ -82,8 +88,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.DeviceProps.encode({
         os: config.deviceOsDisplayName ?? process.platform,
         version: {
@@ -105,7 +111,7 @@ function defaultDeviceProps(versionBase, config) {
         }
     }).finish();
 }
-function buildCommonPayload(config) {
+function buildCommonPayload(config, version) {
     const versionBase = config.versionBase ?? DEFAULT_VERSION_BASE;
     const pull = config.pull ?? true;
     return {
@@ -113,7 +119,7 @@ function buildCommonPayload(config) {
         pull,
         connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
         connectReason: 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()
@@ -142,18 +148,17 @@ export function buildRegistrationPayload(config) {
         throw new Error('registration payload requires a valid signedPreKeyId');
     }
     const versionBase = config.versionBase ?? DEFAULT_VERSION_BASE;
-    const common = buildCommonPayload(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),
+        buildHash: config.buildHash ?? md5Bytes(versionBase),
+        deviceProps: config.deviceProps ?? defaultDeviceProps(versionBase, config, version),
         eRegid: intToBytes(4, registrationId),
-        eKeytype: intToBytes(1, KEY_TYPE_CURVE25519),
-        eIdent: toBytesView(config.registrationInfo.identityKeyPair.pubKey),
+        eKeytype: intToBytes(1, 5),
+        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();
+}