zapo-js 0.2.0 → 1.0.0

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

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildUsyncUserNode = buildUsyncUserNode;
+exports.iterateUsyncUsers = iterateUsyncUsers;
+exports.parseUsyncResultEnvelope = parseUsyncResultEnvelope;
 exports.buildUsyncIq = buildUsyncIq;
 const constants_1 = require("../../../protocol/constants");
+const helpers_1 = require("../../node/helpers");
 const query_1 = require("../../node/query");
+const primitives_1 = require("../../../util/primitives");
 function buildUsyncUserNode(input) {
     return {
         tag: constants_1.WA_NODE_TAGS.USER,
@@ -14,6 +18,53 @@ function buildUsyncUserNode(input) {
         ...(input.content !== undefined ? { content: input.content } : {})
     };
 }
+function iterateUsyncUsers(result) {
+    const usyncNode = (0, helpers_1.findNodeChild)(result, constants_1.WA_NODE_TAGS.USYNC);
+    if (!usyncNode)
+        return null;
+    const listNode = (0, helpers_1.findNodeChild)(usyncNode, constants_1.WA_NODE_TAGS.LIST);
+    if (!listNode)
+        return null;
+    return (0, helpers_1.getNodeChildrenByTag)(listNode, constants_1.WA_NODE_TAGS.USER);
+}
+const EMPTY_USYNC_RESULT_ENVELOPE = Object.freeze({
+    errors: Object.freeze({}),
+    refresh: Object.freeze({})
+});
+/**
+ * Walks a `usync` IQ result and extracts per-protocol error envelopes plus
+ * `refresh` hints. Returns an empty envelope when the result has no `usync`
+ * payload.
+ */
+function parseUsyncResultEnvelope(result) {
+    const usyncNode = (0, helpers_1.findNodeChild)(result, constants_1.WA_NODE_TAGS.USYNC);
+    if (!usyncNode)
+        return EMPTY_USYNC_RESULT_ENVELOPE;
+    const resultNode = (0, helpers_1.findNodeChild)(usyncNode, 'result');
+    if (!resultNode)
+        return EMPTY_USYNC_RESULT_ENVELOPE;
+    if (!Array.isArray(resultNode.content))
+        return EMPTY_USYNC_RESULT_ENVELOPE;
+    const errors = {};
+    const refresh = {};
+    for (let i = 0; i < resultNode.content.length; i += 1) {
+        const protoNode = resultNode.content[i];
+        const errorNode = (0, helpers_1.findNodeChild)(protoNode, constants_1.WA_NODE_TAGS.ERROR);
+        if (errorNode) {
+            errors[protoNode.tag] = {
+                code: (0, primitives_1.parseOptionalInt)(errorNode.attrs.code) ?? null,
+                text: errorNode.attrs.text ?? null,
+                backoffSeconds: (0, primitives_1.parseOptionalInt)(errorNode.attrs.backoff) ?? null
+            };
+            continue;
+        }
+        const refreshSeconds = (0, primitives_1.parseOptionalInt)(protoNode.attrs.refresh);
+        if (refreshSeconds !== undefined) {
+            refresh[protoNode.tag] = refreshSeconds;
+        }
+    }
+    return { errors, refresh };
+}
 function buildUsyncIq(input) {
     if (input.queryProtocolNodes.length === 0) {
         throw new Error('usync query must include at least one protocol node');
@@ -22,7 +73,7 @@ function buildUsyncIq(input) {
     for (let index = 0; index < input.users.length; index += 1) {
         users[index] = buildUsyncUserNode(input.users[index]);
     }
-    return (0, query_1.buildIqNode)('get', input.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.USYNC, [
+    return (0, query_1.buildIqNode)(constants_1.WA_IQ_TYPES.GET, input.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN, constants_1.WA_XMLNS.USYNC, [
         {
             tag: constants_1.WA_NODE_TAGS.USYNC,
             attrs: {

package/dist/transport/node/helpers.js

@@ -11,9 +11,10 @@ exports.getNodeChildrenNonEmptyUtf8ByTag = getNodeChildrenNonEmptyUtf8ByTag;
 exports.findNodeChildrenByTags = findNodeChildrenByTags;
 exports.hasNodeChild = hasNodeChild;
 exports.decodeNodeContentUtf8OrBytes = decodeNodeContentUtf8OrBytes;
+exports.getNodeTextContent = getNodeTextContent;
 exports.decodeNodeContentBase64OrBytes = decodeNodeContentBase64OrBytes;
-exports.formatNodeIdPrefixFromSeed = formatNodeIdPrefixFromSeed;
 exports.createNodeIdGenerator = createNodeIdGenerator;
+exports.createMobileNodeIdGenerator = createMobileNodeIdGenerator;
 const _crypto_1 = require("../../crypto/index.js");
 const bytes_1 = require("../../util/bytes");
 const EMPTY_NODE_CHILDREN = Object.freeze([]);
@@ -142,6 +143,16 @@ function decodeNodeContentUtf8OrBytes(value, field) {
     }
     throw new Error(`node ${field} has no binary content`);
 }
+function getNodeTextContent(node) {
+    if (!node)
+        return undefined;
+    const content = node.content;
+    if (content instanceof Uint8Array)
+        return bytes_1.TEXT_DECODER.decode(content);
+    if (typeof content === 'string')
+        return content;
+    return undefined;
+}
 function decodeNodeContentBase64OrBytes(value, field) {
     if (value === null || value === undefined) {
         throw new Error(`missing binary node content for ${field}`);
@@ -171,3 +182,19 @@ async function createNodeIdGenerator() {
         }
     };
 }
+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/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,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMexQuery = runMexQuery;
+exports.dispatchMexQuery = dispatchMexQuery;
+const _mex_1 = require("../../../mex.js");
+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;
+/**
+ * Typed wrapper around `dispatchMexQuery` that resolves persist IDs from the
+ * generated `WA_MEX_PERSIST_IDS` table. The op key constrains the `variables`
+ * shape via `WaMexOperationVariables` and defaults the response to
+ * `WaMexOperationResponses[K] | null` (the response tree the extractor walked
+ * from the Relay `operation.selections`; leaves are `unknown` since Relay
+ * strips scalar types at codegen).
+ */
+async function runMexQuery(socket, opKey, variables) {
+    const persist = _mex_1.WA_MEX_PERSIST_IDS[opKey];
+    if (!persist) {
+        throw new Error(`mex/${String(opKey)} persist IDs not found`);
+    }
+    const { data } = await dispatchMexQuery(socket, {
+        docId: persist.docId,
+        clientDocId: persist.clientDocId,
+        opName: opKey,
+        variables: variables
+    });
+    return data;
+}
+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/query.js

@@ -7,6 +7,11 @@ exports.queryWithContext = queryWithContext;
 const constants_1 = require("../../protocol/constants");
 const helpers_1 = require("../node/helpers");
 const primitives_1 = require("../../util/primitives");
+/**
+ * Builds an IQ stanza (`<iq type="get|set" to="..." xmlns="..."/>`) with the
+ * given children/attrs. The caller is responsible for the `id` attribute
+ * (the transport assigns one automatically when omitted).
+ */
 function buildIqNode(type, to, xmlns, content, attrs = {}) {
     return {
         tag: constants_1.WA_NODE_TAGS.IQ,
@@ -19,6 +24,10 @@ function buildIqNode(type, to, xmlns, content, attrs = {}) {
         ...(content !== undefined ? { content } : {})
     };
 }
+/**
+ * Reads the standard error envelope from an IQ stanza, returning the string
+ * `code`/`text` and (when parseable) the numeric `code`.
+ */
 function parseIqError(node) {
     const errorNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.ERROR);
     const code = errorNode?.attrs.code ?? node.attrs.type ?? 'unknown';
@@ -30,6 +39,10 @@ function parseIqError(node) {
         ...(Number.isSafeInteger(parsedCode) ? { numericCode: parsedCode } : {})
     };
 }
+/**
+ * Throws when `node` is not a successful IQ result, embedding the parsed
+ * error envelope and the `context` label in the message.
+ */
 function assertIqResult(node, context) {
     if (node.tag !== constants_1.WA_NODE_TAGS.IQ) {
         throw new Error(`${context} returned non-iq node (${node.tag})`);
@@ -40,6 +53,10 @@ function assertIqResult(node, context) {
     const error = parseIqError(node);
     throw new Error(`${context} iq failed (${error.code}: ${error.text})`);
 }
+/**
+ * Wraps `query(...)` so failures are logged with a `context` label and the
+ * stanza's tag/id/type, then rethrown. Used by every coordinator's IQ call.
+ */
 async function queryWithContext(query, logger, context, node, timeoutMs, contextData = {}) {
     try {
         return await query(node, timeoutMs);

package/dist/transport/node/usync.js

@@ -1,8 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUsyncSidGenerator = createUsyncSidGenerator;
+exports.logUsyncProtocolErrors = logUsyncProtocolErrors;
 const helpers_1 = require("./helpers");
 function createUsyncSidGenerator() {
     const generatorPromise = (0, helpers_1.createNodeIdGenerator)();
     return async () => (await generatorPromise).next();
 }
+function logUsyncProtocolErrors(envelope, logger, context) {
+    for (const protocol of Object.keys(envelope.errors)) {
+        const err = envelope.errors[protocol];
+        logger.warn('usync protocol error', {
+            context,
+            protocol,
+            code: err.code,
+            text: err.text,
+            backoffSeconds: err.backoffSeconds
+        });
+    }
+}

package/dist/transport/noise/WaClientPayload.js

@@ -5,8 +5,8 @@ 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("../noise/constants");
 const bytes_1 = require("../../util/bytes");
+const _version_spec_1 = require("../../version-spec.js");
 function parseVersion(versionBase) {
     const [p = '2', s = '3000', t = '0'] = versionBase.split('.');
     const primary = Number.parseInt(p, 10);
@@ -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;
@@ -104,12 +111,13 @@ function defaultDeviceProps(versionBase, config, version) {
             supportHostedGroupMsg: true,
             supportBizHostedMsg: true,
             supportFbidBotChatHistory: true,
-            supportMessageAssociation: true
+            supportMessageAssociation: true,
+            supportInlineContacts: true
         }
     }).finish();
 }
 function buildCommonPayload(config, version) {
-    const versionBase = config.versionBase ?? constants_1.DEFAULT_VERSION_BASE;
+    const versionBase = config.versionBase ?? _version_spec_1.WA_VERSION;
     const pull = config.pull ?? true;
     return {
         passive: config.passive === true,
@@ -117,10 +125,9 @@ function buildCommonPayload(config, version) {
         connectType: _proto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
         connectReason: _proto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: config.userAgent ?? defaultUserAgent(versionBase, config.deviceOsDisplayName, version),
-        webInfo: config.webInfo ??
-            {
-                webSubPlatform: defaultWebSubPlatform()
-            }
+        webInfo: config.webInfo ?? {
+            webSubPlatform: defaultWebSubPlatform()
+        }
     };
 }
 function buildLoginPayload(config) {
@@ -144,20 +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_1.DEFAULT_VERSION_BASE;
+    const versionBase = config.versionBase ?? _version_spec_1.WA_VERSION;
     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,61 @@
+"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)
+    };
+}
+/**
+ * Builds the encoded {@link Proto.ClientPayload} bytes the WhatsApp Mobile
+ * transport sends after the noise login handshake. Throws when
+ * `username`/`appVersion` are missing/invalid.
+ */
+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();
+}