gifted-baileys 1.5.4 → 1.5.6

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

@@ -36,12 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeBinaryNode = void 0;
 const constants = __importStar(require("./constants"));
 const jid_utils_1 = require("./jid-utils");
-const encodeBinaryNode = (node, opts = constants, buffer = [0]) => {
-    const encoded = encodeBinaryNodeInner(node, opts, buffer);
-    return Buffer.from(encoded);
-};
-exports.encodeBinaryNode = encodeBinaryNode;
-const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
+const encodeBinaryNode = ({ tag, attrs, content }, opts = constants, buffer = [0]) => {
     const { TAGS, TOKEN_MAP } = opts;
     const pushByte = (value) => buffer.push(value & 0xff);
     const pushInt = (value, n, littleEndian = false) => {
@@ -50,11 +45,7 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
             buffer.push((value >> (curShift * 8)) & 0xff);
         }
     };
-    const pushBytes = (bytes) => {
-        for (const b of bytes) {
-            buffer.push(b);
-        }
-    };
+    const pushBytes = (bytes) => (bytes.forEach(b => buffer.push(b)));
     const pushInt16 = (value) => {
         pushBytes([(value >> 8) & 0xff, value & 0xff]);
     };
@@ -156,7 +147,8 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
         if (str.length > TAGS.PACKED_MAX) {
             return false;
         }
-        for (const char of str) {
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
             const isInNibbleRange = char >= '0' && char <= '9';
             if (!isInNibbleRange && char !== '-' && char !== '.') {
                 return false;
@@ -168,9 +160,10 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
         if (str.length > TAGS.PACKED_MAX) {
             return false;
         }
-        for (const char of str) {
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
             const isInNibbleRange = char >= '0' && char <= '9';
-            if (!isInNibbleRange && !(char >= 'A' && char <= 'F')) {
+            if (!isInNibbleRange && !(char >= 'A' && char <= 'F') && !(char >= 'a' && char <= 'f')) {
                 return false;
             }
         }
@@ -231,7 +224,7 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
     else if (Array.isArray(content)) {
         writeListStart(content.length);
         for (const item of content) {
-            encodeBinaryNodeInner(item, opts, buffer);
+            (0, exports.encodeBinaryNode)(item, opts, buffer);
         }
     }
     else if (typeof content === 'undefined') {
@@ -240,5 +233,6 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
     else {
         throw new Error(`invalid children for header "${tag}": ${content} (${typeof content})`);
     }
-    return buffer;
+    return Buffer.from(buffer);
 };
+exports.encodeBinaryNode = encodeBinaryNode;

package/src/WABinary/encode.ts

@@ -0,0 +1,236 @@
+
+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

@@ -0,0 +1,121 @@
+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

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

package/src/WABinary/jid-utils.ts

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,17 @@
+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

package/src/WAM/BinaryInfo.ts

@@ -0,0 +1,12 @@
+import { EventInputType } from './constants'
+
+export class BinaryInfo {
+	protocolVersion = 5
+	sequence = 0
+	events = [] as EventInputType[]
+	buffer: Buffer[] = []
+
+	constructor(options: Partial<BinaryInfo> = {}) {
+		Object.assign(this, options)
+	}
+}