gifted-baileys 1.5.6 → 1.5.7

package/src/WABinary/decode.ts

@@ -1,265 +0,0 @@
-import { inflateSync } from 'zlib'
-import * as constants from './constants'
-import { jidEncode } from './jid-utils'
-import type { BinaryNode, BinaryNodeCodingOptions } from './types'
-
-export const decompressingIfRequired = (buffer: Buffer) => {
-	if(2 & buffer.readUInt8()) {
-		buffer = inflateSync(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 agent = readByte()
-		const device = readByte()
-		const user = readString(readByte())
-
-		return jidEncode(user, agent === 0 ? 's.whatsapp.net' : 'lid', 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 = (buff: Buffer): BinaryNode => {
-	const decompBuff = decompressingIfRequired(buff)
-	return decodeDecompressedBinaryNode(decompBuff, constants)
-}

package/src/WABinary/encode.ts

@@ -1,236 +0,0 @@
-
-import * as constants from './constants'
-import { FullJid, jidDecode } from './jid-utils'
-import type { BinaryNode, BinaryNodeCodingOptions } from './types'
-
-export const encodeBinaryNode = (
-	{ tag, attrs, content }: BinaryNode,
-	opts: Pick<BinaryNodeCodingOptions, 'TAGS' | 'TOKEN_MAP'> = constants,
-	buffer: number[] = [0]
-) => {
-	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[]) => (
-		bytes.forEach (b => 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.length > TAGS.PACKED_MAX) {
-			return false
-		}
-
-		for(let i = 0;i < str.length;i++) {
-			const char = str[i]
-			const isInNibbleRange = char >= '0' && char <= '9'
-			if(!isInNibbleRange && char !== '-' && char !== '.') {
-				return false
-			}
-		}
-
-		return true
-	}
-
-	const isHex = (str: string) => {
-		if(str.length > TAGS.PACKED_MAX) {
-			return false
-		}
-
-		for(let i = 0;i < str.length;i++) {
-			const char = str[i]
-			const isInNibbleRange = char >= '0' && char <= '9'
-			if(!isInNibbleRange && !(char >= 'A' && char <= 'F') && !(char >= 'a' && char <= 'f')) {
-				return false
-			}
-		}
-
-		return true
-	}
-
-	const writeString = (str: string) => {
-		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)
-		}
-	}
-
-	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)) {
-		writeListStart(content.length)
-		for(const item of content) {
-			encodeBinaryNode(item, opts, buffer)
-		}
-	} else if(typeof content === 'undefined') {
-		// do nothing
-	} else {
-		throw new Error(`invalid children for header "${tag}": ${content} (${typeof content})`)
-	}
-
-	return Buffer.from(buffer)
-}

package/src/WABinary/generic-utils.ts

@@ -1,121 +0,0 @@
-import { Boom } from '@hapi/boom'
-import { proto } from '../../WAProto'
-import { 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 }) => {
-			dict[attrs.name || 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))
-			}
-		}
-	}
-
-	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) {
-	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

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

package/src/WABinary/jid-utils.ts

@@ -1,68 +0,0 @@
-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 type JidServer = 'c.us' | 'g.us' | 'broadcast' | 's.whatsapp.net' | 'call' | 'lid' | 'newsletter'
-
-export type JidWithDevice = {
-    user: string
-    device?: number
-}
-
-export type FullJid = JidWithDevice & {
-	server: JidServer | string
-	domainType?: number
-}
-
-export const jidEncode = (user: string | number | null, server: JidServer, device?: number, agent?: number) => {
-	return `${user || ''}${!!agent ? `_${agent}` : ''}${!!device ? `:${device}` : ''}@${server}`
-}
-
-export const jidDecode = (jid: string | undefined): FullJid | undefined => {
-	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 = userAgent.split('_')[0]
-
-	return {
-		server,
-		user,
-		domainType: server === 'lid' ? 1 : 0,
-		device: device ? +device : undefined
-	}
-}
-
-/** is the jid a user */
-export const areJidsSameUser = (jid1: string | undefined, jid2: string | undefined) => (
-	jidDecode(jid1)?.user === jidDecode(jid2)?.user
-)
-/** is the jid a user */
-export const isJidUser = (jid: string | undefined) => (jid?.endsWith('@s.whatsapp.net'))
-/** is the jid a group */
-export const isLidUser = (jid: string | undefined) => (jid?.endsWith('@lid'))
-/** is the jid a broadcast */
-export const isJidBroadcast = (jid: string | undefined) => (jid?.endsWith('@broadcast'))
-/** is the jid a group */
-export const isJidGroup = (jid: string | undefined) => (jid?.endsWith('@g.us'))
-/** is the jid the status broadcast */
-export const isJidStatusBroadcast = (jid: string) => jid === 'status@broadcast'
-/** is the jid the newsletter */
-export const isJidNewsLetter = (jid: string | undefined) => (jid?.endsWith('newsletter'))
-
-export const jidNormalizedUser = (jid: string | undefined) => {
-	const result = jidDecode(jid)
-	if(!result) {
-		return ''
-	}
-
-	const { user, server } = result
-	return jidEncode(user, server === 'c.us' ? 's.whatsapp.net' : server as JidServer)
-}

package/src/WABinary/types.ts

@@ -1,17 +0,0 @@
-import * as constants from './constants'
-/**
- * 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