@badzz88/baileys 8.5.3 → 8.5.5

package/lib/Defaults/index.js

@@ -56,15 +56,12 @@ exports.WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1])
 exports.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5])
 exports.WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6])
 exports.WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60
-/** Status messages older than 24 hours are considered expired */
 exports.STATUS_EXPIRY_SECONDS = 24 * 60 * 60
-/** WA Web enforces a 14-day maximum age for placeholder resend requests */
 exports.PLACEHOLDER_MAX_AGE_SECONDS = 14 * 24 * 60 * 60
 exports.NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0'
 exports.DICT_VERSION = 3
 exports.KEY_BUNDLE_TYPE = Buffer.from([5])
-exports.NOISE_WA_HEADER = Buffer.from([87, 65, 6, exports.DICT_VERSION]) // last is "DICT_VERSION"
-/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+exports.NOISE_WA_HEADER = Buffer.from([87, 65, 6, exports.DICT_VERSION])
 exports.URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g
 exports.WA_CERT_DETAILS = {
 	SERIAL: 0,
@@ -168,17 +165,17 @@ exports.MEDIA_HKDF_KEY_MAPPING = {
 exports.MEDIA_KEYS = Object.keys(exports.MEDIA_PATH_MAP)
 exports.MIN_PREKEY_COUNT = 5
 exports.INITIAL_PREKEY_COUNT = 812
-exports.UPLOAD_TIMEOUT = 30000 // 30 seconds
-exports.MIN_UPLOAD_INTERVAL = 5000 // 5 seconds minimum between uploads
+exports.UPLOAD_TIMEOUT = 30000
+exports.MIN_UPLOAD_INTERVAL = 5000
 exports.DEFAULT_CACHE_TTLS = {
-	SIGNAL_STORE: 5 * 60, // 5 minutes
-	MSG_RETRY: 60 * 60, // 1 hour
-	CALL_OFFER: 5 * 60, // 5 minutes
-	USER_DEVICES: 5 * 60, // 5 minutes
-	GROUP_METADATA: 30 * 60, // 30 minutes
-	CALL_SESSION: 10 * 60, // 10 minutes
-	USYNC_RESULTS: 10 * 60, // 10 minutes
-	IDENTITY_PROOF: 60 * 60 // 1 hour
+	SIGNAL_STORE: 5 * 60,
+	MSG_RETRY: 60 * 60,
+	CALL_OFFER: 5 * 60,
+	USER_DEVICES: 5 * 60,
+	GROUP_METADATA: 30 * 60,
+	CALL_SESSION: 10 * 60,
+	USYNC_RESULTS: 10 * 60,
+	IDENTITY_PROOF: 60 * 60
 }
 exports.TimeMs = {
 	Second: 1000,

package/lib/Signal/libsignal.js

@@ -60,18 +60,15 @@ const sender_key_name_1 = require('./Group/sender-key-name')
 const sender_key_record_1 = require('./Group/sender-key-record')
 const Group_1 = require('./Group')
 const lid_mapping_1 = require('./lid-mapping')
-/** Extract identity key from PreKeyWhisperMessage for identity change detection */
 function extractIdentityFromPkmsg(ciphertext) {
 	try {
 		if (!ciphertext || ciphertext.length < 2) {
 			return undefined
 		}
-		// Version byte check (version 3)
 		const version = ciphertext[0]
 		if ((version & 0xf) !== 3) {
 			return undefined
 		}
-		// Parse protobuf (skip version byte)
 		const identityKeyArr = rb.getPreKeyMessageIdentityKey(ciphertext)
 		if (identityKeyArr) {
 			return identityKeyArr
@@ -92,7 +89,7 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 	const storage = signalStorage(auth, lidMapping)
 	const parsedKeys = auth.keys
 	const migratedSessionCache = new lru_cache_1.LRUCache({
-		ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
+		ttl: 3 * 24 * 60 * 60 * 1000,
 		ttlAutopurge: true,
 		updateAgeOnGet: true
 	})
@@ -100,7 +97,6 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 		decryptGroupMessage({ group, authorJid, msg }) {
 			const senderName = jidToSignalSenderKeyName(group, authorJid)
 			const cipher = new Group_1.GroupCipher(storage, senderName)
-			// Use transaction to ensure atomicity
 			return parsedKeys.transaction(async () => {
 				return cipher.decrypt(msg)
 			}, group)
@@ -134,7 +130,6 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 		async decryptMessage({ jid, type, ciphertext }) {
 			const addr = jidToSignalProtocolAddress(jid)
 			const session = new rb.SessionCipher(storage, addr)
-			// Extract and save sender's identity key before decryption for identity change detection
 			if (type === 'pkmsg') {
 				const identityKey = extractIdentityFromPkmsg(ciphertext)
 				if (identityKey) {
@@ -157,8 +152,6 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 				}
 				return result
 			}
-			// If it's not a sync message, we need to ensure atomicity
-			// For regular messages, we use a transaction to ensure atomicity
 			return parsedKeys.transaction(async () => {
 				return await doDecrypt()
 			}, jid)
@@ -166,7 +159,6 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 		async encryptMessage({ jid, data }) {
 			const addr = jidToSignalProtocolAddress(jid)
 			const cipher = new rb.SessionCipher(storage, addr)
-			// Use transaction to ensure atomicity
 			return parsedKeys.transaction(async () => {
 				const { type: sigType, body } = await cipher.encrypt(data)
 				const type = sigType === 3 ? 'pkmsg' : 'msg'
@@ -216,7 +208,6 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 		jidToSignalProtocolAddress(jid) {
 			return jidToSignalProtocolAddress(jid).toString()
 		},
-		// Optimized direct access to LID mapping store
 		lidMapping,
 		async validateSession(jid) {
 			try {
@@ -232,28 +223,23 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 		},
 		async deleteSession(jids) {
 			if (!jids.length) return
-			// Convert JIDs to signal addresses and prepare for bulk deletion
 			const sessionUpdates = {}
 			jids.forEach(jid => {
 				const addr = jidToSignalProtocolAddress(jid)
 				sessionUpdates[addr.toString()] = null
 			})
-			// Single transaction for all deletions
 			return parsedKeys.transaction(async () => {
 				await auth.keys.set({ session: sessionUpdates })
 			}, `delete-${jids.length}-sessions`)
 		},
 		async migrateSession(fromJid, toJid) {
-			// TODO: use usync to handle this entire mess
 			if (!fromJid || (!(0, WABinary_1.isLidUser)(toJid) && !(0, WABinary_1.isHostedLidUser)(toJid)))
 				return { migrated: 0, skipped: 0, total: 0 }
-			// Only support PN to LID migration
 			if (!(0, WABinary_1.isPnUser)(fromJid) && !(0, WABinary_1.isHostedPnUser)(fromJid)) {
 				return { migrated: 0, skipped: 0, total: 1 }
 			}
 			const { user } = (0, WABinary_1.jidDecode)(fromJid)
 			logger.debug({ fromJid }, 'bulk device migration - loading all user devices')
-			// Get user's device list from storage
 			const { [user]: userDevices } = await parsedKeys.get('device-list', [user])
 			if (!userDevices) {
 				return { migrated: 0, skipped: 0, total: 0 }
@@ -263,19 +249,15 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 			if (!userDevices.includes(fromDeviceStr)) {
 				userDevices.push(fromDeviceStr)
 			}
-			// Filter out cached devices before database fetch
 			const uncachedDevices = userDevices.filter(device => {
 				const deviceKey = `${user}.${device}`
 				return !migratedSessionCache.has(deviceKey)
 			})
-			// Bulk check session existence only for uncached devices
 			const deviceSessionKeys = uncachedDevices.map(device => `${user}.${device}`)
 			const existingSessions = await parsedKeys.get('session', deviceSessionKeys)
-			// Step 3: Convert existing sessions to JIDs (only migrate sessions that exist)
 			const deviceJids = []
 			for (const [sessionKey, sessionData] of Object.entries(existingSessions)) {
 				if (sessionData) {
-					// Session exists in storage
 					const deviceStr = sessionKey.split('.')[1]
 					if (!deviceStr) continue
 					const deviceNum = parseInt(deviceStr)
@@ -295,7 +277,6 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 				},
 				'bulk device migration complete - all user devices processed'
 			)
-			// Single transaction for all migrations
 			return parsedKeys.transaction(
 				async () => {
 					const migrationOps = deviceJids.map(jid => {
@@ -314,31 +295,25 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 					})
 					const totalOps = migrationOps.length
 					let migratedCount = 0
-					// Bulk fetch PN sessions - already exist (verified during device discovery)
 					const pnAddrStrings = Array.from(new Set(migrationOps.map(op => op.fromAddr.toString())))
 					const pnSessions = await parsedKeys.get('session', pnAddrStrings)
-					// Prepare bulk session updates (PN → LID migration + deletion)
 					const sessionUpdates = {}
 					for (const op of migrationOps) {
 						const pnAddrStr = op.fromAddr.toString()
 						const lidAddrStr = op.toAddr.toString()
 						const pnSession = pnSessions[pnAddrStr]
 						if (pnSession) {
-							// Session exists (guaranteed from device discovery)
 							const fromSession = rb.SessionRecord.deserialize(pnSession)
 							if (fromSession.haveOpenSession()) {
-								// Queue for bulk update: copy to LID, delete from PN
 								sessionUpdates[lidAddrStr] = fromSession.serialize()
 								sessionUpdates[pnAddrStr] = null
 								migratedCount++
 							}
 						}
 					}
-					// Single bulk session update for all migrations
 					if (Object.keys(sessionUpdates).length > 0) {
 						await parsedKeys.set({ session: sessionUpdates })
 						logger.debug({ migratedSessions: migratedCount }, 'bulk session migration complete')
-						// Cache device-level migrations
 						for (const op of migrationOps) {
 							if (sessionUpdates[op.toAddr.toString()]) {
 								const deviceKey = `${op.pnUser}.${op.deviceId}`
@@ -374,7 +349,6 @@ const jidToSignalSenderKeyName = (group, user) => {
 	return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user))
 }
 function signalStorage({ creds, keys }, lidMapping) {
-	// Shared function to resolve PN signal address to LID if mapping exists
 	const resolveLIDSignalAddress = async id => {
 		if (id.includes('.')) {
 			const [deviceId, device] = id.split('.')
@@ -403,22 +377,19 @@ function signalStorage({ creds, keys }, lidMapping) {
 				const fetched = await keys.get('session', keysToFetch)
 				const sess = fetched[wireJid] || fetched[id]
 				if (!sess) return null
-				// Detect old libsignal-node JSON format → treat as no session
 				if (typeof sess === 'object' && !Buffer.isBuffer(sess) && !ArrayBuffer.isView(sess) && sess._sessions) {
 					return null
 				}
-				// Return raw bytes — Rust storage adapter expects Uint8Array, not SessionRecord object
 				return Buffer.isBuffer(sess) ? sess : Buffer.from(sess)
 			} catch (e) {
 				return null
 			}
 		},
 		storeSession: async (id, session) => {
-			// Store under raw ID so it's always findable regardless of LID mapping state
 			await keys.set({ session: { [id]: session.serialize() } })
 		},
 		isTrustedIdentity: () => {
-			return true // TOFU - Trust on First Use (same as WhatsApp Web)
+			return true
 		},
 		loadIdentityKey: async id => {
 			const wireJid = await resolveLIDSignalAddress(id)
@@ -433,7 +404,6 @@ function signalStorage({ creds, keys }, lidMapping) {
 				existingKey.length === identityKey.length &&
 				existingKey.every((byte, i) => byte === identityKey[i])
 			if (existingKey && !keysMatch) {
-				// Identity changed - clear session and update key
 				await keys.set({
 					session: { [wireJid]: null },
 					'identity-key': { [wireJid]: identityKey }
@@ -441,7 +411,6 @@ function signalStorage({ creds, keys }, lidMapping) {
 				return true
 			}
 			if (!existingKey) {
-				// New contact - Trust on First Use (TOFU)
 				await keys.set({ 'identity-key': { [wireJid]: identityKey } })
 				return true
 			}

package/lib/Signal/lid-mapping.js

@@ -6,7 +6,7 @@ const WABinary_1 = require('../WABinary')
 class LIDMappingStore {
 	constructor(keys, logger, pnToLIDFunc) {
 		this.mappingCache = new lru_cache_1.LRUCache({
-			ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
+			ttl: 3 * 24 * 60 * 60 * 1000,
 			ttlAutopurge: true,
 			updateAgeOnGet: true
 		})
@@ -77,7 +77,6 @@ class LIDMappingStore {
 		await this.keys.transaction(async () => {
 			await this.keys.set({ 'lid-mapping': batchData })
 		}, 'lid-mapping')
-		// Update cache after successful DB write
 		for (const [pnUser, lidUser] of Object.entries(pairMap)) {
 			this.mappingCache.set(`pn:${pnUser}`, lidUser)
 			this.mappingCache.set(`lid:${lidUser}`, pnUser)
@@ -113,7 +112,6 @@ class LIDMappingStore {
 				this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`)
 				return false
 			}
-			// Push the PN device ID to the LID to maintain device separation
 			const pnDevice = decoded.device !== undefined ? decoded.device : 0
 			const deviceSpecificLid = `${normalizedLidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`
 			this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`)
@@ -168,7 +166,7 @@ class LIDMappingStore {
 			}
 		}
 		if (Object.keys(usyncFetch).length > 0) {
-			const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch)) // this function already adds LIDs to mapping
+			const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch))
 			if (result && result.length > 0) {
 				await this.storeLIDPNMappings(result)
 				for (const pair of result) {

package/lib/Utils/message-inspect.js

@@ -0,0 +1,393 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+
+const boom_1 = require('@hapi/boom')
+const { proto } = require('../../WAProto/index.js')
+const WABinary_1 = require('../WABinary')
+const crypto_2 = require('./crypto')
+const generics_1 = require('./generics')
+const messages_media_1 = require('./messages-media')
+
+
+const getContentType = content => {
+	if (content) {
+		const keys = Object.keys(content)
+		const key = keys.find(k => (k === 'conversation' || k.includes('Message')) && k !== 'senderKeyDistributionMessage')
+		return key
+	}
+}
+exports.getContentType = getContentType
+
+
+const normalizeMessageContent = content => {
+	if (!content) {
+		return undefined
+	}
+	
+	for (let i = 0; i < 5; i++) {
+		const inner = getFutureProofMessage(content)
+		if (!inner) {
+			break
+		}
+		content = inner.message
+	}
+	return content
+	function getFutureProofMessage(message) {
+		return (
+			message.ephemeralMessage ||
+			message.viewOnceMessage ||
+			message.documentWithCaptionMessage ||
+			message.viewOnceMessageV2 ||
+			message.viewOnceMessageV2Extension ||
+			message.editedMessage ||
+			message.groupMentionedMessage ||
+			message.botInvokeMessage ||
+			message.lottieStickerMessage ||
+			message.eventCoverImage ||
+			message.statusMentionMessage ||
+			message.pollCreationOptionImageMessage ||
+			message.associatedChildMessage ||
+			message.groupStatusMentionMessage ||
+			message.pollCreationMessageV4 ||
+			message.pollCreationMessageV5 ||
+			message.statusAddYours ||
+			message.groupStatusMessage ||
+			message.limitSharingMessage ||
+			message.botTaskMessage ||
+			message.questionMessage ||
+			message.groupStatusMessageV2 ||
+			message.botForwardedMessage ||
+			message.questionReplyMessage ||
+			message.newsletterAdminProfileMessage ||
+			message.newsletterAdminProfileMessageV2 ||
+			message.newsletterAdminProfileStatusMessage ||
+			message.spoilerMessage ||
+			message.groupStatusV3Message ||
+			message.pollCreationMessageV6
+		)
+	}
+}
+exports.normalizeMessageContent = normalizeMessageContent
+
+
+const extractMessageContent = content => {
+	const extractFromTemplateMessage = msg => {
+		if (msg.imageMessage) {
+			return { imageMessage: msg.imageMessage }
+		} else if (msg.documentMessage) {
+			return { documentMessage: msg.documentMessage }
+		} else if (msg.videoMessage) {
+			return { videoMessage: msg.videoMessage }
+		} else if (msg.locationMessage) {
+			return { locationMessage: msg.locationMessage }
+		} else {
+			return {
+				conversation:
+					'contentText' in msg ? msg.contentText : 'hydratedContentText' in msg ? msg.hydratedContentText : ''
+			}
+		}
+	}
+	content = normalizeMessageContent(content)
+	if (content?.buttonsMessage) {
+		return extractFromTemplateMessage(content.buttonsMessage)
+	}
+	if (content?.templateMessage?.hydratedFourRowTemplate) {
+		return extractFromTemplateMessage(content?.templateMessage?.hydratedFourRowTemplate)
+	}
+	if (content?.templateMessage?.hydratedTemplate) {
+		return extractFromTemplateMessage(content?.templateMessage?.hydratedTemplate)
+	}
+	if (content?.templateMessage?.fourRowTemplate) {
+		return extractFromTemplateMessage(content?.templateMessage?.fourRowTemplate)
+	}
+	return content
+}
+exports.extractMessageContent = extractMessageContent
+
+
+const getDevice = id =>
+	/^3A.{18}$/.test(id)
+		? 'ios'
+		: /^3E.{20}$/.test(id)
+			? 'web'
+			: /^(.{21}|.{32})$/.test(id)
+				? 'android'
+				: /^(3F|.{18}$)/.test(id)
+					? 'desktop'
+					: 'api/baileys'
+exports.getDevice = getDevice
+
+
+const updateMessageWithReceipt = (msg, receipt) => {
+	msg.userReceipt = msg.userReceipt || []
+	const recp = msg.userReceipt.find(m => m.userJid === receipt.userJid)
+	if (recp) {
+		Object.assign(recp, receipt)
+	} else {
+		msg.userReceipt.push(receipt)
+	}
+}
+exports.updateMessageWithReceipt = updateMessageWithReceipt
+
+
+const updateMessageWithReaction = (msg, reaction) => {
+	const authorID = (0, generics_1.getKeyAuthor)(reaction.key)
+	const reactions = (msg.reactions || []).filter(r => (0, generics_1.getKeyAuthor)(r.key) !== authorID)
+	reaction.text = reaction.text || ''
+	reactions.push(reaction)
+	msg.reactions = reactions
+}
+exports.updateMessageWithReaction = updateMessageWithReaction
+
+
+const updateMessageWithPollUpdate = (msg, update) => {
+	const authorID = (0, generics_1.getKeyAuthor)(update.pollUpdateMessageKey)
+	const reactions = (msg.pollUpdates || []).filter(
+		r => (0, generics_1.getKeyAuthor)(r.pollUpdateMessageKey) !== authorID
+	)
+	if (update.vote?.selectedOptions?.length) {
+		reactions.push(update)
+	}
+	msg.pollUpdates = reactions
+}
+exports.updateMessageWithPollUpdate = updateMessageWithPollUpdate
+
+
+const updateMessageWithEventResponse = (msg, update) => {
+	const authorID = (0, generics_1.getKeyAuthor)(update.eventResponseMessageKey)
+	const responses = (msg.eventResponses || []).filter(
+		r => (0, generics_1.getKeyAuthor)(r.eventResponseMessageKey) !== authorID
+	)
+	responses.push(update)
+	msg.eventResponses = responses
+}
+exports.updateMessageWithEventResponse = updateMessageWithEventResponse
+
+
+function getAggregateVotesInPollMessage({ message, pollUpdates }, meId) {
+	const opts =
+		message?.pollCreationMessage?.options ||
+		message?.pollCreationMessageV2?.options ||
+		message?.pollCreationMessageV3?.options ||
+		message?.pollCreationMessageV5?.options ||
+		message?.pollCreationMessageV6?.options ||
+		message?.pollCreationMessageV4?.message?.pollCreationMessage?.options ||
+		message?.pollCreationMessageV4?.message?.pollCreationMessageV3?.options ||
+		[]
+	const voteHashMap = opts.reduce((acc, opt) => {
+		const hash = (0, crypto_2.sha256)(Buffer.from(opt.optionName || '')).toString()
+		acc[hash] = {
+			name: opt.optionName || '',
+			voters: []
+		}
+		return acc
+	}, {})
+	for (const update of pollUpdates || []) {
+		const { vote } = update
+		if (!vote) {
+			continue
+		}
+		for (const option of vote.selectedOptions || []) {
+			const hash = option.toString()
+			let data = voteHashMap[hash]
+			if (!data) {
+				voteHashMap[hash] = {
+					name: 'Unknown',
+					voters: []
+				}
+				data = voteHashMap[hash]
+			}
+			voteHashMap[hash].voters.push((0, generics_1.getKeyAuthor)(update.pollUpdateMessageKey, meId))
+		}
+	}
+	return Object.values(voteHashMap)
+}
+exports.getAggregateVotesInPollMessage = getAggregateVotesInPollMessage
+
+
+const aggregateMessageKeysNotFromMe = keys => {
+	const keyMap = {}
+	for (const { remoteJid, id, participant, fromMe, sts } of keys) {
+		if (!fromMe) {
+			const uqKey = `${remoteJid}:${participant || ''}`
+			if (!keyMap[uqKey]) {
+				keyMap[uqKey] = {
+					jid: remoteJid,
+					participant: participant,
+					messageIds: [],
+					
+					sts: sts
+				}
+			} else if (keyMap[uqKey].sts !== sts) {
+				
+				keyMap[uqKey].sts = undefined
+			}
+			keyMap[uqKey].messageIds.push(id)
+		}
+	}
+	return Object.values(keyMap)
+}
+exports.aggregateMessageKeysNotFromMe = aggregateMessageKeysNotFromMe
+
+
+const isScheduledMessage = msg => !!msg?.scheduledMessageMetadata?.scheduledTime
+exports.isScheduledMessage = isScheduledMessage
+
+
+const getScheduledMessageTime = msg => {
+	const t = msg?.scheduledMessageMetadata?.scheduledTime
+	if (!t) return null
+	return new Date(Number(t) * 1000)
+}
+exports.getScheduledMessageTime = getScheduledMessageTime
+
+
+const getMessagePaymentInfo = msg => msg?.paymentInfo || msg?.quotedPaymentInfo || null
+exports.getMessagePaymentInfo = getMessagePaymentInfo
+
+
+const getMessageCommentMetadata = msg => msg?.commentMetadata || null
+exports.getMessageCommentMetadata = getMessageCommentMetadata
+
+
+const getMessageAddOns = msg => msg?.messageAddOns || []
+exports.getMessageAddOns = getMessageAddOns
+
+
+const getPollCorrectAnswer = pollMsg => {
+	const poll =
+		pollMsg?.pollCreationMessage ||
+		pollMsg?.pollCreationMessageV2 ||
+		pollMsg?.pollCreationMessageV3 ||
+		pollMsg?.pollCreationMessageV5 ||
+		pollMsg?.pollCreationMessageV6
+	if (!poll) return null
+	const isQuiz = poll.pollType === proto.Message.PollType?.QUIZ || poll.pollType === 1
+	return isQuiz ? poll.correctAnswer?.optionName || null : null
+}
+exports.getPollCorrectAnswer = getPollCorrectAnswer
+
+
+function getAggregateResponsesInEventMessage({ eventResponses }, meLid) {
+	const responseTypes = ['GOING', 'NOT_GOING', 'MAYBE']
+	const responseMap = {}
+
+	for (const type of responseTypes) {
+		responseMap[type] = {
+			response: type,
+			responders: []
+		}
+	}
+	for (const update of eventResponses) {
+		const { response } = update.response || {}
+		const responseType = proto.Message.EventResponseMessage.EventResponseType[response]
+		if (responseType !== 'UNKNOWN' && responseMap[responseType]) {
+			responseMap[responseType].responders.push(generics_1.getKeyAuthor(update.eventResponseMessageKey, meLid))
+		}
+	}
+
+	return Object.values(responseMap)
+}
+exports.getAggregateResponsesInEventMessage = getAggregateResponsesInEventMessage
+
+const REUPLOAD_REQUIRED_STATUS = [410, 404]
+
+
+const downloadMediaMessage = async (message, type, options, ctx) => {
+	const result = await downloadMsg().catch(async error => {
+		
+		
+		
+		const errorStatus =
+			typeof error?.status === 'number'
+				? error.status
+				: typeof error?.output?.statusCode === 'number'
+					? error.output.statusCode
+					: undefined
+		if (ctx && typeof errorStatus === 'number' && REUPLOAD_REQUIRED_STATUS.includes(errorStatus)) {
+			ctx.logger.info({ key: message.key }, 'sending reupload media request...')
+			message = await ctx.reuploadRequest(message)
+			const result = await downloadMsg()
+			return result
+		}
+		throw error
+	})
+	return result
+	async function downloadMsg() {
+		const mContent = extractMessageContent(message.message)
+		if (!mContent) {
+			throw new boom_1.Boom('No message present', { statusCode: 400, data: message })
+		}
+		const contentType = getContentType(mContent)
+		let mediaType = contentType?.replace('Message', '')
+		const media = mContent[contentType]
+		if (!media || typeof media !== 'object' || (!('url' in media) && !('thumbnailDirectPath' in media))) {
+			throw new boom_1.Boom(`"${contentType}" message is not a media message`)
+		}
+		let download
+		if ('thumbnailDirectPath' in media && !('url' in media)) {
+			download = {
+				directPath: media.thumbnailDirectPath,
+				mediaKey: media.mediaKey
+			}
+			mediaType = 'thumbnail-link'
+		} else {
+			download = media
+		}
+		const stream = await (0, messages_media_1.downloadContentFromMessage)(download, mediaType, options)
+		if (type === 'buffer') {
+			const bufferArray = []
+			for await (const chunk of stream) {
+				bufferArray.push(chunk)
+			}
+			return Buffer.concat(bufferArray)
+		}
+		return stream
+	}
+}
+exports.downloadMediaMessage = downloadMediaMessage
+
+
+const assertMediaContent = content => {
+	content = extractMessageContent(content)
+	const mediaContent =
+		content?.documentMessage ||
+		content?.imageMessage ||
+		content?.videoMessage ||
+		content?.audioMessage ||
+		content?.stickerMessage
+	if (!mediaContent) {
+		throw new boom_1.Boom('given message is not a media message', { statusCode: 400, data: content })
+	}
+	return mediaContent
+}
+exports.assertMediaContent = assertMediaContent
+
+
+const toJid = id => {
+	if (!id) return ''
+	if (id.includes('@')) return id
+	return `${id}@s.whatsapp.net`
+}
+exports.toJid = toJid
+
+
+const getSenderLid = message => {
+	const k = message.key
+	if (!k) {
+		return { jid: '', lid: '' }
+	}
+	const jid = k.participant || k.remoteJid || ''
+	if (jid.endsWith('@lid') || jid.endsWith('@hosted.lid')) {
+		return { jid, lid: jid }
+	}
+	if (k.lid && typeof k.lid === 'string') {
+		const lid = k.lid.includes('@') ? k.lid : (0, WABinary_1.jidEncode)(k.lid, 'lid')
+		return { jid, lid }
+	}
+	if (k.participantLid && (0, WABinary_1.isLidUser)(k.participantLid)) {
+		return { jid, lid: k.participantLid }
+	}
+	return { jid, lid: '' }
+}
+exports.getSenderLid = getSenderLid