@badzz88/baileys 8.4.7 → 8.5.0

package/lib/Utils/jid-display-normalization.js

@@ -0,0 +1,218 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.normalizeMessageForDisplayJids = void 0
+exports.normalizeMentionedJidsForSend = void 0
+
+const WABinary_1 = require('../WABinary')
+
+const createLidPnDebug = logger => {
+	const enabled = process.env.LID_PN_DEBUG === '1' || process.env.LID_PN_DEBUG === 'true'
+	return (phase, payload) => {
+		if (!enabled) {
+			return
+		}
+		logger?.debug({ ...payload, phase }, 'lid->pn normalization trace')
+	}
+}
+
+const fallbackPnFromLidJid = jid => {
+	const decoded = (0, WABinary_1.jidDecode)(jid)
+	const rawUser = decoded?.user || (typeof jid === 'string' ? jid.split('@')[0] : '')
+	const user = rawUser.split(':')[0]
+	if (!user) {
+		return jid
+	}
+	return `${user}@s.whatsapp.net`
+}
+
+const toDisplayPnJid = jid => {
+	if (!jid || typeof jid !== 'string') {
+		return jid
+	}
+	const decoded = (0, WABinary_1.jidDecode)(jid)
+	if (!decoded?.user) {
+		return jid
+	}
+	if (!(0, WABinary_1.isPnUser)(jid) && !(0, WABinary_1.isHostedPnUser)(jid)) {
+		return jid
+	}
+	const user = decoded.user.split(':')[0]
+	if (!user) {
+		return jid
+	}
+	const server = decoded.server === 'hosted' ? 'hosted' : 's.whatsapp.net'
+	return `${user}@${server}`
+}
+
+const buildLidPnHints = key => {
+	const hints = new Map()
+	if (!key) {
+		return hints
+	}
+	const addHint = (lid, pn) => {
+		if (!(0, WABinary_1.isLidUser)(lid) && !(0, WABinary_1.isHostedLidUser)(lid)) {
+			return
+		}
+		if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) {
+			return
+		}
+		hints.set(lid, pn)
+		const lidDecoded = (0, WABinary_1.jidDecode)(lid)
+		const pnDecoded = (0, WABinary_1.jidDecode)(pn)
+		if (lidDecoded?.user && pnDecoded?.user) {
+			hints.set(`${lidDecoded.user}@lid`, `${pnDecoded.user}@s.whatsapp.net`)
+		}
+	}
+	addHint(key.participant, key.participantAlt)
+	addHint(key.remoteJid, key.remoteJidAlt)
+	addHint(key.participantAlt, key.participant)
+	addHint(key.remoteJidAlt, key.remoteJid)
+	return hints
+}
+
+const mergeGroupDataHints = (hints, groupData, debug) => {
+	if (!groupData?.participants?.length) {
+		return
+	}
+	debug?.('groupData-size', { participants: groupData.participants.length })
+	for (const participant of groupData.participants) {
+		const lidCandidate = participant?.lid
+		const idCandidate = participant?.id
+		const pnCandidate = participant?.phoneNumber
+		const lid =
+			((0, WABinary_1.isLidUser)(lidCandidate) || (0, WABinary_1.isHostedLidUser)(lidCandidate)
+				? lidCandidate
+				: undefined) ||
+			((0, WABinary_1.isLidUser)(idCandidate) || (0, WABinary_1.isHostedLidUser)(idCandidate) ? idCandidate : undefined)
+		const pn =
+			((0, WABinary_1.isPnUser)(pnCandidate) || (0, WABinary_1.isHostedPnUser)(pnCandidate)
+				? pnCandidate
+				: undefined) ||
+			((0, WABinary_1.isPnUser)(idCandidate) || (0, WABinary_1.isHostedPnUser)(idCandidate) ? idCandidate : undefined)
+		if (!lid || !pn) {
+			continue
+		}
+		if (
+			((0, WABinary_1.isLidUser)(lid) || (0, WABinary_1.isHostedLidUser)(lid)) &&
+			((0, WABinary_1.isPnUser)(pn) || (0, WABinary_1.isHostedPnUser)(pn))
+		) {
+			const displayPn = toDisplayPnJid(pn)
+			hints.set(lid, displayPn)
+			const lidDecoded = (0, WABinary_1.jidDecode)(lid)
+			if (lidDecoded?.user) {
+				hints.set(`${lidDecoded.user}@lid`, displayPn)
+			}
+			debug?.('group-hint', { lid, pn: displayPn })
+		}
+	}
+}
+
+const normalizeToPnJid = async (jid, hints, signalRepository, debug) => {
+	if (!jid || typeof jid !== 'string') {
+		return jid
+	}
+	if (!(0, WABinary_1.isLidUser)(jid) && !(0, WABinary_1.isHostedLidUser)(jid)) {
+		return jid
+	}
+	debug?.('input', { lid: jid })
+	const hinted = hints.get(jid)
+	if (hinted) {
+		const normalized = toDisplayPnJid(hinted)
+		debug?.('hint-exact', { lid: jid, hinted, normalized })
+		return normalized
+	}
+	const decoded = (0, WABinary_1.jidDecode)(jid)
+	if (decoded?.user) {
+		const userHint = hints.get(`${decoded.user}@lid`)
+		if (userHint) {
+			const normalized = toDisplayPnJid(userHint)
+			debug?.('hint-user', { lid: jid, userHint, normalized })
+			return normalized
+		}
+	}
+	const mapped = await signalRepository?.lidMapping?.getPNForLID?.(jid)
+	if (mapped) {
+		const normalized = toDisplayPnJid(mapped)
+		debug?.('mapping', { lid: jid, mapped, normalized })
+		return normalized
+	}
+	const fallback = fallbackPnFromLidJid(jid)
+	debug?.('fallback', { lid: jid, fallback })
+	return fallback
+}
+
+const normalizeMentionedJidsToPn = async (node, hints, signalRepository, debug) => {
+	if (!node || typeof node !== 'object') {
+		return
+	}
+	if (Array.isArray(node)) {
+		for (const item of node) {
+			await normalizeMentionedJidsToPn(item, hints, signalRepository, debug)
+		}
+		return
+	}
+	if (Array.isArray(node.mentionedJid)) {
+		const before = [...node.mentionedJid]
+		node.mentionedJid = await Promise.all(
+			node.mentionedJid.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug))
+		)
+		debug?.('mentions', { before, after: node.mentionedJid })
+	}
+	if (typeof node.participant === 'string') {
+		const before = node.participant
+		node.participant = await normalizeToPnJid(node.participant, hints, signalRepository, debug)
+		if (before !== node.participant) {
+			debug?.('participant-field', { before, after: node.participant })
+		}
+	}
+	if (typeof node.remoteJid === 'string') {
+		const before = node.remoteJid
+		node.remoteJid = await normalizeToPnJid(node.remoteJid, hints, signalRepository, debug)
+		if (before !== node.remoteJid) {
+			debug?.('remoteJid-field', { before, after: node.remoteJid })
+		}
+	}
+	for (const value of Object.values(node)) {
+		if (value && typeof value === 'object') {
+			await normalizeMentionedJidsToPn(value, hints, signalRepository, debug)
+		}
+	}
+}
+
+const normalizeMentionedJidsForSend = async (mentions, groupData, signalRepository, logger) => {
+	if (!Array.isArray(mentions)) {
+		return mentions
+	}
+	const debug = createLidPnDebug(logger)
+	const hints = new Map()
+	mergeGroupDataHints(hints, groupData, debug)
+	const normalized = await Promise.all(mentions.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)))
+	debug('send-mentions-result', { before: mentions, after: normalized })
+	return normalized
+}
+
+const normalizeMessageForDisplayJids = async (messageInfo, signalRepository, logger, groupData) => {
+	if (!messageInfo?.key) {
+		return messageInfo
+	}
+	const debug = createLidPnDebug(logger)
+	const hints = buildLidPnHints(messageInfo.key)
+	mergeGroupDataHints(hints, groupData, debug)
+	const beforeKey = { ...messageInfo.key }
+	messageInfo.key.participant = await normalizeToPnJid(messageInfo.key.participant, hints, signalRepository, debug)
+	messageInfo.key.participantAlt = await normalizeToPnJid(
+		messageInfo.key.participantAlt,
+		hints,
+		signalRepository,
+		debug
+	)
+	messageInfo.key.remoteJid = await normalizeToPnJid(messageInfo.key.remoteJid, hints, signalRepository, debug)
+	messageInfo.key.remoteJidAlt = await normalizeToPnJid(messageInfo.key.remoteJidAlt, hints, signalRepository, debug)
+	await normalizeMentionedJidsToPn(messageInfo.message, hints, signalRepository, debug)
+	debug('display-key-result', { before: beforeKey, after: messageInfo.key })
+	return messageInfo
+}
+
+exports.normalizeMessageForDisplayJids = normalizeMessageForDisplayJids
+exports.normalizeMentionedJidsForSend = normalizeMentionedJidsForSend

package/lib/Utils/link-preview.js

@@ -1,85 +1,143 @@
-import { prepareWAMessageMedia } from './messages.js';
-import { extractImageThumb, getHttpStream } from './messages-media.js';
-const THUMBNAIL_WIDTH_PX = 192;
+'use strict'
+var __createBinding =
+	(this && this.__createBinding) ||
+	(Object.create
+		? function (o, m, k, k2) {
+				if (k2 === undefined) k2 = k
+				var desc = Object.getOwnPropertyDescriptor(m, k)
+				if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+					desc = {
+						enumerable: true,
+						get: function () {
+							return m[k]
+						}
+					}
+				}
+				Object.defineProperty(o, k2, desc)
+			}
+		: function (o, m, k, k2) {
+				if (k2 === undefined) k2 = k
+				o[k2] = m[k]
+			})
+var __setModuleDefault =
+	(this && this.__setModuleDefault) ||
+	(Object.create
+		? function (o, v) {
+				Object.defineProperty(o, 'default', { enumerable: true, value: v })
+			}
+		: function (o, v) {
+				o['default'] = v
+			})
+var __importStar =
+	(this && this.__importStar) ||
+	(function () {
+		var ownKeys = function (o) {
+			ownKeys =
+				Object.getOwnPropertyNames ||
+				function (o) {
+					var ar = []
+					for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
+					return ar
+				}
+			return ownKeys(o)
+		}
+		return function (mod) {
+			if (mod && mod.__esModule) return mod
+			var result = {}
+			if (mod != null)
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== 'default') __createBinding(result, mod, k[i])
+			__setModuleDefault(result, mod)
+			return result
+		}
+	})()
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.getUrlInfo = void 0
+const messages_1 = require('./messages')
+const messages_media_1 = require('./messages-media')
+const THUMBNAIL_WIDTH_PX = 192
 /** Fetches an image and generates a thumbnail for it */
 const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
-    const stream = await getHttpStream(url, fetchOpts);
-    const result = await extractImageThumb(stream, thumbnailWidth);
-    return result;
-};
+	const stream = await (0, messages_media_1.getHttpStream)(url, fetchOpts)
+	const result = await (0, messages_media_1.extractImageThumb)(stream, thumbnailWidth)
+	return result
+}
 /**
  * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
  * Return undefined if the fetch failed or no URL was found
  * @param text first matched URL in text
  * @returns the URL info required to generate link preview
  */
-export const getUrlInfo = async (text, opts = {
-    thumbnailWidth: THUMBNAIL_WIDTH_PX,
-    fetchOpts: { timeout: 3000 }
-}) => {
-    try {
-        // retries
-        let retries = 0;
-        const maxRetry = 5;
-        const { getLinkPreview } = await import('link-preview-js');
-        let previewLink = text;
-        if (!text.startsWith('https://') && !text.startsWith('http://')) {
-            previewLink = 'https://' + previewLink;
-        }
-        const info = await getLinkPreview(previewLink, {
-            ...opts.fetchOpts,
-            followRedirects: 'follow',
-            handleRedirects: (baseURL, forwardedURL) => {
-                const urlObj = new URL(baseURL);
-                const forwardedURLObj = new URL(forwardedURL);
-                if (retries >= maxRetry) {
-                    return false;
-                }
-                if (forwardedURLObj.hostname === urlObj.hostname ||
-                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
-                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
-                    retries += 1;
-                    return true;
-                }
-                else {
-                    return false;
-                }
-            },
-            headers: opts.fetchOpts?.headers
-        });
-        if (info && 'title' in info && info.title) {
-            const [image] = info.images;
-            const urlInfo = {
-                'canonical-url': info.url,
-                'matched-text': text,
-                title: info.title,
-                description: info.description,
-                originalThumbnailUrl: image
-            };
-            if (opts.uploadImage) {
-                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
-                    upload: opts.uploadImage,
-                    mediaTypeOverride: 'thumbnail-link',
-                    options: opts.fetchOpts
-                });
-                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
-                urlInfo.highQualityThumbnail = imageMessage || undefined;
-            }
-            else {
-                try {
-                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
-                }
-                catch (error) {
-                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
-                }
-            }
-            return urlInfo;
-        }
-    }
-    catch (error) {
-        if (!error.message.includes('receive a valid')) {
-            throw error;
-        }
-    }
-};
-//# sourceMappingURL=link-preview.js.map
+const getUrlInfo = async (
+	text,
+	opts = {
+		thumbnailWidth: THUMBNAIL_WIDTH_PX,
+		fetchOpts: { timeout: 3000 }
+	}
+) => {
+	try {
+		// retries
+		const retries = 0
+		const maxRetry = 5
+		const { getLinkPreview } = await Promise.resolve().then(() => __importStar(require('link-preview-js')))
+		let previewLink = text
+		if (!text.startsWith('https://') && !text.startsWith('http://')) {
+			previewLink = 'https://' + previewLink
+		}
+		const info = await getLinkPreview(previewLink, {
+			...opts.fetchOpts,
+			followRedirects: 'follow',
+			handleRedirects: (baseURL, forwardedURL) => {
+				const urlObj = new URL(baseURL)
+				const forwardedURLObj = new URL(forwardedURL)
+				if (retries >= maxRetry) {
+					return false
+				}
+				if (
+					forwardedURLObj.hostname === urlObj.hostname ||
+					forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+					'www.' + forwardedURLObj.hostname === urlObj.hostname
+				) {
+					retries + 1
+					return true
+				} else {
+					return false
+				}
+			},
+			headers: opts.fetchOpts?.headers
+		})
+		if (info && 'title' in info && info.title) {
+			const [image] = info.images
+			const urlInfo = {
+				'canonical-url': info.url,
+				'matched-text': text,
+				title: info.title,
+				description: info.description,
+				originalThumbnailUrl: image
+			}
+			if (opts.uploadImage) {
+				const { imageMessage } = await (0, messages_1.prepareWAMessageMedia)(
+					{ image: { url: image } },
+					{
+						upload: opts.uploadImage,
+						mediaTypeOverride: 'thumbnail-link',
+						options: opts.fetchOpts
+					}
+				)
+				urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined
+				urlInfo.highQualityThumbnail = imageMessage || undefined
+			} else {
+				try {
+					urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined
+				} catch (error) {
+					opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail')
+				}
+			}
+			return urlInfo
+		}
+	} catch (error) {
+		if (!error.message.includes('receive a valid')) {
+			throw error
+		}
+	}
+}
+exports.getUrlInfo = getUrlInfo

package/lib/Utils/logger.js

@@ -1,3 +1,9 @@
-import P from 'pino';
-export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
-//# sourceMappingURL=logger.js.map
+'use strict'
+var __importDefault =
+	(this && this.__importDefault) ||
+	function (mod) {
+		return mod && mod.__esModule ? mod : { default: mod }
+	}
+Object.defineProperty(exports, '__esModule', { value: true })
+const pino_1 = __importDefault(require('pino'))
+exports.default = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` })

package/lib/Utils/lt-hash.js

@@ -1,8 +1,39 @@
-import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.LT_HASH_ANTI_TAMPERING = void 0
+const crypto_1 = require('./crypto')
+
 /**
- * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
- * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
- * if the same series of mutations was made sequentially.
+ * LT Hash ("lthash16") is a summation-based homomorphic hash algorithm that
+ * maintains the integrity of a piece of data over a series of mutations. You
+ * can add/remove mutations and it'll return a hash equal to if the same
+ * series of mutations was made sequentially.
+ *
+ * WhatsApp expands each element to 128 bytes via HKDF (info = "WhatsApp Patch
+ * Integrity"), treats that as 64 little-endian uint16 lanes, and combines
+ * elements by adding/subtracting lane-wise mod 2^16 -- this is a pure HKDF +
+ * integer-arithmetic algorithm, no elliptic-curve math involved. Pure-JS,
+ * built on the already-validated `hkdf` implementation.
  */
-export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
-//# sourceMappingURL=lt-hash.js.map
+const LTHASH_INFO = 'WhatsApp Patch Integrity'
+const LTHASH_SIZE = 128 // bytes = 64 uint16 lanes
+
+const expand = element => (0, crypto_1.hkdf)(element, LTHASH_SIZE, { info: LTHASH_INFO })
+
+const applyDelta = (result, element, sign) => {
+	const expanded = expand(element)
+	for (let i = 0; i < LTHASH_SIZE; i += 2) {
+		const lane = result.readUInt16LE(i)
+		const delta = expanded.readUInt16LE(i)
+		result.writeUInt16LE((lane + sign * delta) & 0xffff, i)
+	}
+}
+
+exports.LT_HASH_ANTI_TAMPERING = {
+	subtractThenAdd: (base, subtract = [], add = []) => {
+		const result = Buffer.from(base)
+		for (const element of subtract) applyDelta(result, element, -1)
+		for (const element of add) applyDelta(result, element, 1)
+		return result
+	}
+}

package/lib/Utils/make-mutex.js

@@ -1,33 +1,36 @@
-import { Mutex as AsyncMutex } from 'async-mutex';
-export const makeMutex = () => {
-    const mutex = new AsyncMutex();
-    return {
-        mutex(code) {
-            return mutex.runExclusive(code);
-        }
-    };
-};
-export const makeKeyedMutex = () => {
-    const map = new Map();
-    return {
-        async mutex(key, task) {
-            let entry = map.get(key);
-            if (!entry) {
-                entry = { mutex: new AsyncMutex(), refCount: 0 };
-                map.set(key, entry);
-            }
-            entry.refCount++;
-            try {
-                return await entry.mutex.runExclusive(task);
-            }
-            finally {
-                entry.refCount--;
-                // only delete it if this is still the current entry
-                if (entry.refCount === 0 && map.get(key) === entry) {
-                    map.delete(key);
-                }
-            }
-        }
-    };
-};
-//# sourceMappingURL=make-mutex.js.map
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeKeyedMutex = exports.makeMutex = void 0
+const async_mutex_1 = require('async-mutex')
+const makeMutex = () => {
+	const mutex = new async_mutex_1.Mutex()
+	return {
+		mutex(code) {
+			return mutex.runExclusive(code)
+		}
+	}
+}
+exports.makeMutex = makeMutex
+const makeKeyedMutex = () => {
+	const map = new Map()
+	return {
+		async mutex(key, task) {
+			let entry = map.get(key)
+			if (!entry) {
+				entry = { mutex: new async_mutex_1.Mutex(), refCount: 0 }
+				map.set(key, entry)
+			}
+			entry.refCount++
+			try {
+				return await entry.mutex.runExclusive(task)
+			} finally {
+				entry.refCount--
+				// only delete it if this is still the current entry
+				if (entry.refCount === 0 && map.get(key) === entry) {
+					map.delete(key)
+				}
+			}
+		}
+	}
+}
+exports.makeKeyedMutex = makeKeyedMutex