@badzz88/baileys 8.5.4 → 8.5.5

package/lib/Socket/messages-send.js

@@ -48,47 +48,26 @@ const makeMessagesSocket = config => {
 		trustInteropContact
 	} = sock
 	const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping)
-	
-	
-	const resolveStatusAudience = async (groupJids, includeMe = false) => {
-		const myJid = authState.creds.me?.id
-		const seen = new Set()
-		const allUsers = []
-		for (const gjid of groupJids) {
-			let meta
-			try {
-				meta = cachedGroupMetadata ? await cachedGroupMetadata(gjid) : null
-				if (!meta) meta = await groupMetadata(gjid)
-			} catch {
-				continue
-			}
-			for (const p of meta?.participants || []) {
-				const id = p.id
-				if (!id || seen.has(id)) continue
-				if (!includeMe && id === myJid) continue
-				seen.add(id)
-				allUsers.push(id)
-			}
-		}
-		return { allUsers }
-	}
-	
+	/**
+	 * Set of tctoken storage JIDs with a fire-and-forget issuePrivacyTokens IQ in flight.
+	 * Prevents duplicate IQs from rapid back-to-back sends before senderTimestamp persists.
+	 */
 	const inFlightTcTokenIssuance = new Set()
 	const userDevicesCache =
 		config.userDevicesCache ||
 		new node_cache_1.default({
-			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, 
+			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
 			useClones: false
 		})
 	const peerSessionsCache = new node_cache_1.default({
 		stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES,
 		useClones: false
 	})
-	
+	// Initialize message retry manager if enabled
 	const messageRetryManager = enableRecentMessageCache
 		? new Utils_1.MessageRetryManager(logger, maxMsgRetryCount)
 		: null
-	
+	// Prevent race conditions in Signal session encryption by user
 	const encryptionMutex = (0, make_mutex_1.makeKeyedMutex)()
 	let mediaConn
 	const refreshMediaConn = async (forceGet = false) => {
@@ -105,7 +84,7 @@ const makeMessagesSocket = config => {
 					content: [{ tag: 'media_conn', attrs: {} }]
 				})
 				const mediaConnNode = (0, WABinary_1.getBinaryNodeChild)(result, 'media_conn')
-				
+				// TODO: explore full length of data that whatsapp provides
 				const node = {
 					hosts: (0, WABinary_1.getBinaryNodeChildren)(mediaConnNode, 'host').map(({ attrs }) => ({
 						hostname: attrs.hostname,
@@ -121,7 +100,10 @@ const makeMessagesSocket = config => {
 		}
 		return mediaConn
 	}
-	
+	/**
+	 * generic send receipt function
+	 * used for receipts of phone call, read, delivery etc.
+	 * */
 	const sendReceipt = async (jid, participant, messageIds, type, sts) => {
 		if (!messageIds || messageIds.length === 0) {
 			throw new boom_1.Boom('missing ids in receipt')
@@ -141,7 +123,7 @@ const makeMessagesSocket = config => {
 			node.attrs.recipient = jid
 			node.attrs.to = participant
 		} else if (isInterop && !type) {
-			
+			// Delivery receipt to interop contact: WA sends to device-qualified JID (user:0@interop)
 			const { user } = (0, WABinary_1.jidDecode)(jid)
 			node.attrs.to = `${user}:0@interop`
 		} else {
@@ -153,7 +135,7 @@ const makeMessagesSocket = config => {
 		if (type) {
 			node.attrs.type = type
 		}
-		
+		// Interop bridge requires sts (microsecond stanza timestamp) from the original message
 		if (isInterop && sts) {
 			node.attrs.sts = sts
 		}
@@ -173,21 +155,21 @@ const makeMessagesSocket = config => {
 		logger.debug({ attrs: node.attrs, messageIds }, 'sending receipt for messages')
 		await sendNode(node)
 	}
-	
+	/** Correctly bulk send receipts to multiple chats, participants */
 	const sendReceipts = async (keys, type) => {
 		const recps = (0, Utils_1.aggregateMessageKeysNotFromMe)(keys)
 		for (const { jid, participant, messageIds, sts } of recps) {
 			await sendReceipt(jid, participant, messageIds, type, sts)
 		}
 	}
-	
+	/** Bulk read messages. Keys can be from different chats & participants */
 	const readMessages = async keys => {
 		const privacySettings = await fetchPrivacySettings()
-		
+		// based on privacy settings, we have to change the read type
 		const readType = privacySettings.readreceipts === 'all' ? 'read' : 'read-self'
 		await sendReceipts(keys, readType)
 	}
-	
+	/** Fetch all the devices we've to send a message to */
 	const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
 		const deviceResults = []
 		if (!useCache) {
@@ -245,26 +227,17 @@ const makeMessagesSocket = config => {
 			}
 		}
 		const query = new WAUSync_1.USyncQuery().withContext('message').withDeviceProtocol().withLIDProtocol()
-		
-		
-		const pnJidsToFetch = toFetch.filter(jid => (0, WABinary_1.isPnUser)(jid) || (0, WABinary_1.isHostedPnUser)(jid))
-		const cachedLidPairs = pnJidsToFetch.length
-			? (await signalRepository.lidMapping.getLIDsForPNs(pnJidsToFetch)) || []
-			: []
-		const cachedLidByPn = new Map(cachedLidPairs.map(({ pn, lid }) => [pn, lid]))
 		for (const jid of toFetch) {
-			const syncUser = new WAUSync_1.USyncUser().withId(jid)
-			const cachedLid = cachedLidByPn.get(jid)
-			if (cachedLid) syncUser.withLid(cachedLid)
-			query.withUser(syncUser)
+			query.withUser(new WAUSync_1.USyncUser().withId(jid)) // todo: investigate - the idea here is that <user> should have an inline lid field with the lid being the pn equivalent
 		}
 		const result = await sock.executeUSyncQuery(query)
 		if (result) {
+			// TODO: LID MAP this stuff (lid protocol will now return lid with devices)
 			const lidResults = result.list.filter(a => !!a.lid)
 			if (lidResults.length > 0) {
 				logger.trace('Storing LID maps from device call')
 				await signalRepository.lidMapping.storeLIDPNMappings(lidResults.map(a => ({ lid: a.lid, pn: a.id })))
-				
+				// Force-refresh sessions for newly mapped LIDs to align identity addressing
 				try {
 					const lids = lidResults.map(a => a.lid)
 					if (lids.length) {
@@ -285,10 +258,10 @@ const makeMessagesSocket = config => {
 				deviceMap[item.user] = deviceMap[item.user] || []
 				deviceMap[item.user]?.push(item)
 			}
-			
+			// Process each user's devices as a group for bulk LID migration
 			for (const [user, userDevices] of Object.entries(deviceMap)) {
 				const isLidUser = requestedLidUsers.has(user)
-				
+				// Process all devices for this user
 				for (const item of userDevices) {
 					const finalJid = isLidUser
 						? (0, WABinary_1.jidEncode)(user, item.server, item.device)
@@ -309,7 +282,7 @@ const makeMessagesSocket = config => {
 				}
 			}
 			if (userDevicesCache.mset) {
-				
+				// if the cache supports mset, we can set all devices in one go
 				await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })))
 			} else {
 				for (const key in deviceMap) {
@@ -336,7 +309,9 @@ const makeMessagesSocket = config => {
 		}
 		return deviceResults
 	}
-	
+	/**
+	 * Update Member Label
+	 */
 	const updateMemberLabel = (jid, memberLabel) => {
 		return relayMessage(
 			jid,
@@ -365,16 +340,16 @@ const makeMessagesSocket = config => {
 	}
 	const assertSessions = async (jids, force) => {
 		let didFetchNewSession = false
-		const uniqueJids = [...new Set(jids)] 
+		const uniqueJids = [...new Set(jids)] // Deduplicate JIDs
 		const jidsRequiringFetch = []
 		logger.debug({ jids }, 'assertSessions call with jids')
-		
+		// Check peerSessionsCache and validate sessions using libsignal loadSession
 		for (const jid of uniqueJids) {
 			const signalId = signalRepository.jidToSignalProtocolAddress(jid)
 			const cachedSession = peerSessionsCache.get(signalId)
 			if (cachedSession !== undefined) {
 				if (cachedSession && !force) {
-					continue 
+					continue // Session exists in cache
 				}
 			} else {
 				const sessionValidation = await signalRepository.validateSession(jid)
@@ -387,7 +362,7 @@ const makeMessagesSocket = config => {
 			jidsRequiringFetch.push(jid)
 		}
 		if (jidsRequiringFetch.length) {
-			
+			// LID if mapped, otherwise original; interop JIDs pass through as-is
 			const wireJids = [
 				...jidsRequiringFetch.filter(jid => !!(0, WABinary_1.isLidUser)(jid) || !!(0, WABinary_1.isHostedLidUser)(jid)),
 				...(
@@ -430,7 +405,7 @@ const makeMessagesSocket = config => {
 			}
 			await (0, Utils_1.parseAndInjectE2ESessions)(result, signalRepository)
 			didFetchNewSession = true
-			
+			// Cache fetched sessions using wire JIDs
 			for (const wireJid of wireJids) {
 				const signalId = signalRepository.jidToSignalProtocolAddress(wireJid)
 				peerSessionsCache.set(signalId, true)
@@ -439,7 +414,7 @@ const makeMessagesSocket = config => {
 		return didFetchNewSession
 	}
 	const sendPeerDataOperationMessage = async pdoMessage => {
-		
+		//TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
 		if (!authState.creds.me?.id) {
 			throw new boom_1.Boom('Not authenticated')
 		}
@@ -532,9 +507,7 @@ const makeMessagesSocket = config => {
 			additionalNodes,
 			useUserDevicesCache,
 			useCachedGroupMetadata,
-			statusJidList,
-			statusPrivacy,
-			AI = false
+			statusJidList
 		}
 	) => {
 		const meId = authState.creds.me.id
@@ -550,7 +523,8 @@ const makeMessagesSocket = config => {
 		const isInterop = (0, WABinary_1.isInteropUser)(jid)
 		const isGroupOrStatus = isGroup || isStatus
 		const finalJid = jid
-		msgId = msgId || (0, Utils_1.generateMessageIDV2)(meId)
+		const iosBros = config.browser[0] === "iOS" || config.browser[1] === "Safari";
+	    msgId = iosBros ? Utils_1.generateIOSMessageID() : msgId ?? (0, Utils_1.generateMessageIDV2)(meId)
 		useUserDevicesCache = useUserDevicesCache !== false
 		useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus
 		const participants = []
@@ -573,18 +547,6 @@ const makeMessagesSocket = config => {
 
 		const buttonType = getButtonType(messages)
 		const pollMessage = messages.pollCreationMessage || messages.pollCreationMessageV2 || messages.pollCreationMessageV3
-
-		if (participant) {
-			if (!isGroup && !isStatus) {
-				additionalAttributes = { ...additionalAttributes, device_fanout: 'false' }
-			}
-			const { user, device } = (0, WABinary_1.jidDecode)(participant.jid)
-			devices.push({
-				user,
-				device,
-				jid: participant.jid
-			})
-		}
 		await authState.keys.transaction(async () => {
 			const mediaType = getMediaType(message)
 			if (mediaType) {
@@ -616,24 +578,35 @@ const makeMessagesSocket = config => {
 				(0, Utils_1.normalizeMessageContent)(message)?.pinInChatMessage ||
 				(0, Utils_1.normalizeMessageContent)(message)?.reactionMessage
 			) {
-				extraAttrs['decrypt-fail'] = 'hide'
+				extraAttrs['decrypt-fail'] = 'hide' // todo: expand for reactions and other types
 			}
 			if (isGroupOrStatus && !isRetryResend) {
 				const [groupData, senderKeyMap] = await Promise.all([
 					(async () => {
-						let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined 
-						if (groupData && Array.isArray(groupData?.participants)) {
+						let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined
+						const looksStale =
+							groupData &&
+							typeof groupData.size === 'number' &&
+							Array.isArray(groupData.participants) &&
+							groupData.participants.length < groupData.size
+						if (groupData && Array.isArray(groupData?.participants) && !looksStale) {
 							logger.trace({ jid, participants: groupData.participants.length }, 'using cached group metadata')
 						} else if (!isStatus) {
-							groupData = await groupMetadata(jid) 
+							if (looksStale) {
+								logger.debug(
+									{ jid, cached: groupData.participants.length, expected: groupData.size },
+									'cached group metadata looks stale, re-fetching'
+								)
+							}
+							groupData = await groupMetadata(jid) // TODO: start storing group participant list + addr mode in Signal & stop relying on this
 						}
 						return groupData
 					})(),
 					(async () => {
 						if (!participant && !isStatus) {
-							
-							
-							const result = await authState.keys.get('sender-key-memory', [jid]) 
+							// what if sender memory is less accurate than the cached metadata
+							// on participant change in group, we should do sender memory manipulation
+							const result = await authState.keys.get('sender-key-memory', [jid]) // TODO: check out what if the sender key memory doesn't include the LID stuff now?
 							return result[jid] || {}
 						}
 						return {}
@@ -817,8 +790,8 @@ const makeMessagesSocket = config => {
 						!(0, WABinary_1.isHostedPnUser)(deviceJid) &&
 						device.device !== 99
 					) {
-						
-						
+						//todo: revamp all this logic
+						// the goal is to follow with what I said above for each group, and instead of a true false map of ids, we can set an array full of those the app has already sent pkmsgs
 						senderKeyRecipients.push(deviceJid)
 						senderKeyMap[deviceJid] = true
 					}
@@ -844,8 +817,8 @@ const makeMessagesSocket = config => {
 				})
 				await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } })
 			} else {
-				
-				
+				// ADDRESSING CONSISTENCY: Match own identity to conversation context
+				// TODO: investigate if this is true
 				let ownId = meId
 				if (isLid && meLid) {
 					ownId = meLid
@@ -865,9 +838,9 @@ const makeMessagesSocket = config => {
 					devices.push({
 						user,
 						device: 0,
-						jid: (0, WABinary_1.jidEncode)(user, targetUserServer, 0) 
+						jid: (0, WABinary_1.jidEncode)(user, targetUserServer, 0) // rajeh, todo: this entire logic is convoluted and weird.
 					})
-					
+					// Interop contacts don't receive a copy to own devices — native WA sends only one flat <enc>
 					if (user !== ownUser && !isInterop) {
 						const ownUserServer = isLid ? 'lid' : 's.whatsapp.net'
 						const ownUserForAddressing =
@@ -879,14 +852,14 @@ const makeMessagesSocket = config => {
 						})
 					}
 					if (additionalAttributes?.['category'] !== 'peer' && !isInterop) {
-						
+						// Clear placeholders and enumerate actual devices
 						devices.length = 0
-						
+						// Use conversation-appropriate sender identity
 						const senderIdentity =
 							isLid && meLid
 								? (0, WABinary_1.jidEncode)((0, WABinary_1.jidDecode)(meLid)?.user, 'lid', undefined)
 								: (0, WABinary_1.jidEncode)((0, WABinary_1.jidDecode)(meId)?.user, 's.whatsapp.net', undefined)
-						
+						// Enumerate devices for sender and target with consistent addressing
 						const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false)
 						devices.push(...sessionDevices)
 						logger.debug(
@@ -904,26 +877,25 @@ const makeMessagesSocket = config => {
 				const { user: mePnUser } = (0, WABinary_1.jidDecode)(meId)
 				const { user: meLidUser } = meLid ? (0, WABinary_1.jidDecode)(meLid) : { user: null }
 				for (const { user, jid } of devices) {
-					const isExactSenderDevice = jid === meId || (meLid && jid === meLid)
-					if (isExactSenderDevice) {
-						logger.debug({ jid, meId, meLid }, 'Skipping exact sender device (whatsmeow pattern)')
-						continue
-					}
-					
-					const isMe = user === mePnUser || user === meLidUser
-					if (isMe) {
-						meRecipients.push(jid)
-					} else {
-						otherRecipients.push(jid)
-					}
-					allRecipients.push(jid)
-				}
+                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+                    if (isExactSenderDevice) continue;
+                    const isMe = user === mePnUser || user === meLidUser;
+                    let ptcp = false;
+                    if (participant) {
+                        if (!(!isMe)) ptcp = true;
+                    }
+                    if (!ptcp) {
+                        if (isMe) meRecipients.push(jid);
+                        else otherRecipients.push(jid);
+                        allRecipients.push(jid);
+                    }
+                }
 				await assertSessions(allRecipients)
 				const [
 					{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 },
 					{ nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }
 				] = await Promise.all([
-					
+					// For own devices: use DSM if available (1:1 chats only)
 					createParticipantNodes(meRecipients, meMsg || message, extraAttrs),
 					createParticipantNodes(otherRecipients, message, extraAttrs, meMsg)
 				])
@@ -934,40 +906,15 @@ const makeMessagesSocket = config => {
 				}
 				shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2
 			}
-			if (isRetryResend) {
-				const isParticipantLid = (0, WABinary_1.isLidUser)(participant.jid)
-				const isMe = (0, WABinary_1.areJidsSameUser)(participant.jid, isParticipantLid ? meLid : meId)
-				const encodedMessageToSend = isMe
-					? (0, Utils_1.encodeWAMessage)({
-							deviceSentMessage: {
-								destinationJid,
-								message
-							}
-						})
-					: (0, Utils_1.encodeWAMessage)(message)
-				const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
-					data: encodedMessageToSend,
-					jid: participant.jid
-				})
-				binaryNodeContent.push({
-					tag: 'enc',
-					attrs: {
-						v: '2',
-						type,
-						count: (participant.count ?? 0).toString()
-					},
-					content: encryptedContent
-				})
-			}
 			if (participants.length) {
 				if (additionalAttributes?.['category'] === 'peer') {
 					const peerNode = participants[0]?.content?.[0]
 					if (peerNode) {
-						binaryNodeContent.push(peerNode) 
+						binaryNodeContent.push(peerNode) // push only enc
 					}
 				} else if (isInterop) {
-					
-					
+					// Flat <enc> directly on <message> — no <participants> wrapper (native WA behavior).
+					// Find the enc for the actual interop recipient, not own-device DSM copy.
 					const recipientNode = participants.find(p => (0, WABinary_1.isInteropUser)(p?.attrs?.jid))
 					const encNode = (recipientNode ?? participants[0])?.content?.[0]
 					if (encNode) {
@@ -991,22 +938,6 @@ const makeMessagesSocket = config => {
 				},
 				content: binaryNodeContent
 			}
-			
-			
-			
-			if (participant) {
-				if ((0, WABinary_1.isJidGroup)(destinationJid)) {
-					stanza.attrs.to = destinationJid
-					stanza.attrs.participant = participant.jid
-				} else if ((0, WABinary_1.areJidsSameUser)(participant.jid, meId)) {
-					stanza.attrs.to = participant.jid
-					stanza.attrs.recipient = destinationJid
-				} else {
-					stanza.attrs.to = participant.jid
-				}
-			} else {
-				stanza.attrs.to = destinationJid
-			}
 			if (shouldIncludeDeviceIdentity) {
 				stanza.content.push({
 					tag: 'device-identity',
@@ -1023,14 +954,6 @@ const makeMessagesSocket = config => {
 				})
 			}
 
-			
-			if (isStatus && statusPrivacy && !additionalAttributes?.edit) {
-				stanza.content.push({
-					tag: 'meta',
-					attrs: { status_setting: statusPrivacy, session_scope: 'status' }
-				})
-			}
-
 			if (pollMessage || messages.eventMessage) {
 				stanza.content.push({
 					tag: 'meta',
@@ -1088,30 +1011,30 @@ const makeMessagesSocket = config => {
 					stanza.content.push(buttonsNode)
 				}
 			}
-			if (!AI && (0, WABinary_1.isPnUser)(destinationJid)) {
+			if (!config.aiLabel && (0, WABinary_1.isPnUser)(destinationJid)) {
 				const alreadyHasBizBot =
 					WABinary_1.getBinaryFilteredBizBot(additionalNodes || []) ||
 					WABinary_1.getBinaryFilteredBizBot(stanza.content)
 				if (!alreadyHasBizBot) {
 					stanza.content.push({ tag: 'bot', attrs: { biz_bot: '1' } })
 				}
-			} else if (AI && !isGroup && !isStatus && !isNewsletter) {
+			} else if (config.aiLabel && !isGroup && !isStatus && !isNewsletter) {
 				const existingBizBot = WABinary_1.getBinaryFilteredBizBot(additionalNodes || [])
 				if (!existingBizBot) {
 					stanza.content.push({ tag: 'bot', attrs: { biz_bot: '1' } })
 				}
 			}
-			
+			// WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
 			const isPeerMessage = additionalAttributes?.['category'] === 'peer'
 			const is1on1Send = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage
-			
+			// Resolve destination to LID for tctoken storage — matches Signal session key pattern
 			const tcTokenJid = is1on1Send
 				? await (0, tc_token_utils_1.resolveTcTokenJid)(destinationJid, getLIDForPN)
 				: destinationJid
 			const contactTcTokenData = is1on1Send ? await authState.keys.get('tctoken', [tcTokenJid]) : {}
 			const existingTokenEntry = contactTcTokenData[tcTokenJid]
 			let tcTokenBuffer = existingTokenEntry?.token
-			
+			// Treat expired tokens the same as missing — clear from cache
 			if (tcTokenBuffer?.length && (0, tc_token_utils_1.isTcTokenExpired)(existingTokenEntry?.timestamp)) {
 				logger.debug({ jid: destinationJid, timestamp: existingTokenEntry?.timestamp }, 'tctoken expired, clearing')
 				tcTokenBuffer = undefined
@@ -1132,38 +1055,17 @@ const makeMessagesSocket = config => {
 					content: tcTokenBuffer
 				})
 			}
-			
-			if (is1on1Send && !tcTokenBuffer?.length) {
-				try {
-					const saltStore = await authState.keys.get('nct-salt', ['default'])
-					const nctSalt = saltStore?.['default']
-					if (nctSalt?.length) {
-						const recipientLid = await getLIDForPN(destinationJid)
-						if (recipientLid) {
-							const { createHmac } = require('crypto')
-							const lidStr = (0, WABinary_1.isLidUser)(recipientLid)
-								? recipientLid
-								: `${recipientLid.split('@')[0]}@lid`
-							const cs = createHmac('sha256', nctSalt).update(lidStr, 'utf8').digest()
-							stanza.content.push({ tag: 'cstoken', attrs: {}, content: cs })
-							logger.debug({ jid: destinationJid, lid: lidStr }, 'nct: attached cstoken')
-						}
-					}
-				} catch (err) {
-					logger.debug({ jid: destinationJid, err: err?.message }, 'nct: cstoken attach failed')
-				}
-			}
 			if (additionalNodes && additionalNodes.length > 0 && !didPushAdditional) {
 				stanza.content.push(...additionalNodes)
 			}
 			logger.debug({ msgId }, `sending message to ${participants.length} devices`)
 			await sendNode(stanza)
-			
-			
+			// Register messageSecret immediately at send time so msmsg replies can be
+			// decrypted even if they arrive before our own message echo comes back.
 			if (message.messageContextInfo?.messageSecret) {
 				setBotMessageSecret(msgId, message.messageContextInfo.messageSecret, destinationJid)
 			}
-			
+			// Fire-and-forget: issue our token to the contact AFTER message send.
 			const isProtocolMsg = !!(0, Utils_1.normalizeMessageContent)(message)?.protocolMessage
 			const isBotOrPSA =
 				destinationJid === WABinary_1.PSA_WID ||
@@ -1214,7 +1116,7 @@ const makeMessagesSocket = config => {
 						inFlightTcTokenIssuance.delete(tcTokenJid)
 					})
 			}
-			
+			// Add message to retry cache if enabled
 			if (messageRetryManager && !participant) {
 				messageRetryManager.addRecentMessage(destinationJid, msgId, message)
 			}
@@ -1336,7 +1238,7 @@ const makeMessagesSocket = config => {
 				}
 			}
 		} else if (nativeFlow && nativeFlowSpecials.includes(firstButtonName)) {
-			
+			// Only works for WhatsApp Original, not WhatsApp Business
 			return {
 				tag: 'biz',
 				attrs: {
@@ -1370,7 +1272,7 @@ const makeMessagesSocket = config => {
 				]
 			}
 		} else if (nativeFlow || message.buttonsMessage) {
-			
+			// It works for whatsapp original and whatsapp business
 			return {
 				tag: 'biz',
 				attrs: {
@@ -1466,7 +1368,7 @@ const makeMessagesSocket = config => {
 	}
 	const getPrivacyTokens = issuePrivacyTokens
 	const waUploadToServer = (0, Utils_1.getWAUploadToServer)(config, refreshMediaConn)
-	const badzzne2 = new interactive_handler_1.badzz88(waUploadToServer, relayMessage, config, sock)
+	const interactiveHandler = new interactive_handler_1.InteractiveMessageHandler(waUploadToServer, relayMessage, config, sock)
 	const waitForMsgMediaUpdate = (0, Utils_1.bindWaitForEvent)(ev, 'messages.media-update')
 	return {
 		...sock,
@@ -1619,7 +1521,6 @@ const makeMessagesSocket = config => {
 								mediaHandle = up.handle
 								return up
 							},
-							mediaAbProps: authState.creds.mediaAbProps,
 							...options
 						}
 					)
@@ -1641,7 +1542,6 @@ const makeMessagesSocket = config => {
 								mediaHandle = up.handle
 								return up
 							},
-							mediaAbProps: authState.creds.mediaAbProps,
 							...options
 						}
 					)
@@ -1661,7 +1561,7 @@ const makeMessagesSocket = config => {
 		},
 
 		sendStatusMention: async (content, jids = []) => {
-			return await badzzne2.sendStatusWhatsApp(content, jids)
+			return await interactiveHandler.sendStatusWhatsApp(content, jids)
 		},
 		sendTable: async (jid, title, headers, rows, quoted, options = {}) => {
 			const { message, messageId } = message_composer_1.generateTableContent(title, headers, rows, quoted, options)
@@ -1716,7 +1616,9 @@ const makeMessagesSocket = config => {
 		},
 		sendMessage: async (jid, content, options = {}) => {
 			const userJid = authState.creds.me.id
-			
+			const iosBros = config.browser[0] === "iOS" || config.browser[1] === "Safari";
+	        const mId = iosBros ? Utils_1.generateIOSMessageID() : msgId ?? (0, Utils_1.generateMessageIDV2)(userJid)
+			// ── Normalize: buttons[].nativeFlowInfo -> interactiveButtons ──────
 			if (
 				typeof content === 'object' &&
 				Array.isArray(content.buttons) &&
@@ -1741,181 +1643,6 @@ const makeMessagesSocket = config => {
 				const { buttons, headerType, viewOnce, ...rest } = content
 				content = { ...rest, interactiveButtons }
 			}
-			if (
-				typeof content === 'object' &&
-				Array.isArray(content.interactiveButtons) &&
-				content.interactiveButtons.length > 0
-			) {
-				const {
-					text = '',
-					caption = '',
-					title = '',
-					footer = '',
-					interactiveButtons,
-					hasMediaAttachment = false,
-					image = null,
-					video = null,
-					document = null,
-					mimetype = null,
-					jpegThumbnail = null,
-					location = null,
-					product = null,
-					businessOwnerJid = null,
-					externalAdReply = null
-				} = content
-				
-				const processedButtons = []
-				for (let i = 0; i < interactiveButtons.length; i++) {
-					const btn = interactiveButtons[i]
-					if (!btn || typeof btn !== 'object') throw new Error(`interactiveButtons[${i}] must be an object`)
-					if (btn.name && btn.buttonParamsJson) {
-						processedButtons.push(btn)
-						continue
-					}
-					if (btn.id || btn.text || btn.displayText) {
-						processedButtons.push({
-							name: 'quick_reply',
-							buttonParamsJson: JSON.stringify({
-								display_text: btn.text || btn.displayText || `Button ${i + 1}`,
-								id: btn.id || `quick_${i + 1}`
-							})
-						})
-						continue
-					}
-					if (btn.buttonId && btn.buttonText?.displayText) {
-						processedButtons.push({
-							name: 'quick_reply',
-							buttonParamsJson: JSON.stringify({ display_text: btn.buttonText.displayText, id: btn.buttonId })
-						})
-						continue
-					}
-					throw new Error(`interactiveButtons[${i}] has invalid shape`)
-				}
-				let messageContent = {}
-				if (image) {
-					const mi = Buffer.isBuffer(image)
-						? { image }
-						: { image: { url: typeof image === 'object' ? image.url : image } }
-					const pm = await (0, Utils_1.prepareWAMessageMedia)(mi, { upload: waUploadToServer })
-					messageContent.header = { title: title || '', hasMediaAttachment: true, imageMessage: pm.imageMessage }
-				} else if (video) {
-					const mi = Buffer.isBuffer(video)
-						? { video }
-						: { video: { url: typeof video === 'object' ? video.url : video } }
-					const pm = await (0, Utils_1.prepareWAMessageMedia)(mi, { upload: waUploadToServer })
-					messageContent.header = { title: title || '', hasMediaAttachment: true, videoMessage: pm.videoMessage }
-				} else if (document) {
-					const mi = Buffer.isBuffer(document)
-						? { document }
-						: { document: { url: typeof document === 'object' ? document.url : document } }
-					if (mimetype && typeof mi.document === 'object') mi.document.mimetype = mimetype
-					if (jpegThumbnail) {
-						const thumb = Buffer.isBuffer(jpegThumbnail)
-							? jpegThumbnail
-							: await (async () => {
-									try {
-										const r = await fetch(jpegThumbnail)
-										return Buffer.from(await r.arrayBuffer())
-									} catch {
-										return undefined
-									}
-								})()
-						if (thumb) mi.document.jpegThumbnail = thumb
-					}
-					const pm = await (0, Utils_1.prepareWAMessageMedia)(mi, { upload: waUploadToServer })
-					messageContent.header = { title: title || '', hasMediaAttachment: true, documentMessage: pm.documentMessage }
-				} else if (location && typeof location === 'object') {
-					messageContent.header = {
-						title: title || location.name || 'Location',
-						hasMediaAttachment: false,
-						locationMessage: {
-							degreesLatitude: location.degreesLatitude || location.degressLatitude || 0,
-							degreesLongitude: location.degreesLongitude || location.degressLongitude || 0,
-							name: location.name || '',
-							address: location.address || ''
-						}
-					}
-				} else if (product && typeof product === 'object') {
-					let productImageMessage = null
-					if (product.productImage) {
-						const mi = Buffer.isBuffer(product.productImage)
-							? { image: product.productImage }
-							: {
-									image: {
-										url: typeof product.productImage === 'object' ? product.productImage.url : product.productImage
-									}
-								}
-						const pm = await (0, Utils_1.prepareWAMessageMedia)(mi, { upload: waUploadToServer })
-						productImageMessage = pm.imageMessage
-					}
-					messageContent.header = {
-						title: title || product.title || 'Product',
-						hasMediaAttachment: false,
-						productMessage: {
-							product: {
-								productImage: productImageMessage,
-								productId: product.productId || '',
-								title: product.title || '',
-								description: product.description || '',
-								currencyCode: product.currencyCode || 'USD',
-								priceAmount1000: parseInt(product.priceAmount1000, 10) || 0,
-								retailerId: product.retailerId || '',
-								url: product.url || '',
-								productImageCount: product.productImageCount || 1
-							},
-							businessOwnerJid: businessOwnerJid || product.businessOwnerJid || userJid
-						}
-					}
-				} else if (title) {
-					messageContent.header = { title, hasMediaAttachment: false }
-				}
-				const hasMedia = !!(image || video || document || location || product)
-				const bodyText = hasMedia ? caption : text || caption
-				if (bodyText) messageContent.body = { text: bodyText }
-				if (footer) messageContent.footer = { text: footer }
-				messageContent.nativeFlowMessage = { buttons: processedButtons }
-				if (externalAdReply && typeof externalAdReply === 'object') {
-					messageContent.contextInfo = {
-						externalAdReply: {
-							title: externalAdReply.title || '',
-							body: externalAdReply.body || '',
-							mediaType: externalAdReply.mediaType || 1,
-							sourceUrl: externalAdReply.sourceUrl || externalAdReply.url || '',
-							thumbnailUrl: externalAdReply.thumbnailUrl || externalAdReply.thumbnail || '',
-							renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false,
-							showAdAttribution: externalAdReply.showAdAttribution !== false,
-							containsAutoReply: externalAdReply.containsAutoReply || false,
-							...(externalAdReply.mediaUrl && { mediaUrl: externalAdReply.mediaUrl }),
-							...(Buffer.isBuffer(externalAdReply.thumbnail) && { thumbnail: externalAdReply.thumbnail }),
-							...(externalAdReply.jpegThumbnail && { jpegThumbnail: externalAdReply.jpegThumbnail })
-						},
-						...(options.mentionedJid && { mentionedJid: options.mentionedJid })
-					}
-				} else if (options.mentionedJid) {
-					messageContent.contextInfo = { mentionedJid: options.mentionedJid }
-				}
-				const payload = index_js_1.proto.Message.InteractiveMessage.create(messageContent)
-				const msg = (0, Utils_1.generateWAMessageFromContent)(
-					jid,
-					{ viewOnceMessage: { message: { interactiveMessage: payload } } },
-					{ userJid, quoted: options?.quoted || null }
-				)
-				const additionalNodes = [
-					{
-						tag: 'biz',
-						attrs: {},
-						content: [
-							{
-								tag: 'interactive',
-								attrs: { type: 'native_flow', v: '1' },
-								content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
-							}
-						]
-					}
-				]
-				await relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes })
-				return msg
-			}
 			if (
 				typeof content === 'object' &&
 				'disappearingMessagesInChat' in content &&
@@ -1930,25 +1657,25 @@ const makeMessagesSocket = config => {
 							: 0
 						: disappearingMessagesInChat
 				await groupToggleEphemeral(jid, value)
-			} else if (badzzne2.detectType(content)) {
+			} else if (interactiveHandler.detectType(content)) {
 				const { quoted } = options
-				const messageType = badzzne2.detectType(content)
+				const messageType = interactiveHandler.detectType(content)
 				switch (messageType) {
 					case 'PAYMENT': {
-						const paymentContent = await badzzne2.handlePayment(content, quoted)
+						const paymentContent = await interactiveHandler.handlePayment(content, quoted)
 						return await relayMessage(jid, paymentContent, {
-							messageId: (0, Utils_1.generateMessageIDV2)(userJid)
+							messageId: mId
 						})
 					}
 					case 'PRODUCT': {
-						const productContent = await badzzne2.handleProduct(content, jid, quoted)
+						const productContent = await interactiveHandler.handleProduct(content, jid, quoted)
 						const productMsg = await (0, Utils_1.generateWAMessageFromContent)(jid, productContent, { quoted, userJid })
 						return await relayMessage(jid, productMsg.message, {
 							messageId: productMsg.key.id
 						})
 					}
 					case 'INTERACTIVE': {
-						const interactiveContent = await badzzne2.handleInteractive(content, jid, quoted)
+						const interactiveContent = await interactiveHandler.handleInteractive(content, jid, quoted)
 						const interactiveMsg = await (0, Utils_1.generateWAMessageFromContent)(jid, interactiveContent, {
 							quoted,
 							userJid
@@ -1957,25 +1684,21 @@ const makeMessagesSocket = config => {
 							messageId: interactiveMsg.key.id
 						})
 					}
-					case 'INTERACTIVE_BUTTONS': {
-						const ibContent = await badzzne2.handleInteractiveButtons(content, jid, quoted)
-						const ibMsg = await (0, Utils_1.generateWAMessageFromContent)(jid, ibContent, { quoted, userJid })
-						return await relayMessage(jid, ibMsg.message, {
-							messageId: ibMsg.key.id
-						})
-					}
 					case 'ALBUM':
-						return await badzzne2.handleAlbum(content, jid, quoted)
+						return await interactiveHandler.handleAlbum(content, jid, quoted)
 					case 'EVENT':
-						return await badzzne2.handleEvent(content, jid, quoted)
+						return await interactiveHandler.handleEvent(content, jid, quoted)
 					case 'POLL_RESULT':
-						return await badzzne2.handlePollResult(content, jid, quoted)
+						return await interactiveHandler.handlePollResult(content, jid, quoted)
 					case 'GROUP_STORY':
-						return await badzzne2.handleGroupStory(content, jid, quoted)
+						return await interactiveHandler.handleGroupStory(content, jid, quoted)
+					case 'ORDER':
+						return await interactiveHandler.handleOrderMessage(content, jid, quoted)
+					case 'GROUP_LABEL':
+						return await interactiveHandler.handleGbLabel(content, jid)
 				}
 			} else {
 				let mediaHandle
-				const { ai, ...optionsWithoutAI } = options
 				const fullMsg = await (0, Utils_1.generateWAMessage)(jid, content, {
 					logger,
 					userJid,
@@ -1989,6 +1712,7 @@ const makeMessagesSocket = config => {
 							logger,
 							uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
 						}),
+					//TODO: CACHE
 					getProfilePicUrl: sock.profilePictureUrl,
 					getCallLink: sock.createCallLink,
 					newsletter: (0, WABinary_1.isJidNewsletter)(jid),
@@ -2002,10 +1726,8 @@ const makeMessagesSocket = config => {
 					},
 					mediaCache: config.mediaCache,
 					options: config.options,
-					messageId: (0, Utils_1.generateMessageIDV2)(sock.user?.id),
-					
-					mediaAbProps: authState.creds.mediaAbProps,
-					...optionsWithoutAI
+					messageId: mId,
+					...options
 				})
 				if (!mediaHandle) {
 					const msgContent = fullMsg.message
@@ -2032,9 +1754,6 @@ const makeMessagesSocket = config => {
 					} else {
 						additionalAttributes.edit = '7'
 					}
-					if (content.delete?.server_id) {
-						additionalAttributes.server_id = String(content.delete.server_id)
-					}
 				} else if (isEditMsg) {
 					additionalAttributes.edit = '1'
 				} else if (isPinMsg) {
@@ -2073,9 +1792,7 @@ const makeMessagesSocket = config => {
 					useCachedGroupMetadata: options.useCachedGroupMetadata,
 					additionalAttributes,
 					statusJidList: options.statusJidList,
-					statusPrivacy: options.statusPrivacy,
-					additionalNodes,
-					AI: ai || false
+					additionalNodes
 				})
 				if (config.emitOwnEvents) {
 					process.nextTick(async () => {
@@ -2085,71 +1802,52 @@ const makeMessagesSocket = config => {
 				return fullMsg
 			}
 		},
-
-		sendMetaAI: async (jid1, text, opts = {}) => {
-			const crypto = require('crypto')
-			const { proto } = require('../../WAProto/index.js')
-			const META_AI_BOT_JID = '867051314767696@bot'
-			const yourJid = jid1 || ''
-			const jid = opts.jid || META_AI_BOT_JID
-			const threadId = opts.threadId || Utils_1.generateMessageIDV2(yourJid)
-			const now = Date.now()
-			const senderTimestamp = opts.senderTimestamp || String(Math.floor(now / 1000))
-			const messageSecret = opts.messageSecret || crypto.randomBytes(32)
-			const senderKeyHash = opts.senderKeyHash || crypto.randomBytes(8).toString('base64')
-			const message = {
-				extendedTextMessage: proto.Message.ExtendedTextMessage.fromObject({
-					text,
-					previewType: 'NONE',
-					contextInfo: proto.ContextInfo.fromObject({
-						botMessageSharingInfo: {
-							botEntryPointOrigin: 'FAVICON',
-							forwardScore: 0
-						}
-					}),
-					inviteLinkGroupTypeV2: 'DEFAULT'
-				}),
-				messageContextInfo: proto.MessageContextInfo.fromObject({
-					deviceListMetadata: {
-						senderKeyHash,
-						senderTimestamp
-					},
-					deviceListMetadataVersion: 2,
-					messageSecret,
-					botMetadata: {
-						botModeSelectionMetadata: {
-							overrideMode: [0]
-						},
-						botThreadInfo: {
-							serverInfo: { title: text.substring(0, 50) },
-							clientInfo: { type: 'DEFAULT' }
-						},
-						botRenderingConfigMetadata: {
-							bloksVersioningId: '1eb86e6f4117d052e6bab62fe758a2e2af43747b85c5c1a886c8262bac462ea4',
-							pixelDensity: 2.625
-						}
-					},
-					threadId: [
-						{
-							threadType: 'AI_THREAD',
-							threadKey: {
-								remoteJid: '0002@s.whatsapp.net',
-								fromMe: true,
-								id: threadId
-							}
-						}
-					]
-				})
-			}
-			const msgId = (0, Utils_1.generateMessageIDV2)(yourJid)
-			const messageOptions = {
-				messageId: msgId,
-				quoted: opts.quoted,
-				links: opts.links
-			}
-			await relayMessage(jid, message, messageOptions)
-			return msgId
-		}
+		sendMessageMembers: async (jid, message, options = {}) => {
+            const {
+                messageId: idm,
+                quoted,
+                delayMs = 1500,
+                useUserDevicesCache = true,
+                cachedGroupMetadata,
+                onlyMember = true
+            } = options;
+            const { server } = jidDecode(jid);
+            if (server !== "g.us") throw new Error("@g.us server required");
+            const meId = authState.creds.me.id;
+            const messages = Utils_1.normalizeMessageContent(message);
+            const groupData = cachedGroupMetadata? await cachedGroupMetadata(jid) : await groupMetadata(jid);
+            const isLid = groupData.addressingMode === "lid";
+            const isAdmin = groupData.participants.filter((x) => x.admin !== null).map((y) => y.id)
+            let participantJids = groupData.participants.map(z => z.id);
+            if (onlyMember) {
+                participantJids = isAdmin ? isAdmin : participantJids;
+            }
+            logger.info(`Sending message to ${participantJids.length} members from ${jid}`);
+            for (let i = 0; i < participantJids.length; i++) {
+                const jid = participantJids[i];
+                if (areJidsSameUser(jid, meId)) continue;
+                try {
+                    const msgId = `${idm || Utils_1.generateMessageID()}_${i}`;
+                    const fullMsg = await Utils_1.generateWAMessageFromContent(jid, message, {
+                        messageId: msgId,
+                        quoted
+                    })
+                    await relayMessage(jid, fullMsg.message, {
+                        messageId: fullMsg.key.id
+                    });
+                    logger.debug(`Message successfully sent to ${jid}`);
+                    if (delayMs && i < participantJids.length - 1) {
+                        await new Promise(z => setTimeout(z, delayMs));
+                    }
+                } catch (e) {
+                    logger.error({ jid, e }, "Error sending message to");
+                }
+            }
+            return JSON.stringify({
+                members_total: participantJids.length,
+                message
+            }, null, 4);
+        }
 	}
 }
 exports.makeMessagesSocket = makeMessagesSocket