@zervonex/baileys 0.0.0-stage → 3.0.1

package/lib/WABinary/decode.js

@@ -0,0 +1,152 @@
+import { promisify } from 'util'
+import { inflate } from 'zlib'
+import * as constants from './constants.js'
+import { jidEncode, WAJIDDomains } from './jid-utils.js'
+
+const inflatePromise = promisify(inflate)
+
+export const decompressingIfRequired = async (buffer) => {
+    if (2 & buffer.readUInt8()) buffer = await inflatePromise(buffer.slice(1))
+    else buffer = buffer.slice(1)
+    return buffer
+}
+
+export const decodeBinaryNode = async (buff) =>
+    decodeDecompressedBinaryNode(await decompressingIfRequired(buff), constants)
+
+export const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) => {
+    const { DOUBLE_BYTE_TOKENS, SINGLE_BYTE_TOKENS, TAGS } = opts
+
+    const checkEOS = (n) => { if (indexRef.index + n > buffer.length) throw new Error('end of stream') }
+    const next = () => { const v = buffer[indexRef.index]; indexRef.index += 1; return v }
+    const readByte = () => { checkEOS(1); return next() }
+    const readBytes = (n) => { checkEOS(n); const v = buffer.slice(indexRef.index, indexRef.index + n); indexRef.index += n; return v }
+    const readStringFromChars = (n) => readBytes(n).toString('utf-8')
+
+    const readInt = (n, le = false) => {
+        checkEOS(n)
+        let val = 0
+        for (let i = 0; i < n; i++) val |= next() << ((le ? i : n - 1 - i) * 8)
+        return val
+    }
+
+    const readInt20 = () => { checkEOS(3); return ((next() & 15) << 16) | (next() << 8) | next() }
+
+    const unpackHex = (v) => {
+        if (v >= 0 && v < 16) return v < 10 ? '0'.charCodeAt(0) + v : 'A'.charCodeAt(0) + v - 10
+        throw new Error('invalid hex: ' + v)
+    }
+
+    const unpackNibble = (v) => {
+        if (v >= 0 && v <= 9) return '0'.charCodeAt(0) + v
+        if (v === 10) return '-'.charCodeAt(0)
+        if (v === 11) return '.'.charCodeAt(0)
+        if (v === 15) return '\0'.charCodeAt(0)
+        throw new Error('invalid nibble: ' + v)
+    }
+
+    const unpackByte = (tag, v) => {
+        if (tag === TAGS.NIBBLE_8) return unpackNibble(v)
+        if (tag === TAGS.HEX_8) return unpackHex(v)
+        throw new Error('unknown tag: ' + tag)
+    }
+
+    const readPacked8 = (tag) => {
+        const startByte = readByte()
+        let value = ''
+        for (let i = 0; i < (startByte & 127); i++) {
+            const cur = readByte()
+            value += String.fromCharCode(unpackByte(tag, (cur & 0xf0) >> 4))
+            value += String.fromCharCode(unpackByte(tag, cur & 0x0f))
+        }
+        if (startByte >> 7 !== 0) value = value.slice(0, -1)
+        return value
+    }
+
+    const isListTag = (tag) => 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 domainType = Number(readByte())
+        const device = readByte()
+        const user = readString(readByte())
+        const server =
+            domainType === WAJIDDomains.LID ? 'lid' :
+                domainType === WAJIDDomains.HOSTED ? 'hosted' :
+                    domainType === WAJIDDomains.HOSTED_LID ? 'hosted.lid' :
+                        's.whatsapp.net'
+        return jidEncode(user, server, device)
+    }
+
+    const getTokenDouble = (i1, i2) => {
+        const dict = DOUBLE_BYTE_TOKENS[i1]
+        if (!dict) throw new Error(`invalid double token dict (${i1})`)
+        const val = dict[i2]
+        if (val === undefined) throw new Error(`invalid double token (${i2})`)
+        return val
+    }
+
+    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.AD_JID: return readAdJid()
+            case TAGS.HEX_8:
+            case TAGS.NIBBLE_8: return readPacked8(tag)
+            default: throw new Error('invalid string with tag: ' + tag)
+        }
+    }
+
+    const readList = (tag) => {
+        const size = readListSize(tag)
+        const items = []
+        for (let i = 0; i < size; i++) items.push(decodeDecompressedBinaryNode(buffer, opts, indexRef))
+        return items
+    }
+
+    const listSize = readListSize(readByte())
+    const header = readString(readByte())
+    if (!listSize || !header.length) throw new Error('invalid node')
+
+    const attrs = {}
+    const attributesLength = (listSize - 1) >> 1
+    for (let i = 0; i < attributesLength; i++) attrs[readString(readByte())] = readString(readByte())
+
+    let data
+    if (listSize % 2 === 0) {
+        const tag = readByte()
+        data = isListTag(tag) ? readList(tag) : (() => {
+            switch (tag) {
+                case TAGS.BINARY_8: return readBytes(readByte())
+                case TAGS.BINARY_20: return readBytes(readInt20())
+                case TAGS.BINARY_32: return readBytes(readInt(4))
+                default: return readString(tag)
+            }
+        })()
+    }
+
+    return { tag: header, attrs, content: data }
+}

package/lib/WABinary/encode.js

@@ -0,0 +1,140 @@
+import * as constants from './constants.js'
+import { jidDecode } from './jid-utils.js'
+
+export const encodeBinaryNode = (node, opts = constants, buffer = [0]) => {
+    encodeBinaryNodeInner(node, opts, buffer)
+    return Buffer.from(buffer)
+}
+
+const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
+    const { TAGS, TOKEN_MAP } = opts
+
+    const pushByte = (v) => buffer.push(v & 0xff)
+    const pushBytes = (bytes) => {
+        if (bytes.length > 1000) { for (let i = 0; i < bytes.length; i++) buffer.push(bytes[i]) }
+        else buffer.push(...bytes)
+    }
+    const pushInt = (v, n, le = false) => {
+        for (let i = 0; i < n; i++) buffer.push((v >> ((le ? i : n - 1 - i) * 8)) & 0xff)
+    }
+    const pushInt16 = (v) => pushBytes([(v >> 8) & 0xff, v & 0xff])
+    const pushInt20 = (v) => pushBytes([(v >> 16) & 0x0f, (v >> 8) & 0xff, v & 0xff])
+
+    const writeByteLength = (length) => {
+        if (length >= 4294967296) throw new Error('string too large to encode: ' + length)
+        if (length >= 1 << 20) { pushByte(TAGS.BINARY_32); pushInt(length, 4) }
+        else if (length >= 256) { pushByte(TAGS.BINARY_20); pushInt20(length) }
+        else { pushByte(TAGS.BINARY_8); pushByte(length) }
+    }
+
+    const writeStringRaw = (str) => {
+        const bytes = Buffer.from(str, 'utf-8')
+        writeByteLength(bytes.length)
+        pushBytes(bytes)
+    }
+
+    const writeJid = ({ domainType, device, user, server }) => {
+        if (device !== undefined) {
+            pushByte(TAGS.AD_JID)
+            pushByte(domainType || 0)
+            pushByte(device || 0)
+            writeString(user)
+        } else {
+            pushByte(TAGS.JID_PAIR)
+            if (user.length) writeString(user)
+            else pushByte(TAGS.LIST_EMPTY)
+            writeString(server)
+        }
+    }
+
+    const packNibble = (char) => {
+        if (char >= '0' && char <= '9') return char.charCodeAt(0) - 48
+        if (char === '-') return 10
+        if (char === '.') return 11
+        if (char === '\0') return 15
+        throw new Error(`invalid byte for nibble "${char}"`)
+    }
+
+    const packHex = (char) => {
+        if (char >= '0' && char <= '9') return char.charCodeAt(0) - 48
+        if (char >= 'A' && char <= 'F') return 10 + char.charCodeAt(0) - 65
+        if (char >= 'a' && char <= 'f') return 10 + char.charCodeAt(0) - 97
+        if (char === '\0') return 15
+        throw new Error(`invalid hex char "${char}"`)
+    }
+
+    const writePackedBytes = (str, type) => {
+        if (str.length > TAGS.PACKED_MAX) throw new Error('too many bytes to pack')
+        pushByte(type === 'nibble' ? TAGS.NIBBLE_8 : TAGS.HEX_8)
+        const odd = str.length % 2 !== 0
+        pushByte(odd ? (Math.ceil(str.length / 2) | 128) : Math.ceil(str.length / 2))
+        const pack = type === 'nibble' ? packNibble : packHex
+        for (let i = 0; i < Math.floor(str.length / 2); i++)
+            buffer.push((pack(str[2 * i]) << 4) | pack(str[2 * i + 1]))
+        if (odd) buffer.push((pack(str[str.length - 1]) << 4) | pack('\x00'))
+    }
+
+    const isNibble = (str) => {
+        if (!str || str.length > TAGS.PACKED_MAX) return false
+        for (const c of str) if (!(c >= '0' && c <= '9') && c !== '-' && c !== '.') return false
+        return true
+    }
+
+    const isHex = (str) => {
+        if (!str || str.length > TAGS.PACKED_MAX) return false
+        for (const c of str) if (!(c >= '0' && c <= '9') && !(c >= 'A' && c <= 'F')) return false
+        return true
+    }
+
+    const writeString = (str) => {
+        if (str == null) { pushByte(TAGS.LIST_EMPTY); return }
+        const tokenIndex = TOKEN_MAP[str]
+        if (tokenIndex) {
+            if (typeof tokenIndex.dict === 'number') pushByte(TAGS.DICTIONARY_0 + tokenIndex.dict)
+            pushByte(tokenIndex.index)
+        } else if (isNibble(str)) {
+            writePackedBytes(str, 'nibble')
+        } else if (isHex(str)) {
+            writePackedBytes(str, 'hex')
+        } else if (str) {
+            const decoded = jidDecode(str)
+            if (decoded) writeJid(decoded)
+            else writeStringRaw(str)
+        }
+    }
+
+    const writeListStart = (size) => {
+        if (size === 0) pushByte(TAGS.LIST_EMPTY)
+        else if (size < 256) pushBytes([TAGS.LIST_8, size])
+        else { pushByte(TAGS.LIST_16); pushInt16(size) }
+    }
+
+    if (!tag) throw new Error('invalid node: tag cannot be undefined')
+
+    const validAttrs = Object.keys(attrs || {}).filter(k => attrs[k] != null)
+    writeListStart(2 * validAttrs.length + 1 + (content !== undefined ? 1 : 0))
+    writeString(tag)
+
+    for (const key of validAttrs) {
+        if (typeof attrs[key] === 'string') { writeString(key); writeString(attrs[key]) }
+    }
+
+    if (typeof content === 'string') {
+        writeString(content)
+    } else if (Buffer.isBuffer(content) || content instanceof Uint8Array) {
+        writeByteLength(content.length)
+        // large buffers overflow spread operator stack; push manually above threshold
+        if (content.length > 10_000_000) {
+            pushBytes([...content.slice(0, Math.min(1000, content.length))])
+            for (let i = 1000; i < content.length; i++) buffer.push(content[i])
+        } else {
+            pushBytes(content)
+        }
+    } else if (Array.isArray(content)) {
+        const valid = content.filter(item => item && (item.tag || Buffer.isBuffer(item) || item instanceof Uint8Array || typeof item === 'string'))
+        writeListStart(valid.length)
+        for (const item of valid) encodeBinaryNodeInner(item, opts, buffer)
+    } else if (content !== undefined) {
+        throw new Error(`invalid children for header "${tag}": ${content} (${typeof content})`)
+    }
+}

package/lib/WABinary/generic-utils.js

@@ -0,0 +1,179 @@
+import { Boom } from '@hapi/boom'
+import { randomBytes } from 'crypto'
+import { proto } from '../../WAProto/index.js'
+
+// ─── Node Traversal ───────────────────────────────────────────────────────────
+
+export const getBinaryNodeChildren = (node, childTag) =>
+    Array.isArray(node?.content) ? node.content.filter(item => item.tag === childTag) : []
+
+export const getAllBinaryNodeChildren = ({ content }) =>
+    Array.isArray(content) ? content : []
+
+export const getBinaryNodeChild = (node, childTag) =>
+    Array.isArray(node?.content) ? node.content.find(item => item.tag === childTag) : undefined
+
+export const getBinaryNodeChildBuffer = (node, childTag) => {
+    const child = getBinaryNodeChild(node, childTag)?.content
+    return Buffer.isBuffer(child) || child instanceof Uint8Array ? child : undefined
+}
+
+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')
+    if (typeof child === 'string') return child
+}
+
+export const getBinaryNodeChildUInt = (node, childTag, length) => {
+    const buff = getBinaryNodeChildBuffer(node, childTag)
+    return buff ? bufferToUInt(buff, length) : undefined
+}
+
+export const getBinaryFilteredBizBot = nodeContent => {
+    if (!Array.isArray(nodeContent)) return false
+    return nodeContent.some(b => b?.tag === 'bot' && b?.attrs?.biz_bot === '1')
+}
+
+function bufferToUInt(e, t) {
+    let a = 0
+    for (let i = 0; i < t; i++) a = 256 * a + e[i]
+    return a
+}
+
+// ─── Node Validation ──────────────────────────────────────────────────────────
+
+export const assertNodeErrorFree = (node) => {
+    const errNode = getBinaryNodeChild(node, 'error')
+    if (errNode) {
+        const errorCode = +errNode.attrs.code
+        if (errorCode === 429) {
+            const error = new Boom('Rate limit', { data: 429 })
+            error.isRateLimit = true
+            throw error
+        }
+        throw new Boom(errNode.attrs.text || 'Unknown error', { data: errorCode })
+    }
+}
+
+export const reduceBinaryNodeToDictionary = (node, tag) => {
+    const nodes = getBinaryNodeChildren(node, tag)
+    return 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
+    }, {})
+}
+
+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
+}
+
+// ─── Button Type Detection ────────────────────────────────────────────────────
+
+export 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)
+    )
+}
+
+export const getButtonType = (message) => {
+    if (message.listMessage) return 'list'
+    if (message.buttonsMessage) return 'buttons'
+    const interactiveMsg = message.interactiveMessage || message.interactive
+    if (!interactiveMsg?.nativeFlowMessage) return null
+    const btn = interactiveMsg?.nativeFlowMessage?.buttons?.[0]?.name
+    if (['review_and_pay', 'review_order', 'payment_info', 'payment_status', 'payment_method'].includes(btn)) return btn
+    if (interactiveMsg?.nativeFlowMessage?.buttons?.length || interactiveMsg?.nativeFlowMessage) return 'interactive'
+    return null
+}
+
+// ─── Biz Binary Node (canonical single implementation) ────────────────────────
+
+const FLOWS_MAP = new Set(['mpm', 'catalog_message', 'send_location', 'call_permission_request', 'wa_payment_transaction_details', 'automated_greeting_message_view_catalog', 'card_message', 'order_status', 'track_order', 'reorder', 'cancel_order', 'clear_chat', 'navigateToScreen', 'payment_status', 'payment_method', 'flow', 'flow_action', 'voice_call', 'video_call_button', 'otp_button', 'authentication_button', 'cta_reminder', 'cta_cancel_reminder'])
+
+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'
+}
+
+const NATIVE_FLOW_ATTR = { type: 'native_flow', v: '1' }
+const MIXED_NATIVE_FLOW = { tag: 'interactive', attrs: NATIVE_FLOW_ATTR, content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }] }
+const LIST_TYPE_CONTENT = { tag: 'list', attrs: { v: '2', type: 'product_list' } }
+const DECISION_SOURCE = [{ tag: 'decision_source', attrs: { value: 'df' } }]
+
+export const getBizBinaryNode = (message) => {
+    const flowMsg = message.interactiveMessage?.nativeFlowMessage
+    const firstButtonName = flowMsg?.buttons?.[0]?.name
+    const bizAttrs = { actual_actors: '2', host_storage: '2', privacy_mode_ts: `${Date.now() / 1000 | 0}` }
+    const qualityContent = {
+        tag: 'quality_control',
+        attrs: { decision_id: randomBytes(20).toString('hex'), source_type: 'third_party' },
+        content: DECISION_SOURCE
+    }
+
+    if (firstButtonName && ORDER_RESPONSE_ALIAS[firstButtonName]) {
+        bizAttrs.native_flow_name = ORDER_RESPONSE_ALIAS[firstButtonName]
+        return { tag: 'biz', attrs: bizAttrs, content: [qualityContent] }
+    }
+    if (firstButtonName && FLOWS_MAP.has(firstButtonName)) {
+        return {
+            tag: 'biz', attrs: bizAttrs,
+            content: [
+                { tag: 'interactive', attrs: NATIVE_FLOW_ATTR, content: [{ tag: 'native_flow', attrs: { v: '2', name: firstButtonName } }] },
+                qualityContent
+            ]
+        }
+    }
+    if (flowMsg || message.buttonsMessage || message.templateMessage) {
+        return { tag: 'biz', attrs: bizAttrs, content: [MIXED_NATIVE_FLOW, qualityContent] }
+    }
+    if (message.listMessage) {
+        return { tag: 'biz', attrs: bizAttrs, content: [LIST_TYPE_CONTENT, qualityContent] }
+    }
+    return { tag: 'biz', attrs: bizAttrs, content: [qualityContent] }
+}
+
+// Legacy alias — kept for back-compat, delegates to canonical getBizBinaryNode
+export const getButtonArgs = (message) => {
+    const msgContent = message.viewOnceMessage?.message || message
+    const interactiveMsg = msgContent.interactiveMessage || msgContent.interactive
+    const flowMsg = interactiveMsg?.nativeFlowMessage
+    const btnFirst = flowMsg?.buttons?.[0]?.name
+    const ts = Math.floor(Date.now() / 1000) - 77980457
+    const order_response_name = { review_and_pay: 'order_details', review_order: 'order_status', payment_info: 'payment_info', payment_status: 'payment_status', payment_method: 'payment_method' }
+    const flow_name = { cta_catalog: 'cta_catalog', mpm: 'mpm', call_permission_request: 'call_permission_request', call_request: 'call_permission_request', view_catalog: 'automated_greeting_message_view_catalog', automated_greeting_message_view_catalog: 'automated_greeting_message_view_catalog', wa_pay_detail: 'wa_payment_transaction_details', wa_payment_transaction_details: 'wa_payment_transaction_details', send_location: 'send_location', open_webview: 'open_webview', galaxy_message: 'galaxy_message' }
+    if (btnFirst && order_response_name[btnFirst]) return [{ tag: 'biz', attrs: { native_flow_name: order_response_name[btnFirst] }, content: [] }]
+    if (flowMsg || msgContent.buttonsMessage) {
+        const name = (btnFirst && flow_name[btnFirst]) ? flow_name[btnFirst] : 'mixed'
+        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 }, content: [] }] }] }]
+    }
+    if (msgContent.listMessage) 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' } }] }]
+    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' } }] }]
+}
+
+// ─── Debug Utilities ──────────────────────────────────────────────────────────
+
+const tabs = (n) => '\t'.repeat(n)
+
+export const 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/lib/WABinary/index.js

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