@sixcore/baileys 1.0.0

package/src/WABinary/decode.ts

@@ -0,0 +1,281 @@
+import { promisify } from 'util'
+import { inflate } from 'zlib'
+import * as constants from './constants'
+import { jidEncode, type JidServer, WAJIDDomains } from './jid-utils'
+import type { BinaryNode, BinaryNodeCodingOptions } from './types'
+
+const inflatePromise = promisify(inflate)
+
+export const decompressingIfRequired = async (buffer: Buffer) => {
+	if (2 & buffer.readUInt8()) {
+		buffer = await inflatePromise(buffer.slice(1))
+	} else {
+		// nodes with no compression have a 0x00 prefix, we remove that
+		buffer = buffer.slice(1)
+	}
+
+	return buffer
+}
+
+export const decodeDecompressedBinaryNode = (
+	buffer: Buffer,
+	opts: Pick<BinaryNodeCodingOptions, 'DOUBLE_BYTE_TOKENS' | 'SINGLE_BYTE_TOKENS' | 'TAGS'>,
+	indexRef: { index: number } = { index: 0 }
+): BinaryNode => {
+	const { DOUBLE_BYTE_TOKENS, SINGLE_BYTE_TOKENS, TAGS } = opts
+
+	const checkEOS = (length: number) => {
+		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: number) => {
+		checkEOS(n)
+		const value = buffer.slice(indexRef.index, indexRef.index + n)
+		indexRef.index += n
+		return value
+	}
+
+	const readStringFromChars = (length: number) => {
+		return readBytes(length).toString('utf-8')
+	}
+
+	const readInt = (n: number, 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: number) => {
+		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: number) => {
+		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: number, value: number) => {
+		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: number) => {
+		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: number) => {
+		return tag === TAGS.LIST_EMPTY || tag === TAGS.LIST_8 || tag === TAGS.LIST_16
+	}
+
+	const readListSize = (tag: number) => {
+		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: JidServer = 's.whatsapp.net' // default whatsapp server
+		if (domainType === WAJIDDomains.LID) {
+			server = 'lid'
+		} else if (domainType === WAJIDDomains.HOSTED) {
+			server = 'hosted'
+		} else if (domainType === WAJIDDomains.HOSTED_LID) {
+			server = 'hosted.lid'
+		}
+
+		return jidEncode(user, server, device)
+	}
+
+	const readString = (tag: number): string => {
+		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: number) => {
+		const items: BinaryNode[] = []
+		const size = readListSize(tag)!
+		for (let i = 0; i < size; i++) {
+			items.push(decodeDecompressedBinaryNode(buffer, opts, indexRef))
+		}
+
+		return items
+	}
+
+	const getTokenDouble = (index1: number, index2: number) => {
+		const dict = DOUBLE_BYTE_TOKENS[index1]
+		if (!dict) {
+			throw new Error(`Invalid double token dict (${index1})`)
+		}
+
+		const value = dict[index2]
+		if (typeof value === 'undefined') {
+			throw new Error(`Invalid double token (${index2})`)
+		}
+
+		return value
+	}
+
+	const listSize = readListSize(readByte()!)
+	const header = readString(readByte()!)
+	if (!listSize || !header.length) {
+		throw new Error('invalid node')
+	}
+
+	const attrs: BinaryNode['attrs'] = {}
+	let data: BinaryNode['content']
+	if (listSize === 0 || !header) {
+		throw new Error('invalid node')
+	}
+
+	// read the attributes in
+	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: Buffer | string
+			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
+	}
+}
+
+export const decodeBinaryNode = async (buff: Buffer): Promise<BinaryNode> => {
+	const decompBuff = await decompressingIfRequired(buff)
+	return decodeDecompressedBinaryNode(decompBuff, constants)
+}

package/src/WABinary/encode.ts

@@ -0,0 +1,253 @@
+import * as constants from './constants'
+import { type FullJid, jidDecode } from './jid-utils'
+import type { BinaryNode, BinaryNodeCodingOptions } from './types'
+
+export const encodeBinaryNode = (
+	node: BinaryNode,
+	opts: Pick<BinaryNodeCodingOptions, 'TAGS' | 'TOKEN_MAP'> = constants,
+	buffer: number[] = [0]
+): Buffer => {
+	const encoded = encodeBinaryNodeInner(node, opts, buffer)
+	return Buffer.from(encoded)
+}
+
+const encodeBinaryNodeInner = (
+	{ tag, attrs, content }: BinaryNode,
+	opts: Pick<BinaryNodeCodingOptions, 'TAGS' | 'TOKEN_MAP'>,
+	buffer: number[]
+): number[] => {
+	const { TAGS, TOKEN_MAP } = opts
+
+	const pushByte = (value: number) => buffer.push(value & 0xff)
+
+	const pushInt = (value: number, n: number, littleEndian = false) => {
+		for (let i = 0; i < n; i++) {
+			const curShift = littleEndian ? i : n - 1 - i
+			buffer.push((value >> (curShift * 8)) & 0xff)
+		}
+	}
+
+	const pushBytes = (bytes: Uint8Array | Buffer | number[]) => {
+		for (const b of bytes) {
+			buffer.push(b)
+		}
+	}
+
+	const pushInt16 = (value: number) => {
+		pushBytes([(value >> 8) & 0xff, value & 0xff])
+	}
+
+	const pushInt20 = (value: number) => pushBytes([(value >> 16) & 0x0f, (value >> 8) & 0xff, value & 0xff])
+	const writeByteLength = (length: number) => {
+		if (length >= 4294967296) {
+			throw new Error('string too large to encode: ' + length)
+		}
+
+		if (length >= 1 << 20) {
+			pushByte(TAGS.BINARY_32)
+			pushInt(length, 4) // 32 bit integer
+		} else if (length >= 256) {
+			pushByte(TAGS.BINARY_20)
+			pushInt20(length)
+		} else {
+			pushByte(TAGS.BINARY_8)
+			pushByte(length)
+		}
+	}
+
+	const writeStringRaw = (str: string) => {
+		const bytes = Buffer.from(str, 'utf-8')
+		writeByteLength(bytes.length)
+		pushBytes(bytes)
+	}
+
+	const writeJid = ({ domainType, device, user, server }: FullJid) => {
+		if (typeof 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: string) => {
+		switch (char) {
+			case '-':
+				return 10
+			case '.':
+				return 11
+			case '\0':
+				return 15
+			default:
+				if (char >= '0' && char <= '9') {
+					return char.charCodeAt(0) - '0'.charCodeAt(0)
+				}
+
+				throw new Error(`invalid byte for nibble "${char}"`)
+		}
+	}
+
+	const packHex = (char: string) => {
+		if (char >= '0' && char <= '9') {
+			return char.charCodeAt(0) - '0'.charCodeAt(0)
+		}
+
+		if (char >= 'A' && char <= 'F') {
+			return 10 + char.charCodeAt(0) - 'A'.charCodeAt(0)
+		}
+
+		if (char >= 'a' && char <= 'f') {
+			return 10 + char.charCodeAt(0) - 'a'.charCodeAt(0)
+		}
+
+		if (char === '\0') {
+			return 15
+		}
+
+		throw new Error(`Invalid hex char "${char}"`)
+	}
+
+	const writePackedBytes = (str: string, type: 'nibble' | 'hex') => {
+		if (str.length > TAGS.PACKED_MAX) {
+			throw new Error('Too many bytes to pack')
+		}
+
+		pushByte(type === 'nibble' ? TAGS.NIBBLE_8 : TAGS.HEX_8)
+
+		let roundedLength = Math.ceil(str.length / 2.0)
+		if (str.length % 2 !== 0) {
+			roundedLength |= 128
+		}
+
+		pushByte(roundedLength)
+		const packFunction = type === 'nibble' ? packNibble : packHex
+
+		const packBytePair = (v1: string, v2: string) => {
+			const result = (packFunction(v1) << 4) | packFunction(v2)
+			return result
+		}
+
+		const strLengthHalf = Math.floor(str.length / 2)
+		for (let i = 0; i < strLengthHalf; i++) {
+			pushByte(packBytePair(str[2 * i]!, str[2 * i + 1]!))
+		}
+
+		if (str.length % 2 !== 0) {
+			pushByte(packBytePair(str[str.length - 1]!, '\x00'))
+		}
+	}
+
+	const isNibble = (str?: string) => {
+		if (!str || str.length > TAGS.PACKED_MAX) {
+			return false
+		}
+
+		for (const char of str) {
+			const isInNibbleRange = char >= '0' && char <= '9'
+			if (!isInNibbleRange && char !== '-' && char !== '.') {
+				return false
+			}
+		}
+
+		return true
+	}
+
+	const isHex = (str?: string) => {
+		if (!str || str.length > TAGS.PACKED_MAX) {
+			return false
+		}
+
+		for (const char of str) {
+			const isInNibbleRange = char >= '0' && char <= '9'
+			if (!isInNibbleRange && !(char >= 'A' && char <= 'F')) {
+				return false
+			}
+		}
+
+		return true
+	}
+
+	const writeString = (str?: string) => {
+		if (str === undefined || 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 decodedJid = jidDecode(str)
+			if (decodedJid) {
+				writeJid(decodedJid)
+			} else {
+				writeStringRaw(str)
+			}
+		}
+	}
+
+	const writeListStart = (listSize: number) => {
+		if (listSize === 0) {
+			pushByte(TAGS.LIST_EMPTY)
+		} else if (listSize < 256) {
+			pushBytes([TAGS.LIST_8, listSize])
+		} else {
+			pushByte(TAGS.LIST_16)
+			pushInt16(listSize)
+		}
+	}
+
+	if (!tag) {
+		throw new Error('Invalid node: tag cannot be undefined')
+	}
+
+	const validAttributes = Object.keys(attrs || {}).filter(k => typeof attrs[k] !== 'undefined' && attrs[k] !== null)
+
+	writeListStart(2 * validAttributes.length + 1 + (typeof content !== 'undefined' ? 1 : 0))
+	writeString(tag)
+
+	for (const key of validAttributes) {
+		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)
+		pushBytes(content)
+	} else if (Array.isArray(content)) {
+		const validContent = content.filter(
+			item => item && (item.tag || Buffer.isBuffer(item) || item instanceof Uint8Array || typeof item === 'string')
+		)
+		writeListStart(validContent.length)
+		for (const item of validContent) {
+			encodeBinaryNodeInner(item, opts, buffer)
+		}
+	} else if (typeof content === 'undefined') {
+		// do nothing
+	} else {
+		throw new Error(`invalid children for header "${tag}": ${content} (${typeof content})`)
+	}
+
+	return buffer
+}

package/src/WABinary/generic-utils.ts

@@ -0,0 +1,127 @@
+import { Boom } from '@hapi/boom'
+import { proto } from '../../WAProto/index.js'
+import { type BinaryNode } from './types'
+
+// some extra useful utilities
+
+export const getBinaryNodeChildren = (node: BinaryNode | undefined, childTag: string) => {
+	if (Array.isArray(node?.content)) {
+		return node.content.filter(item => item.tag === childTag)
+	}
+
+	return []
+}
+
+export const getAllBinaryNodeChildren = ({ content }: BinaryNode) => {
+	if (Array.isArray(content)) {
+		return content
+	}
+
+	return []
+}
+
+export const getBinaryNodeChild = (node: BinaryNode | undefined, childTag: string) => {
+	if (Array.isArray(node?.content)) {
+		return node?.content.find(item => item.tag === childTag)
+	}
+}
+
+export const getBinaryNodeChildBuffer = (node: BinaryNode | undefined, childTag: string) => {
+	const child = getBinaryNodeChild(node, childTag)?.content
+	if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
+		return child
+	}
+}
+
+export const getBinaryNodeChildString = (node: BinaryNode | undefined, childTag: string) => {
+	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: BinaryNode, childTag: string, length: number) => {
+	const buff = getBinaryNodeChildBuffer(node, childTag)
+	if (buff) {
+		return bufferToUInt(buff, length)
+	}
+}
+
+export const assertNodeErrorFree = (node: BinaryNode) => {
+	const errNode = getBinaryNodeChild(node, 'error')
+	if (errNode) {
+		throw new Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code! })
+	}
+}
+
+export const reduceBinaryNodeToDictionary = (node: BinaryNode, tag: string) => {
+	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
+		},
+		{} as { [_: string]: string }
+	)
+	return dict
+}
+
+export const getBinaryNodeMessages = ({ content }: BinaryNode) => {
+	const msgs: proto.WebMessageInfo[] = []
+	if (Array.isArray(content)) {
+		for (const item of content) {
+			if (item.tag === 'message') {
+				msgs.push(proto.WebMessageInfo.decode(item.content as Buffer).toJSON() as proto.WebMessageInfo)
+			}
+		}
+	}
+
+	return msgs
+}
+
+function bufferToUInt(e: Uint8Array | Buffer, t: number) {
+	let a = 0
+	for (let i = 0; i < t; i++) {
+		a = 256 * a + e[i]!
+	}
+
+	return a
+}
+
+const tabs = (n: number) => '\t'.repeat(n)
+
+export function binaryNodeToString(node: BinaryNode | BinaryNode['content'], i = 0): string {
+	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: string = children ? `>\n${children}\n${tabs(i)}</${node.tag}>` : '/>'
+
+	return tag + content
+}

package/src/WABinary/index.ts

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