@badzz88/baileys 8.4.9 → 8.5.0

package/lib/WABinary/encode.js

@@ -0,0 +1,228 @@
+'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);
+};
+const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
+    const { TAGS, TOKEN_MAP } = opts;
+    const pushByte = (value) => buffer.push(value & 0xff);
+    const pushInt = (value, n, 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) => {
+        for (const b of bytes) {
+            buffer.push(b);
+        }
+    };
+    const pushInt16 = (value) => {
+        pushBytes([(value >> 8) & 0xff, value & 0xff]);
+    };
+    const pushInt20 = (value) => pushBytes([(value >> 16) & 0x0f, (value >> 8) & 0xff, value & 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); // 32 bit integer
+        }
+        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 (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) => {
+        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) => {
+        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, type) => {
+        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, v2) => {
+            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) => {
+        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) => {
+        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) => {
+        if (str === undefined || str === null) {
+            pushByte(TAGS.LIST_EMPTY);
+            return;
+        }
+        if (str === '') {
+            writeStringRaw(str);
+            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 {
+            const decodedJid = jidDecode(str);
+            if (decodedJid) {
+                writeJid(decodedJid);
+            }
+            else {
+                writeStringRaw(str);
+            }
+        }
+    };
+    const writeListStart = (listSize) => {
+        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;
+};
+
+const encodeBinaryNode = (node, opts, buffer) => {
+	return encodeBinaryNodeJS(node, opts || constants, buffer || [0])
+}
+exports.encodeBinaryNode = encodeBinaryNode

package/{src → lib}/WABinary/generic-utils.js

@@ -53,7 +53,7 @@ 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('utf8')
+		return Buffer.from(child).toString('utf-8')
 	} else if (typeof child === 'string') {
 		return child
 	}
@@ -117,6 +117,98 @@ const getBinaryFilteredBizBot = nodeContent => {
 }
 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++) {

package/{src → lib}/WABinary/jid-utils.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, '__esModule', { value: true })
 exports.transferDevice =
 	exports.jidNormalizedUser =
-	exports.isJidLid =
 	exports.isJidBot =
 	exports.isHostedLidUser =
 	exports.isHostedPnUser =
@@ -24,13 +23,9 @@ exports.transferDevice =
 	exports.PSA_WID =
 	exports.SERVER_JID =
 	exports.OFFICIAL_BIZ_JID =
-	exports.BOT_WHATSAPP_NET =
-	exports.BOT_SERVER =
 	exports.S_WHATSAPP_NET =
 		void 0
 exports.S_WHATSAPP_NET = '@s.whatsapp.net'
-exports.BOT_WHATSAPP_NET = '@bot.whatsapp.net' // kept for compat; wire domain is '@bot'
-exports.BOT_SERVER = '@bot'
 exports.OFFICIAL_BIZ_JID = '16505361212@c.us'
 exports.SERVER_JID = 'server@c.us'
 exports.PSA_WID = '0@c.us'
@@ -40,7 +35,6 @@ var WAJIDDomains
 ;(function (WAJIDDomains) {
 	WAJIDDomains[(WAJIDDomains['WHATSAPP'] = 0)] = 'WHATSAPP'
 	WAJIDDomains[(WAJIDDomains['LID'] = 1)] = 'LID'
-	WAJIDDomains[(WAJIDDomains['BOT'] = 2)] = 'BOT'
 	WAJIDDomains[(WAJIDDomains['HOSTED'] = 128)] = 'HOSTED'
 	WAJIDDomains[(WAJIDDomains['HOSTED_LID'] = 129)] = 'HOSTED_LID'
 })(WAJIDDomains || (exports.WAJIDDomains = WAJIDDomains = {}))
@@ -48,8 +42,6 @@ const getServerFromDomainType = (initialServer, domainType) => {
 	switch (domainType) {
 		case WAJIDDomains.LID:
 			return 'lid'
-		case WAJIDDomains.BOT:
-			return 'bot'
 		case WAJIDDomains.HOSTED:
 			return 'hosted'
 		case WAJIDDomains.HOSTED_LID:
@@ -288,6 +280,7 @@ const jidEncode = (user, server, device, agent) => {
 }
 exports.jidEncode = jidEncode
 const jidDecode = jid => {
+	// todo: investigate how to implement hosted ids in this case
 	const sepIdx = typeof jid === 'string' ? jid.indexOf('@') : -1
 	if (sepIdx < 0) {
 		return undefined
@@ -299,14 +292,12 @@ const jidDecode = jid => {
 	let domainType = WAJIDDomains.WHATSAPP
 	if (server === 'lid') {
 		domainType = WAJIDDomains.LID
-	} else if (server === 'bot') {
-		domainType = WAJIDDomains.BOT
 	} else if (server === 'hosted') {
 		domainType = WAJIDDomains.HOSTED
 	} else if (server === 'hosted.lid') {
 		domainType = WAJIDDomains.HOSTED_LID
 	} else if (agent) {
-		domainType = parseInt(agent, 10)
+		domainType = parseInt(agent)
 	}
 	return {
 		server: server,
@@ -331,9 +322,6 @@ exports.isInteropUser = isInteropUser
 /** is the jid a LID */
 const isLidUser = jid => jid?.endsWith('@lid')
 exports.isLidUser = isLidUser
-/** is the jid a LID (isJidLid is an alias for isLidUser) */
-const isJidLid = jid => jid?.endsWith('@lid')
-exports.isJidLid = isJidLid
 /** is the jid a broadcast */
 const isJidBroadcast = jid => jid?.endsWith('@broadcast')
 exports.isJidBroadcast = isJidBroadcast
@@ -353,8 +341,7 @@ exports.isHostedPnUser = isHostedPnUser
 const isHostedLidUser = jid => jid?.endsWith('@hosted.lid')
 exports.isHostedLidUser = isHostedLidUser
 const botRegexp = /^1313555\d{4}$|^131655500\d{2}$/
-/** is the jid a bot — covers @bot wire domain and @c.us number patterns for WA-native bots */
-const isJidBot = jid => jid && ((botRegexp.test(jid.split('@')[0]) && jid.endsWith('@c.us')) || jid.endsWith('@bot'))
+const isJidBot = jid => jid && botRegexp.test(jid.split('@')[0]) && jid.endsWith('@c.us')
 exports.isJidBot = isJidBot
 const jidNormalizedUser = jid => {
 	const result = (0, exports.jidDecode)(jid)

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

@@ -124,7 +124,7 @@ function serializeData(key, value, flag) {
 		buffer.write(value, offset, 'utf8')
 		return buffer
 	}
-	throw new Error(`WAM serializeData: unsupported value type ${typeof value} for key ${key}`)
+	throw 'missing'
 }
 function serializeHeader(buffer, offset, key, flag) {
 	if (key < 256) {

package/lib/WAUSync/Protocols/USyncBusinessProtocol.js

@@ -0,0 +1,43 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.USyncBusinessProtocol = void 0
+const WABinary_1 = require('../../WABinary')
+class USyncBusinessProtocol {
+	constructor(profileVersion = '2') {
+		this.name = 'business'
+		this.profileVersion = profileVersion
+	}
+	getQueryElement() {
+		return {
+			tag: 'business',
+			attrs: {},
+			content: [
+				{ tag: 'verified_name', attrs: {} },
+				{ tag: 'profile', attrs: { v: this.profileVersion } }
+			]
+		}
+	}
+	getUserElement(user) {
+		const children = []
+		if (user.verifiedNameSerial) {
+			children.push({ tag: 'verified_name', attrs: { serial: user.verifiedNameSerial } })
+		}
+		if (user.businessProfileTag) {
+			children.push({ tag: 'profile', attrs: { tag: user.businessProfileTag } })
+		}
+		return children.length > 0 ? { tag: 'business', attrs: {}, content: children } : null
+	}
+	parser(node) {
+		if (node.tag !== 'business') return null
+		;(0, WABinary_1.assertNodeErrorFree)(node)
+		const verifiedNameNode = (0, WABinary_1.getBinaryNodeChild)(node, 'verified_name')
+		const profileNode = (0, WABinary_1.getBinaryNodeChild)(node, 'profile')
+		return {
+			verifiedName: verifiedNameNode?.content ?? null,
+			verifiedLevel: verifiedNameNode?.attrs?.verified_level ?? null,
+			profileTag: profileNode?.attrs?.tag ?? null,
+			pnJid: node.attrs?.pn_jid ?? null
+		}
+	}
+}
+exports.USyncBusinessProtocol = USyncBusinessProtocol

package/{src → lib}/WAUSync/Protocols/USyncContactProtocol.js

@@ -46,13 +46,7 @@ class USyncContactProtocol {
 	parser(node) {
 		if (node.tag === 'contact') {
 			;(0, WABinary_1.assertNodeErrorFree)(node)
-			const inWA = node?.attrs?.type === 'in'
-			const restrictionType = node?.attrs?.stella_addressbook_restriction_type
-			if (restrictionType !== undefined) {
-				// Return object with extra metadata when restriction type is present
-				return { inWA, stellaAddressbookRestrictionType: restrictionType }
-			}
-			return inWA
+			return node?.attrs?.type === 'in'
 		}
 		return false
 	}

package/{src → lib}/WAUSync/Protocols/USyncDeviceProtocol.js

@@ -14,19 +14,11 @@ class USyncDeviceProtocol {
 			}
 		}
 	}
-	getUserElement(user) {
-		const { deviceHash, ts, expectedTs } = user
-		if (deviceHash == null && ts == null && expectedTs == null) {
-			return null
-		}
-		const attrs = {}
-		if (deviceHash != null) attrs.device_hash = deviceHash
-		if (ts != null) attrs.ts = String(ts)
-		if (expectedTs != null) attrs.expected_ts = String(expectedTs)
-		return {
-			tag: 'devices',
-			attrs
-		}
+	getUserElement(/* user: USyncUser */) {
+		//TODO: Implement device phashing, ts and expectedTs
+		//TODO: if all are not present, return null <- current behavior
+		//TODO: otherwise return a node w tag 'devices' w those as attrs
+		return null
 	}
 	parser(node) {
 		const deviceList = []

package/{src → lib}/WAUSync/Protocols/USyncDisappearingModeProtocol.js

@@ -20,7 +20,10 @@ class USyncDisappearingModeProtocol {
 			;(0, WABinary_1.assertNodeErrorFree)(node)
 			const duration = +node?.attrs.duration
 			const setAt = new Date(+(node?.attrs.t || 0) * 1000)
-			return { duration, setAt }
+			return {
+				duration,
+				setAt
+			}
 		}
 	}
 }

package/{src → lib}/WAUSync/Protocols/USyncFeatureProtocol.js

@@ -15,9 +15,7 @@ exports.USYNC_FEATURES = [
 	'encrypt_url',
 	'encrypt_v2',
 	'voip',
-	'voip_legacy',
-	'multi_agent',
-	'bot_eligible'
+	'multi_agent'
 ]
 class USyncFeatureProtocol {
 	/**
@@ -48,24 +46,11 @@ class USyncFeatureProtocol {
 				errorText: errorNode.attrs?.text
 			}
 		}
-		const CAMEL_MAP = {
-			encrypt_v2: 'encryptV2',
-			voip_legacy: 'voipLegacy',
-			multi_agent: 'multiAgent',
-			bot_eligible: 'botEligible',
-			encrypt_blist: 'encryptBlist',
-			encrypt_contact: 'encryptContact',
-			encrypt_group_gen2: 'encryptGroupGen2',
-			encrypt_image: 'encryptImage',
-			encrypt_location: 'encryptLocation',
-			encrypt_url: 'encryptUrl'
-		}
 		const features = {}
 		const children = Array.isArray(node.content) ? node.content : []
 		for (const child of children) {
 			if (child?.attrs && child.attrs.value !== undefined) {
-				const key = CAMEL_MAP[child.tag] || child.tag
-				features[key] = child.attrs.value
+				features[child.tag] = child.attrs.value
 			}
 		}
 		return features

package/{src → lib}/WAUSync/Protocols/USyncStatusProtocol.js

@@ -12,13 +12,8 @@ class USyncStatusProtocol {
 			attrs: {}
 		}
 	}
-	getUserElement(user) {
-		if (!user?.tcToken) return null
-		return {
-			tag: 'tctoken',
-			attrs: {},
-			content: user.tcToken
-		}
+	getUserElement() {
+		return null
 	}
 	parser(node) {
 		if (node.tag === 'status') {

package/{src → lib}/WAUSync/Protocols/USyncUsernameProtocol.js

@@ -19,8 +19,7 @@ class USyncUsernameProtocol {
 	parser(node) {
 		if (node.tag === 'username') {
 			;(0, WABinary_1.assertNodeErrorFree)(node)
-			const username = node.content != null ? node.content.toString() : null
-			return username && username.length > 0 ? username : null
+			return typeof node.content === 'string' ? node.content : null
 		}
 		return null
 	}

package/{src → lib}/WAUSync/Protocols/index.js

@@ -35,6 +35,5 @@ __exportStar(require('./USyncBotProfileProtocol'), exports)
 __exportStar(require('./USyncBusinessProtocol'), exports)
 __exportStar(require('./USyncPictureProtocol'), exports)
 __exportStar(require('./USyncTextStatusProtocol'), exports)
-__exportStar(require('./USyncLIDProtocol'), exports)
 __exportStar(require('./USyncSidelistProtocol'), exports)
 __exportStar(require('./USyncFeatureProtocol'), exports)