@badzz88/baileys 8.5.5 → 8.5.6

package/src/WABinary/decode.js

@@ -0,0 +1,342 @@
+'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.decodeBinaryNode = exports.decodeDecompressedBinaryNode = exports.decompressingIfRequired = void 0;
+const util_1 = require('util');
+const zlib_1 = require('zlib');
+const constants = __importStar(require('./constants'));
+const jid_utils_1 = require('./jid-utils');
+const inflatePromise = (0, util_1.promisify)(zlib_1.inflate);
+const decompressingIfRequired = async (buffer) => {
+    if (2 & buffer.readUInt8()) {
+        buffer = await inflatePromise(buffer.slice(1));
+    }
+    else {
+        buffer = buffer.slice(1);
+    }
+    return buffer;
+};
+exports.decompressingIfRequired = decompressingIfRequired;
+const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) => {
+    const { DOUBLE_BYTE_TOKENS, SINGLE_BYTE_TOKENS, TAGS } = opts;
+    const checkEOS = length => {
+        if (indexRef.index + length > buffer.length) {
+            throw new Error('end of stream');
+        }
+    };
+    const next = () => {
+        const value = buffer[indexRef.index];
+        indexRef.index += 1;
+        return value;
+    };
+    const readByte = () => {
+        checkEOS(1);
+        return next();
+    };
+    const readBytes = n => {
+        checkEOS(n);
+        const value = buffer.slice(indexRef.index, indexRef.index + n);
+        indexRef.index += n;
+        return value;
+    };
+    const readStringFromChars = length => {
+        return readBytes(length).toString('utf-8');
+    };
+    const readInt = (n, littleEndian = false) => {
+        checkEOS(n);
+        let val = 0;
+        for (let i = 0; i < n; i++) {
+            const shift = littleEndian ? i : n - 1 - i;
+            val |= next() << (shift * 8);
+        }
+        return val;
+    };
+    const readInt20 = () => {
+        checkEOS(3);
+        return ((next() & 15) << 16) + (next() << 8) + next();
+    };
+    const unpackHex = value => {
+        if (value >= 0 && value < 16) {
+            return value < 10 ? '0'.charCodeAt(0) + value : 'A'.charCodeAt(0) + value - 10;
+        }
+        throw new Error('invalid hex: ' + value);
+    };
+    const unpackNibble = value => {
+        if (value >= 0 && value <= 9) {
+            return '0'.charCodeAt(0) + value;
+        }
+        switch (value) {
+            case 10:
+                return '-'.charCodeAt(0);
+            case 11:
+                return '.'.charCodeAt(0);
+            case 15:
+                return '\0'.charCodeAt(0);
+            default:
+                throw new Error('invalid nibble: ' + value);
+        }
+    };
+    const unpackByte = (tag, value) => {
+        if (tag === TAGS.NIBBLE_8) {
+            return unpackNibble(value);
+        }
+        else if (tag === TAGS.HEX_8) {
+            return unpackHex(value);
+        }
+        else {
+            throw new Error('unknown tag: ' + tag);
+        }
+    };
+    const readPacked8 = tag => {
+        const startByte = readByte();
+        let value = '';
+        for (let i = 0; i < (startByte & 127); i++) {
+            const curByte = readByte();
+            value += String.fromCharCode(unpackByte(tag, (curByte & 0xf0) >> 4));
+            value += String.fromCharCode(unpackByte(tag, curByte & 0x0f));
+        }
+        if (startByte >> 7 !== 0) {
+            value = value.slice(0, -1);
+        }
+        return value;
+    };
+    const isListTag = tag => {
+        return tag === TAGS.LIST_EMPTY || tag === TAGS.LIST_8 || tag === TAGS.LIST_16;
+    };
+    const readListSize = tag => {
+        switch (tag) {
+            case TAGS.LIST_EMPTY:
+                return 0;
+            case TAGS.LIST_8:
+                return readByte();
+            case TAGS.LIST_16:
+                return readInt(2);
+            default:
+                throw new Error('invalid tag for list size: ' + tag);
+        }
+    };
+    const readJidPair = () => {
+        const i = readString(readByte());
+        const j = readString(readByte());
+        if (j) {
+            return (i || '') + '@' + j;
+        }
+        throw new Error('invalid jid pair: ' + i + ', ' + j);
+    };
+    const readAdJid = () => {
+        const rawDomainType = readByte();
+        const domainType = Number(rawDomainType);
+        const device = readByte();
+        const user = readString(readByte());
+        let server = 's.whatsapp.net';
+        if (domainType === jid_utils_1.WAJIDDomains.LID) {
+            server = 'lid';
+        }
+        else if (domainType === jid_utils_1.WAJIDDomains.HOSTED) {
+            server = 'hosted';
+        }
+        else if (domainType === jid_utils_1.WAJIDDomains.HOSTED_LID) {
+            server = 'hosted.lid';
+        }
+        return (0, jid_utils_1.jidEncode)(user, server, device);
+    };
+    const readFbJid = () => {
+        const user = readString(readByte());
+        const device = readInt(2);
+        const server = readString(readByte());
+        return `${user}:${device}@${server}`;
+    };
+    const readInteropJid = () => {
+        const user = readString(readByte());
+        const device = readInt(2);
+        const integrator = readInt(2);
+        let server = 'interop';
+        if (indexRef.index < buffer.length) {
+            const serverTag = buffer[indexRef.index];
+            const isValidStringTag = (serverTag >= 1 && serverTag <= 235) ||
+                serverTag === TAGS.BINARY_8 ||
+                serverTag === TAGS.BINARY_20 ||
+                serverTag === TAGS.BINARY_32 ||
+                serverTag === TAGS.NIBBLE_8 ||
+                serverTag === TAGS.HEX_8;
+            if (isValidStringTag) {
+                indexRef.index++;
+                server = readString(serverTag);
+            }
+        }
+        return `${integrator}-${user}:${device}@${server}`;
+    };
+    const readInteropJidTuple = () => {
+        const user = readString(readByte());
+        const device = readInt(2);
+        const integrator = readInt(2);
+        const domain = readByte();
+        if (domain !== 0) {
+            throw new Error(`invalid domain for INTEROP_JID_TUPLE: ${domain}`);
+        }
+        const devicePart = device !== 0 ? `:${device}` : '';
+        return `${integrator}-${user}${devicePart}@interop`;
+    };
+    const readString = tag => {
+        if (tag >= 1 && tag < SINGLE_BYTE_TOKENS.length) {
+            return SINGLE_BYTE_TOKENS[tag] || '';
+        }
+        switch (tag) {
+            case TAGS.DICTIONARY_0:
+            case TAGS.DICTIONARY_1:
+            case TAGS.DICTIONARY_2:
+            case TAGS.DICTIONARY_3:
+                return getTokenDouble(tag - TAGS.DICTIONARY_0, readByte());
+            case TAGS.LIST_EMPTY:
+                return '';
+            case TAGS.BINARY_8:
+                return readStringFromChars(readByte());
+            case TAGS.BINARY_20:
+                return readStringFromChars(readInt20());
+            case TAGS.BINARY_32:
+                return readStringFromChars(readInt(4));
+            case TAGS.JID_PAIR:
+                return readJidPair();
+            case TAGS.FB_JID:
+                return readFbJid();
+            case TAGS.INTEROP_JID_TUPLE:
+                return readInteropJidTuple();
+            case TAGS.INTEROP_JID:
+                return readInteropJid();
+            case TAGS.AD_JID:
+                return readAdJid();
+            case TAGS.HEX_8:
+            case TAGS.NIBBLE_8:
+                return readPacked8(tag);
+            default:
+                process.stderr.write(`[WABinary] unknown string tag 0x${tag.toString(16)} — token table outdated?\n`);
+                return '';
+        }
+    };
+    const readList = tag => {
+        const items = [];
+        const size = readListSize(tag);
+        for (let i = 0; i < size; i++) {
+            items.push((0, exports.decodeDecompressedBinaryNode)(buffer, opts, indexRef));
+        }
+        return items;
+    };
+    const getTokenDouble = (index1, index2) => {
+        const dict = DOUBLE_BYTE_TOKENS[index1];
+        if (!dict) {
+            process.stderr.write(`[WABinary] unknown double-byte token dict ${index1} — token table outdated?\n`);
+            return '';
+        }
+        const value = dict[index2];
+        if (typeof value === 'undefined') {
+            process.stderr.write(`[WABinary] unknown double-byte token dict=${index1} idx=${index2} — token table outdated?\n`);
+            return '';
+        }
+        return value;
+    };
+    const listSize = readListSize(readByte());
+    const header = readString(readByte());
+    if (!listSize || !header.length) {
+        throw new Error('invalid node');
+    }
+    const attrs = {};
+    let data;
+    if (listSize === 0 || !header) {
+        throw new Error('invalid node');
+    }
+    const attributesLength = (listSize - 1) >> 1;
+    for (let i = 0; i < attributesLength; i++) {
+        const key = readString(readByte());
+        const value = readString(readByte());
+        attrs[key] = value;
+    }
+    if (listSize % 2 === 0) {
+        const tag = readByte();
+        if (isListTag(tag)) {
+            data = readList(tag);
+        }
+        else {
+            let decoded;
+            switch (tag) {
+                case TAGS.BINARY_8:
+                    decoded = readBytes(readByte());
+                    break;
+                case TAGS.BINARY_20:
+                    decoded = readBytes(readInt20());
+                    break;
+                case TAGS.BINARY_32:
+                    decoded = readBytes(readInt(4));
+                    break;
+                default:
+                    decoded = readString(tag);
+                    break;
+            }
+            data = decoded;
+        }
+    }
+    return {
+        tag: header,
+        attrs,
+        content: data
+    };
+};
+exports.decodeDecompressedBinaryNode = decodeDecompressedBinaryNode;
+const decodeBinaryNode = buff => {
+    const buffer = Buffer.isBuffer(buff) ? buff : Buffer.from(buff);
+    return decodeDecompressedBinaryNode(buffer, constants);
+};
+exports.decodeBinaryNode = decodeBinaryNode;

package/{lib → src}/WABinary/encode.js

@@ -1,9 +1,8 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.encodeBinaryNode = void 0
-const constants = require('./constants')
-const { jidDecode } = require('./jid-utils')
-
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.encodeBinaryNode = void 0;
+const constants = require('./constants');
+const { jidDecode } = require('./jid-utils');
 const encodeBinaryNodeJS = (node, opts = constants, buffer = [0]) => {
     const encoded = encodeBinaryNodeInner(node, opts, buffer);
     return Buffer.from(encoded);
@@ -32,7 +31,7 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
         }
         if (length >= 1 << 20) {
             pushByte(TAGS.BINARY_32);
-            pushInt(length, 4); // 32 bit integer
+            pushInt(length, 4);
         }
         else if (length >= 256) {
             pushByte(TAGS.BINARY_20);
@@ -214,15 +213,13 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
         }
     }
     else if (typeof content === 'undefined') {
-        // do nothing
     }
     else {
         throw new Error(`invalid children for header "${tag}": ${content} (${typeof content})`);
     }
     return buffer;
 };
-
 const encodeBinaryNode = (node, opts, buffer) => {
-	return encodeBinaryNodeJS(node, opts || constants, buffer || [0])
-}
-exports.encodeBinaryNode = encodeBinaryNode
+    return encodeBinaryNodeJS(node, opts || constants, buffer || [0]);
+};
+exports.encodeBinaryNode = encodeBinaryNode;

package/src/WABinary/generic-utils.js

@@ -0,0 +1,238 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getBinaryNodeMessages =
+    exports.reduceBinaryNodeToDictionary =
+        exports.assertNodeErrorFree =
+            exports.getBinaryNodeChildUInt =
+                exports.getBinaryNodeChildString =
+                    exports.getBinaryNodeChildBuffer =
+                        exports.getAllBinaryNodeChildren =
+                            exports.getBinaryNodeChild =
+                                exports.getBinaryNodeChildren =
+                                    void 0;
+exports.binaryNodeToString = binaryNodeToString;
+const boom_1 = require('@hapi/boom');
+const index_js_1 = require('../../WAProto/index.js');
+const indexCache = new WeakMap();
+const getBinaryNodeChildren = (node, childTag) => {
+    if (!node || !Array.isArray(node.content))
+        return [];
+    let index = indexCache.get(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 index.get(childTag) || [];
+};
+exports.getBinaryNodeChildren = getBinaryNodeChildren;
+const getBinaryNodeChild = (node, childTag) => {
+    return (0, exports.getBinaryNodeChildren)(node, childTag)[0];
+};
+exports.getBinaryNodeChild = getBinaryNodeChild;
+const getAllBinaryNodeChildren = ({ content }) => {
+    if (Array.isArray(content)) {
+        return content;
+    }
+    return [];
+};
+exports.getAllBinaryNodeChildren = getAllBinaryNodeChildren;
+const getBinaryNodeChildBuffer = (node, childTag) => {
+    const child = (0, exports.getBinaryNodeChild)(node, childTag)?.content;
+    if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
+        return child;
+    }
+};
+exports.getBinaryNodeChildBuffer = getBinaryNodeChildBuffer;
+const getBinaryNodeChildString = (node, childTag) => {
+    const child = (0, exports.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;
+    }
+};
+exports.getBinaryNodeChildString = getBinaryNodeChildString;
+const getBinaryNodeChildUInt = (node, childTag, length) => {
+    const buff = (0, exports.getBinaryNodeChildBuffer)(node, childTag);
+    if (buff) {
+        return bufferToUInt(buff, length);
+    }
+};
+exports.getBinaryNodeChildUInt = getBinaryNodeChildUInt;
+const assertNodeErrorFree = node => {
+    const errNode = (0, exports.getBinaryNodeChild)(node, 'error');
+    if (errNode) {
+        throw new boom_1.Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code });
+    }
+};
+exports.assertNodeErrorFree = assertNodeErrorFree;
+const reduceBinaryNodeToDictionary = (node, tag) => {
+    const nodes = (0, exports.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;
+};
+exports.reduceBinaryNodeToDictionary = reduceBinaryNodeToDictionary;
+const getBinaryNodeMessages = ({ content }) => {
+    const msgs = [];
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (item.tag === 'message') {
+                msgs.push(index_js_1.proto.WebMessageInfo.decode(item.content).toJSON());
+            }
+        }
+    }
+    return msgs;
+};
+exports.getBinaryNodeMessages = getBinaryNodeMessages;
+const getBinaryFilteredButtons = nodeContent => {
+    if (!Array.isArray(nodeContent))
+        return false;
+    return nodeContent.some(a => ['native_flow'].includes(a?.content?.[0]?.content?.[0]?.tag) ||
+        ['interactive', 'buttons', 'list'].includes(a?.content?.[0]?.tag) ||
+        ['hsm', 'biz'].includes(a?.tag));
+};
+exports.getBinaryFilteredButtons = getBinaryFilteredButtons;
+const getBinaryFilteredBizBot = nodeContent => {
+    if (!Array.isArray(nodeContent))
+        return false;
+    return nodeContent.some(b => ['bot'].includes(b?.tag) && b?.attrs?.biz_bot === '1');
+};
+exports.getBinaryFilteredBizBot = getBinaryFilteredBizBot;
+const getAdditionalNode = name => {
+    if (name)
+        name = name.toLowerCase();
+    const ts = Math.floor(Date.now() / 1000) - 77980457;
+    const order_response_name = {
+        review_and_pay: 'order_details',
+        review_order: 'order_status',
+        order_status: 'order_status',
+        payment_info: 'payment_info',
+        payment_status: 'payment_status',
+        payment_method: 'payment_method',
+        catalog_message: 'catalog_message'
+    };
+    const flow_name = {
+        cta_catalog: 'cta_catalog',
+        mpm: 'mpm',
+        call_request: 'call_permission_request',
+        view_catalog: 'automated_greeting_message_view_catalog',
+        wa_pay_detail: 'wa_payment_transaction_details',
+        send_location: 'send_location',
+        payment_key_info: 'payment_key_info'
+    };
+    if (order_response_name[name]) {
+        return [
+            {
+                tag: 'biz',
+                attrs: {
+                    native_flow_name: order_response_name[name]
+                },
+                content: []
+            }
+        ];
+    }
+    else if (flow_name[name] || name === 'interactive' || name === 'buttons') {
+        return [
+            {
+                tag: 'biz',
+                attrs: {
+                    actual_actors: '2',
+                    host_storage: '2',
+                    privacy_mode_ts: `${ts}`
+                },
+                content: [
+                    {
+                        tag: 'engagement',
+                        attrs: {
+                            customer_service_state: 'open',
+                            conversation_state: 'open'
+                        }
+                    },
+                    {
+                        tag: 'interactive',
+                        attrs: {
+                            type: 'native_flow',
+                            v: '1'
+                        },
+                        content: [
+                            {
+                                tag: 'native_flow',
+                                attrs: {
+                                    v: '9',
+                                    name: flow_name[name] ?? 'mixed'
+                                },
+                                content: []
+                            }
+                        ]
+                    }
+                ]
+            }
+        ];
+    }
+    else {
+        return [
+            {
+                tag: 'biz',
+                attrs: {
+                    actual_actors: '2',
+                    host_storage: '2',
+                    privacy_mode_ts: `${ts}`
+                },
+                content: [
+                    {
+                        tag: 'engagement',
+                        attrs: {
+                            customer_service_state: 'open',
+                            conversation_state: 'open'
+                        }
+                    }
+                ]
+            }
+        ];
+    }
+};
+exports.getAdditionalNode = getAdditionalNode;
+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);
+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;
+}

package/src/WABinary/index.js

@@ -0,0 +1,34 @@
+'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 __exportStar = (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m)
+            if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p))
+                __createBinding(exports, m, p);
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+__exportStar(require('./encode'), exports);
+__exportStar(require('./decode'), exports);
+__exportStar(require('./generic-utils'), exports);
+__exportStar(require('./jid-utils'), exports);
+__exportStar(require('./types'), exports);