@nexustechpro/baileys 2.0.5 → 2.0.6

package/lib/Socket/messages-send.js

@@ -4,8 +4,7 @@ import * as Utils from '../Utils/index.js'
 import { proto } from '../../WAProto/index.js'
 import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js'
 import * as WABinary from '../WABinary/index.js'
-import { getUrlInfo, migrateIndexKey } from '../Utils/index.js'
-import { makeKeyedMutex } from '../Utils/make-mutex.js'
+import { getUrlInfo, migrateIndexKey, getMessageReportingToken, shouldIncludeReportingToken, buildMergedTcTokenIndexWrite, isTcTokenExpired, readTcTokenIndex, resolveTcTokenJid, resolveIssuanceJid, shouldSendNewTcToken, storeTcTokensFromIqResult, makeKeyedMutex, makeMutex } from '../Utils/index.js'
 import { USyncQuery, USyncUser } from '../WAUSync/index.js'
 import { makeNewsletterSocket } from './newsletter.js'
 import NexusHandler from './nexus-handler.js'
@@ -23,52 +22,11 @@ const {
 const {
     areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser,
     isJidBroadcast, isJidGroup, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET,
-    getBinaryFilteredButtons, STORIES_JID, isJidUser, getButtonArgs, getButtonType
+    getBinaryFilteredButtons, STORIES_JID, isJidUser, getButtonArgs, getButtonType, isJidBot, isJidMetaAI
 } = WABinary
 
-const TC_TOKEN_BUCKET_DURATION = 604800 // 7 days
-const TC_TOKEN_NUM_BUCKETS = 4          // ~28-day rolling window
-
-const isTcTokenExpired = (timestamp) => {
-    if (timestamp === null || timestamp === undefined) return true
-    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp
-    if (isNaN(ts)) return true
-    const now = Math.floor(Date.now() / 1000)
-    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)
-    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1)
-    return ts < (cutoffBucket * TC_TOKEN_BUCKET_DURATION)
-}
-
-const shouldSendNewTcToken = (senderTimestamp) => {
-    if (senderTimestamp === undefined) return true
-    const now = Math.floor(Date.now() / 1000)
-    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)
-    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION)
-    return currentBucket > senderBucket
-}
-
-const resolveTcTokenJid = async (jid, getLIDForPN) => {
-    if (isLidUser(jid)) return jid
-    const lid = await getLIDForPN(jid)
-    return lid ?? jid
-}
-
-const resolveIssuanceJid = async (jid, issueToLid, getLIDForPN, getPNForLID) => {
-    if (issueToLid) {
-        if (isLidUser(jid)) return jid
-        return (await getLIDForPN(jid)) ?? jid
-    }
-    if (!isLidUser(jid)) return jid
-    if (getPNForLID) return (await getPNForLID(jid)) ?? jid
-    return jid
-}
-
 export const makeMessagesSocket = (config) => {
-    const {
-        logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview,
-        options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata,
-        enableRecentMessageCache, maxMsgRetryCount
-    } = config
+    const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount, getMessage } = config
 
     const sock = makeNewsletterSocket(config)
     const {
@@ -77,7 +35,7 @@ export const makeMessagesSocket = (config) => {
     } = sock
 
     const userDevicesCache = config.userDevicesCache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, useClones: false })
-    const peerSessionsCache = new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, useClones: false })
+    const devicesMutex = makeMutex()
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null
     const encryptionMutex = makeKeyedMutex()
 
@@ -111,9 +69,19 @@ export const makeMessagesSocket = (config) => {
         const node = { tag: 'receipt', attrs: { id: messageIds[0] } }
         const isReadReceipt = type === 'read' || type === 'read-self'
         if (isReadReceipt) node.attrs.t = unixTimestampSeconds().toString()
+        if (isJidStatusBroadcast(jid) && !participant && getMessage) {
+            try {
+                const msg = await getMessage({ remoteJid: jid, id: messageIds[0], fromMe: false })
+                participant = msg?.key?.participant || msg?.participant || msg?.key?.remoteJid
+                logger.debug({ jid, resolvedParticipant: participant }, 'resolved status receipt participant from message store')
+            } catch (err) { logger.debug({ err, jid }, 'failed to resolve status receipt participant') }
+        }
         if (type === 'sender' && (isPnUser(jid) || isLidUser(jid))) {
             node.attrs.recipient = jid
             node.attrs.to = participant
+        } else if (isJidStatusBroadcast(jid) && participant) {
+            node.attrs.to = jid
+            node.attrs.participant = participant
         } else {
             node.attrs.to = jid
             if (participant) node.attrs.participant = participant
@@ -135,7 +103,9 @@ export const makeMessagesSocket = (config) => {
 
     const readMessages = async (keys) => {
         const privacySettings = await fetchPrivacySettings()
-        await sendReceipts(keys, privacySettings.readreceipts === 'all' ? 'read' : 'read-self')
+        const hasStatusKey = keys.some(k => isJidStatusBroadcast(k.remoteJid))
+        const type = hasStatusKey ? 'read' : (privacySettings.readreceipts === 'all' ? 'read' : 'read-self')
+        await sendReceipts(keys, type)
     }
 
     const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
@@ -212,11 +182,13 @@ export const makeMessagesSocket = (config) => {
                 }
             }
 
-            if (userDevicesCache.mset) {
-                await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })))
-            } else {
-                for (const key in deviceMap) if (deviceMap[key]) await userDevicesCache.set(key, deviceMap[key])
-            }
+            await devicesMutex.mutex(async () => {
+                if (userDevicesCache.mset) {
+                    await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })))
+                } else {
+                    for (const key in deviceMap) if (deviceMap[key]) await userDevicesCache.set(key, deviceMap[key])
+                }
+            })
 
             // Persist device lists for session migration (capped at 500 users)
             const userDeviceUpdates = {}
@@ -243,16 +215,20 @@ export const makeMessagesSocket = (config) => {
         if (force) {
             jidsRequiringFetch = jids
         } else {
-            // assertSessions
-            const sessionBatch = await migrateIndexKey(authState.keys, 'session') // sessions live in index blob, not individual files
+            const sessionBatch = await migrateIndexKey(authState.keys, 'session')
             for (const jid of jids) {
                 const signalId = signalRepository.jidToSignalProtocolAddress(jid)
                 if (!sessionBatch[signalId]) jidsRequiringFetch.push(jid)
             }
         }
         if (jidsRequiringFetch.length) {
-            logger.debug({ jidsRequiringFetch }, 'fetching sessions')
-            const result = await query({ tag: 'iq', attrs: { xmlns: 'encrypt', type: 'get', to: S_WHATSAPP_NET }, content: [{ tag: 'key', attrs: {}, content: jidsRequiringFetch.map(jid => ({ tag: 'user', attrs: { jid } })) }] })
+            const wireJids = [
+                ...jidsRequiringFetch.filter(jid => isLidUser(jid) || isHostedLidUser(jid)),
+                ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => isPnUser(jid) || isHostedPnUser(jid)))) || []).map(a => a.lid)
+            ]
+            const fetchTargets = wireJids.length ? wireJids : jidsRequiringFetch
+            logger.debug({ jidsRequiringFetch, fetchTargets }, 'fetching sessions')
+            const result = await query({ tag: 'iq', attrs: { xmlns: 'encrypt', type: 'get', to: S_WHATSAPP_NET }, content: [{ tag: 'key', attrs: {}, content: fetchTargets.map(jid => ({ tag: 'user', attrs: { jid, ...(force ? { reason: 'identity' } : {}) } })) }] })
             await parseAndInjectE2ESessions(result, signalRepository)
             didFetchNewSession = true
         }
@@ -433,6 +409,7 @@ export const makeMessagesSocket = (config) => {
         const meMsg = { deviceSentMessage: { destinationJid, message }, messageContextInfo: message.messageContextInfo }
         const extraAttrs = {}
         const messages = normalizeMessageContent(message)
+        const reportingMessage = messages
         const buttonType = getButtonType(messages)
 
         let hasDeviceFanoutFalse = false
@@ -454,7 +431,7 @@ export const makeMessagesSocket = (config) => {
                 return
             }
 
-            if (messages?.pinInChatMessage || messages?.keepInChatMessage || message.reactionMessage || message.protocolMessage?.editedMessage) {
+            if (messages?.pinInChatMessage || messages?.keepInChatMessage || (message.reactionMessage && !isStatus) || message.protocolMessage?.editedMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'
             }
 
@@ -497,9 +474,10 @@ export const makeMessagesSocket = (config) => {
                 if (Array.isArray(patched)) throw new Boom('Per-jid patching not supported in groups')
 
                 const bytes = encodeWAMessage(patched)
+                const bytesU8 = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
                 const gAddressingMode = additionalAttributes?.addressing_mode || groupData?.addressingMode || 'lid'
                 const groupSenderIdentity = gAddressingMode === 'lid' && meLid ? meLid : meId
-                const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({ group: destinationJid, data: bytes, meId: groupSenderIdentity })
+                const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({ group: destinationJid, data: bytesU8, meId: groupSenderIdentity })
 
                 const senderKeyRecipients = devices
                     .filter(d => !isHostedLidUser(d.jid) && !isHostedPnUser(d.jid) && d.device !== 99)
@@ -527,9 +505,10 @@ export const makeMessagesSocket = (config) => {
                 if (Array.isArray(patched)) throw new Boom('Per-jid patching not supported in groups')
 
                 const bytes = encodeWAMessage(patched)
+                const bytesU8 = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
                 const gAddressingMode = additionalAttributes?.addressing_mode || groupData?.addressingMode || 'lid'
                 const groupSenderIdentity = gAddressingMode === 'lid' && meLid ? meLid : meId
-                const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({ group: destinationJid, data: bytes, meId: groupSenderIdentity })
+                const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({ group: destinationJid, data: bytesU8, meId: groupSenderIdentity })
 
                 const senderKeyMsg = { senderKeyDistributionMessage: { axolotlSenderKeyDistributionMessage: senderKeyDistributionMessage, groupId: destinationJid } }
                 await assertSessions([participant.jid])
@@ -657,48 +636,64 @@ export const makeMessagesSocket = (config) => {
                 logger.debug({ jid }, 'adding device identity')
             }
 
-            // TC token handling for 1:1 messages
             const isPeerMessage = additionalAttributes?.category === 'peer'
             const is1on1 = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage
             if (is1on1) {
                 const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping)
                 const tcTokenJid = await resolveTcTokenJid(destinationJid, getLIDForPN)
-
                 const contactTcTokenData = await authState.keys.get('tctoken', [tcTokenJid])
                 const existingEntry = contactTcTokenData[tcTokenJid]
                 let tcTokenBuffer = existingEntry?.token
-
-                // Clear expired tokens
                 if (tcTokenBuffer?.length && isTcTokenExpired(existingEntry?.timestamp)) {
-                    logger.debug({ jid: destinationJid }, 'tctoken expired, clearing')
+                    logger.debug({ jid: destinationJid, timestamp: existingEntry?.timestamp }, 'tctoken expired, clearing')
                     tcTokenBuffer = undefined
-                    try {
-                        await authState.keys.set({ tctoken: { [tcTokenJid]: existingEntry?.senderTimestamp !== undefined ? { token: Buffer.alloc(0), senderTimestamp: existingEntry.senderTimestamp } : null } })
-                    } catch { }
+                    const cleared = existingEntry?.senderTimestamp !== undefined ? { token: Buffer.alloc(0), senderTimestamp: existingEntry.senderTimestamp } : null
+                    try { await authState.keys.set({ tctoken: { [tcTokenJid]: cleared } }) } catch (err) { logger.debug({ jid: destinationJid, err: err?.message }, 'failed to persist tctoken expiry cleanup') }
                 }
-
-                if (tcTokenBuffer?.length) {
-                    stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
-                }
-
-                // Fire-and-forget: issue our token to the contact after send
+                if (tcTokenBuffer?.length && sock.serverProps?.privacyTokenOn1to1) stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
                 const isProtocolMsg = !!normalizeMessageContent(message)?.protocolMessage
-                if (!isProtocolMsg && shouldSendNewTcToken(existingEntry?.senderTimestamp) && !inFlightTcTokenIssuance.has(tcTokenJid)) {
+                const isBotOrPSA = isJidBot(destinationJid) || isJidMetaAI(destinationJid)
+                if (!isProtocolMsg && !isBotOrPSA && shouldSendNewTcToken(existingEntry?.senderTimestamp) && !inFlightTcTokenIssuance.has(tcTokenJid)) {
                     inFlightTcTokenIssuance.add(tcTokenJid)
                     const issueTimestamp = unixTimestampSeconds()
                     const getPNForLID = signalRepository.lidMapping.getPNForLID.bind(signalRepository.lidMapping)
                     const issueToLid = sock.serverProps?.lidTrustedTokenIssueToLid ?? false
                     resolveIssuanceJid(destinationJid, issueToLid, getLIDForPN, getPNForLID)
                         .then(issueJid => issuePrivacyTokens([issueJid], issueTimestamp))
-                        .then(async () => {
+                        .then(async (result) => {
+                            await storeTcTokensFromIqResult({ result, fallbackJid: tcTokenJid, keys: authState.keys, getLIDForPN })
                             const currentData = await authState.keys.get('tctoken', [tcTokenJid])
-                            const current = currentData[tcTokenJid]
-                            await authState.keys.set({ tctoken: { [tcTokenJid]: { ...current, senderTimestamp: issueTimestamp } } })
+                            const currentEntry = currentData[tcTokenJid]
+                            const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [tcTokenJid])
+                            await authState.keys.set({ tctoken: { [tcTokenJid]: { token: Buffer.alloc(0), ...currentEntry, senderTimestamp: issueTimestamp }, ...indexWrite } })
                         })
                         .catch(err => logger.debug({ jid: destinationJid, err: err?.message }, 'fire-and-forget tctoken issuance failed'))
                         .finally(() => inFlightTcTokenIssuance.delete(tcTokenJid))
                 }
             }
+            if (
+                !isNewsletter &&
+                !isRetryResend &&
+                reportingMessage?.messageContextInfo?.messageSecret &&
+                shouldIncludeReportingToken(reportingMessage)
+            ) {
+                try {
+                    const encoded = encodeWAMessage(reportingMessage)
+                    const reportingKey = {
+                        id: finalMsgId,
+                        fromMe: true,
+                        remoteJid: destinationJid,
+                        participant: participant?.jid
+                    }
+                    const reportingNode = await getMessageReportingToken(encoded, reportingMessage, reportingKey)
+                    if (reportingNode) {
+                        stanza.content.push(reportingNode)
+                        logger.trace({ jid }, 'added reporting token to message')
+                    }
+                } catch (error) {
+                    logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token')
+                }
+            }
 
             logger.debug({ msgId: finalMsgId }, `sending message to ${participants.length} devices`)
             await sendNode(stanza)
@@ -749,7 +744,9 @@ export const makeMessagesSocket = (config) => {
             content = { ...rest, interactiveMessage: interactive }
         }
 
-        const messageType = nexus.detectType(content)
+        // never route status reactions through nexus
+        const isStatusJid = jid === 'status@broadcast'
+        const messageType = !isStatusJid && nexus.detectType(content)
         if (messageType) return await nexus.processMessage(content, jid, quoted)
 
         if (content.disappearingMessagesInChat && isJidGroup(jid)) {
@@ -760,35 +757,6 @@ export const makeMessagesSocket = (config) => {
             return
         }
 
-        if (content.delete) {
-            const deleteKey = content.delete
-            if (!deleteKey.remoteJid || !deleteKey.id) {
-                logger.error({ deleteKey }, 'Invalid delete key: missing remoteJid or id')
-                throw new Boom('Delete key must have remoteJid and id', { statusCode: 400 })
-            }
-
-            const { server: deleteServer } = jidDecode(deleteKey.remoteJid)
-            let deleteAddressingMode = deleteServer === 'lid' ? 'lid' : 'pn'
-            if (isJidGroup(deleteKey.remoteJid)) {
-                const groupData = useCache && cachedGroupMetadata ? await cachedGroupMetadata(deleteKey.remoteJid) : undefined
-                deleteAddressingMode = groupData?.addressingMode || 'lid'
-            }
-
-            let normalizedParticipant = deleteKey.participant
-            if (deleteKey.fromMe || isJidGroup(deleteKey.remoteJid)) {
-                const senderJid = (deleteAddressingMode === 'lid' && meLid) ? meLid : meId
-                normalizedParticipant = jidNormalizedUser(senderJid)
-            }
-
-            content.delete = {
-                remoteJid: deleteKey.remoteJid,
-                fromMe: deleteKey.fromMe === true || deleteKey.fromMe === 'true',
-                id: deleteKey.id,
-                ...(normalizedParticipant ? { participant: jidNormalizedUser(normalizedParticipant) } : {}),
-                addressingMode: deleteAddressingMode
-            }
-            logger.debug({ jid, deleteKey: content.delete }, 'processing message deletion')
-        }
 
         const fullMsg = await generateWAMessage(jid, content, {
             logger,
@@ -805,7 +773,9 @@ export const makeMessagesSocket = (config) => {
 
         const additionalAttributes = {}, additionalNodes = []
         if (content.delete) {
-            additionalAttributes.edit = isJidGroup(content.delete.remoteJid) ? '8' : '7'
+            const fromMe = content.delete?.fromMe
+            const isGroupDelete = isJidGroup(content.delete?.remoteJid)
+            additionalAttributes.edit = (isGroupDelete && !fromMe) ? '8' : '7'
         } else if (content.edit) {
             additionalAttributes.edit = '1'
         } else if (content.pin) {
@@ -815,15 +785,6 @@ export const makeMessagesSocket = (config) => {
         if (content.event) additionalNodes.push({ tag: 'meta', attrs: { event_type: 'creation' } })
         if (content.ai) additionalNodes.push({ tag: 'bot', attrs: { biz_bot: '1' } })
 
-        // Pre-fetch TC token for new DM contacts
-        if (!isJidGroup(jid) && !isJidStatusBroadcast(jid) && !isJidBroadcast(jid) && !content.disappearingMessagesInChat) {
-            const existingToken = await authState.keys.get('tctoken', [jid])
-            if (!existingToken[jid]) {
-                try { await getPrivacyTokens([jid]); logger.debug({ jid }, 'fetched tctoken for new contact') }
-                catch (err) { logger.warn({ jid, err }, 'failed to fetch tctoken') }
-            }
-        }
-
         await relayMessage(jid, fullMsg.message, {
             messageId: fullMsg.key.id,
             useCachedGroupMetadata: options.useCachedGroupMetadata,
@@ -844,6 +805,7 @@ export const makeMessagesSocket = (config) => {
         sendReceipt, sendReceipts, nexus, readMessages, refreshMediaConn,
         waUploadToServer, fetchPrivacySettings, sendPeerDataOperationMessage,
         createParticipantNodes, getUSyncDevices, messageRetryManager, updateMemberLabel,
+        userDevicesCache, devicesMutex,
 
         updateMediaMessage: async (message) => {
             const content = assertMediaContent(message.message)