@japofc/baileys 2.1.0

package/lib/WABinary/generic-utils.js

@@ -0,0 +1,276 @@
+import { Boom } from '@hapi/boom';
+import { randomBytes } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+// some extra useful utilities
+const indexCache = new WeakMap();
+export const getBinaryNodeChildren = (node, childTag) => {
+    if (!node || !Array.isArray(node.content))
+        return [];
+    let index = indexCache.get(node);
+    // Build the index once per node
+    if (!index) {
+        index = new Map();
+        for (const child of node.content) {
+            let arr = index.get(child.tag);
+            if (!arr)
+                index.set(child.tag, (arr = []));
+            arr.push(child);
+        }
+        indexCache.set(node, index);
+    }
+    // Return first matching child
+    return index.get(childTag) || [];
+};
+export const getBinaryNodeChild = (node, childTag) => {
+    return getBinaryNodeChildren(node, childTag)[0];
+};
+export const getAllBinaryNodeChildren = ({ content }) => {
+    if (Array.isArray(content)) {
+        return content;
+    }
+    return [];
+};
+export const getBinaryNodeChildBuffer = (node, childTag) => {
+    const child = getBinaryNodeChild(node, childTag)?.content;
+    if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
+        return child;
+    }
+};
+export const getBinaryNodeChildString = (node, childTag) => {
+    const child = getBinaryNodeChild(node, childTag)?.content;
+    if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
+        return Buffer.from(child).toString('utf-8');
+    }
+    else if (typeof child === 'string') {
+        return child;
+    }
+};
+export const getBinaryNodeChildUInt = (node, childTag, length) => {
+    const buff = getBinaryNodeChildBuffer(node, childTag);
+    if (buff) {
+        return bufferToUInt(buff, length);
+    }
+};
+export const assertNodeErrorFree = (node) => {
+    const errNode = getBinaryNodeChild(node, 'error');
+    if (errNode) {
+        throw new Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code });
+    }
+};
+export const reduceBinaryNodeToDictionary = (node, tag) => {
+    const nodes = getBinaryNodeChildren(node, tag);
+    const dict = nodes.reduce((dict, { attrs }) => {
+        if (typeof attrs.name === 'string') {
+            dict[attrs.name] = attrs.value || attrs.config_value;
+        }
+        else {
+            dict[attrs.config_code] = attrs.value || attrs.config_value;
+        }
+        return dict;
+    }, {});
+    return dict;
+};
+export const getBinaryNodeMessages = ({ content }) => {
+    const msgs = [];
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (item.tag === 'message') {
+                msgs.push(proto.WebMessageInfo.decode(item.content).toJSON());
+            }
+        }
+    }
+    return msgs;
+};
+function bufferToUInt(e, t) {
+    let a = 0;
+    for (let i = 0; i < t; i++) {
+        a = 256 * a + e[i];
+    }
+    return a;
+}
+const tabs = (n) => '\t'.repeat(n);
+export function binaryNodeToString(node, i = 0) {
+    if (!node) {
+        return node;
+    }
+    if (typeof node === 'string') {
+        return tabs(i) + node;
+    }
+    if (node instanceof Uint8Array) {
+        return tabs(i) + Buffer.from(node).toString('hex');
+    }
+    if (Array.isArray(node)) {
+        return node.map(x => tabs(i + 1) + binaryNodeToString(x, i + 1)).join('\n');
+    }
+    const children = binaryNodeToString(node.content, i + 1);
+    const tag = `<${node.tag} ${Object.entries(node.attrs || {})
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}='${v}'`)
+        .join(' ')}`;
+    const content = children ? `>\n${children}\n${tabs(i)}</${node.tag}>` : '/>';
+    return tag + content;
+}
+/**
+ * JAP@Changes 30-01-26
+ * ---
+ * Produce the binary node (WABinary-like JSON shape) required for the specific
+ * interactive button / list type.
+ * compatible with observed official client traffic.
+ *
+ * NOTE: Returning different "v" (version) and "name" values influences how
+ * WhatsApp renders & validates flows. The constants here are empirically derived.
+ *
+ * @param {object} message Normalized message content (after Baileys normalization).
+ * @returns {object} A node with shape { tag, attrs, [content] } to inject into additionalNodes.
+ */
+const FLOWS_MAP = {
+    // Original flow types
+    mpm: true,
+    // JAP@Fix (bug 44): the "catalog" nativeFlow shortcut generates a button
+    // named 'catalog_message' (see prepareNativeFlowButtons in messages.js),
+    // never 'cta_catalog' — the old key here never matched anything, so
+    // catalog_message always fell through to the generic mixed-flow node
+    // instead of getting its dedicated native_flow node.
+    catalog_message: true,
+    send_location: true,
+    call_permission_request: true,
+    wa_payment_transaction_details: true,
+    automated_greeting_message_view_catalog: true,
+    // Jap extended button types
+    card_message: true,
+    order_status: true,
+    track_order: true,
+    reorder: true,
+    cancel_order: true,
+    clear_chat: true,
+    navigateToScreen: true,
+    payment_status: true,
+    payment_method: true,
+    flow_action: true,
+    voice_call: true,
+    video_call_button: true,
+    otp_button: true,
+    authentication_button: true,
+    cta_reminder: true,
+    cta_cancel_reminder: true,
+    // JAP@Fix 27-08-26: the real native_flow name for a WhatsApp Flows launch
+    // button is 'flow' (matches Button.addFlow()'s button.name after the fix
+    // in MessageBuilder.js). 'flow_action' was never a valid native_flow name --
+    // it's the name of a *field inside* buttonParamsJson -- so it never actually
+    // routed anything real; kept as a harmless alias in case any external caller
+    // is still constructing a raw button object with the old (wrong) name.
+    flow: true,
+    // JAP@Fix (bug 68): removed duplicate `flow_action: true` key — already declared
+    // above (Jap extended button types block); this was a leftover copy-paste dupe,
+    // harmless (same value) but confusing on re-read.
+    // JAP@Fix (single_select never renders alone) --- single_select must NEVER get
+    // its own dedicated native_flow node here. WhatsApp only renders a single_select
+    // button through the generic <native_flow v='9' name='mixed'> node — the same one
+    // used when it's combined with other buttons. Giving it a dedicated
+    // <native_flow v='2' name='single_select'> node (like the other FLOWS_MAP entries)
+    // silently fails to render client-side, whether single_select is alone or is simply
+    // the first button in the array. Removed from this map on purpose so it always
+    // falls through to the `flowMsg` mixed-flow branch below.
+};
+const DECISION_SOURCE_CONTENT = [
+    {
+        tag: 'decision_source',
+        attrs: { value: 'df' }
+    }
+];
+const LIST_TYPE_CONTENT = {
+    tag: 'list',
+    attrs: { v: '2', type: 'product_list' }
+};
+const NATIVE_FLOW_ATTRIBUTE = { type: 'native_flow', v: '1' };
+const MIXED_NATIVE_FLOW = {
+    tag: 'interactive',
+    attrs: NATIVE_FLOW_ATTRIBUTE,
+    content: [
+        {
+            tag: 'native_flow',
+            attrs: { v: '9', name: 'mixed' }
+        }
+    ]
+};
+export const getBizBinaryNode = (message) => {
+    const flowMsg = message.interactiveMessage?.nativeFlowMessage;
+    const firstButtonName = flowMsg?.buttons?.[0]?.name;
+    const qualityContent = {
+        tag: 'quality_control',
+        attrs: {
+            decision_id: randomBytes(20).toString('hex'),
+            source_type: 'third_party'
+        },
+        content: DECISION_SOURCE_CONTENT
+    };
+    const bizAttributes = {
+        actual_actors: '2',
+        host_storage: '2',
+        privacy_mode_ts: `${Date.now() / 1_000 | 0}`
+    };
+    const ORDER_RESPONSE_ALIAS = {
+        review_and_pay: 'order_details',
+        review_order: 'order_status',
+        payment_info: 'payment_info',
+        payment_status: 'payment_status',
+        payment_method: 'payment_method',
+        order_details: 'order_details',
+        order_status: 'order_status',
+        track_order: 'track_order',
+        reorder: 'reorder',
+        cancel_order: 'cancel_order',
+    };
+    if (firstButtonName && ORDER_RESPONSE_ALIAS[firstButtonName]) {
+        bizAttributes.native_flow_name = ORDER_RESPONSE_ALIAS[firstButtonName];
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [qualityContent]
+        };
+    }
+    if (firstButtonName && FLOWS_MAP[firstButtonName]) {
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                {
+                    tag: 'interactive',
+                    attrs: NATIVE_FLOW_ATTRIBUTE,
+                    content: [
+                        {
+                            tag: 'native_flow',
+                            attrs: { v: '2', name: firstButtonName }
+                        }
+                    ]
+                },
+                qualityContent
+            ]
+        };
+    }
+    if (flowMsg || message.buttonsMessage || message.templateMessage) {
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                MIXED_NATIVE_FLOW,
+                qualityContent
+            ]
+        };
+    }
+    if (message.listMessage) {
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                LIST_TYPE_CONTENT,
+                qualityContent
+            ]
+        };
+    }
+    return {
+        tag: 'biz',
+        attrs: bizAttributes,
+        content: [qualityContent]
+    };
+};

package/lib/WABinary/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./encode.js";
+export * from "./decode.js";
+export * from "./generic-utils.js";
+export * from "./jid-utils.js";
+export * from "./types.js";

package/lib/WABinary/index.js

@@ -0,0 +1,5 @@
+export * from './encode.js';
+export * from './decode.js';
+export * from './generic-utils.js';
+export * from './jid-utils.js';
+export * from './types.js';

package/lib/WABinary/jid-utils.d.ts

@@ -0,0 +1,28 @@
+export const S_WHATSAPP_NET: "@s.whatsapp.net";
+export const OFFICIAL_BIZ_JID: "16505361212@c.us";
+export const SERVER_JID: "server@c.us";
+export const PSA_WID: "0@c.us";
+export const STORIES_JID: "status@broadcast";
+export const META_AI_JID: "13135550002@c.us";
+export const WAJIDDomains: any;
+export function getServerFromDomainType(initialServer: any, domainType: any): any;
+export function jidEncode(user: any, server: any, device: any, agent: any): string;
+export function jidDecode(jid: any): {
+    server: any;
+    user: any;
+    domainType: any;
+    device: number | undefined;
+} | undefined;
+export function areJidsSameUser(jid1: any, jid2: any): boolean;
+export function isJidMetaAI(jid: any): any;
+export function isPnUser(jid: any): any;
+export function isLidUser(jid: any): any;
+export function isJidBroadcast(jid: any): any;
+export function isJidGroup(jid: any): any;
+export function isJidStatusBroadcast(jid: any): boolean;
+export function isJidNewsletter(jid: any): any;
+export function isHostedPnUser(jid: any): any;
+export function isHostedLidUser(jid: any): any;
+export function isJidBot(jid: any): any;
+export function jidNormalizedUser(jid: any): string;
+export function transferDevice(fromJid: any, toJid: any): string;

package/lib/WABinary/jid-utils.js

@@ -0,0 +1,95 @@
+export const S_WHATSAPP_NET = '@s.whatsapp.net';
+export const OFFICIAL_BIZ_JID = '16505361212@c.us';
+export const SERVER_JID = 'server@c.us';
+export const PSA_WID = '0@c.us';
+export const STORIES_JID = 'status@broadcast';
+export const META_AI_JID = '13135550002@c.us';
+export var WAJIDDomains;
+(function (WAJIDDomains) {
+    WAJIDDomains[WAJIDDomains["WHATSAPP"] = 0] = "WHATSAPP";
+    WAJIDDomains[WAJIDDomains["LID"] = 1] = "LID";
+    WAJIDDomains[WAJIDDomains["HOSTED"] = 128] = "HOSTED";
+    WAJIDDomains[WAJIDDomains["HOSTED_LID"] = 129] = "HOSTED_LID";
+})(WAJIDDomains || (WAJIDDomains = {}));
+export const getServerFromDomainType = (initialServer, domainType) => {
+    switch (domainType) {
+        case WAJIDDomains.LID:
+            return 'lid';
+        case WAJIDDomains.HOSTED:
+            return 'hosted';
+        case WAJIDDomains.HOSTED_LID:
+            return 'hosted.lid';
+        case WAJIDDomains.WHATSAPP:
+        default:
+            return initialServer;
+    }
+};
+export const jidEncode = (user, server, device, agent) => {
+    return `${user || ''}${!!agent ? `_${agent}` : ''}${!!device ? `:${device}` : ''}@${server || 'lid'}`;
+};
+export const jidDecode = (jid) => {
+    // todo: investigate how to implement hosted ids in this case
+    const sepIdx = typeof jid === 'string' ? jid.indexOf('@') : -1;
+    if (sepIdx < 0) {
+        return undefined;
+    }
+    const server = jid.slice(sepIdx + 1);
+    const userCombined = jid.slice(0, sepIdx);
+    const [userAgent, device] = userCombined.split(':');
+    const [user, agent] = userAgent.split('_');
+    let domainType = WAJIDDomains.WHATSAPP;
+    if (server === 'lid') {
+        domainType = WAJIDDomains.LID;
+    }
+    else if (server === 'hosted') {
+        domainType = WAJIDDomains.HOSTED;
+    }
+    else if (server === 'hosted.lid') {
+        domainType = WAJIDDomains.HOSTED_LID;
+    }
+    else if (agent) {
+        domainType = parseInt(agent);
+    }
+    return {
+        server: server,
+        user: user,
+        domainType,
+        device: device ? +device : undefined
+    };
+};
+/** is the jid a user */
+export const areJidsSameUser = (jid1, jid2) => jidDecode(jid1)?.user === jidDecode(jid2)?.user;
+/** is the jid Meta AI */
+export const isJidMetaAI = (jid) => jid?.endsWith('@bot');
+/** is the jid a PN user */
+export const isPnUser = (jid) => jid?.endsWith('@s.whatsapp.net');
+/** is the jid a LID */
+export const isLidUser = (jid) => jid?.endsWith('@lid');
+/** is the jid a broadcast */
+export const isJidBroadcast = (jid) => jid?.endsWith('@broadcast');
+/** is the jid a group */
+export const isJidGroup = (jid) => jid?.endsWith('@g.us');
+/** is the jid the status broadcast */
+export const isJidStatusBroadcast = (jid) => jid === 'status@broadcast';
+/** is the jid a newsletter */
+export const isJidNewsletter = (jid) => jid?.endsWith('@newsletter');
+/** is the jid a hosted PN */
+export const isHostedPnUser = (jid) => jid?.endsWith('@hosted');
+/** is the jid a hosted LID */
+export const isHostedLidUser = (jid) => jid?.endsWith('@hosted.lid');
+const botRegexp = /^1313555\d{4}$|^131655500\d{2}$/;
+export const isJidBot = (jid) => jid && botRegexp.test(jid.split('@')[0]) && jid.endsWith('@c.us');
+export const jidNormalizedUser = (jid) => {
+    const result = jidDecode(jid);
+    if (!result) {
+        return '';
+    }
+    const { user, server } = result;
+    return jidEncode(user, server === 'c.us' ? 's.whatsapp.net' : server);
+};
+export const transferDevice = (fromJid, toJid) => {
+    const fromDecoded = jidDecode(fromJid);
+    const deviceId = fromDecoded?.device || 0;
+    const { server, user } = jidDecode(toJid);
+    return jidEncode(user, server, deviceId);
+};

package/lib/WABinary/types.d.ts

@@ -0,0 +1,19 @@
+import * as constants from './constants.js';
+/**
+ * the binary node WA uses internally for communication
+ *
+ * this is manipulated soley as an object and it does not have any functions.
+ * This is done for easy serialization, to prevent running into issues with prototypes &
+ * to maintain functional code structure
+ * */
+export type BinaryNode = {
+    tag: string;
+    attrs: {
+        [key: string]: string;
+    };
+    content?: BinaryNode[] | string | Uint8Array;
+};
+export type BinaryNodeAttributes = BinaryNode['attrs'];
+export type BinaryNodeData = BinaryNode['content'];
+export type BinaryNodeCodingOptions = typeof constants;
+//# sourceMappingURL=types.d.ts.map

package/lib/WABinary/types.js

@@ -0,0 +1 @@
+import * as constants from './constants.js';

package/lib/WAM/BinaryInfo.d.ts

@@ -0,0 +1,7 @@
+export class BinaryInfo {
+    constructor(options?: {});
+    protocolVersion: number;
+    sequence: number;
+    events: any[];
+    buffer: any[];
+}

package/lib/WAM/BinaryInfo.js

@@ -0,0 +1,9 @@
+export class BinaryInfo {
+    constructor(options = {}) {
+        this.protocolVersion = 5;
+        this.sequence = 0;
+        this.events = [];
+        this.buffer = [];
+        Object.assign(this, options);
+    }
+}