@nexustechpro/baileys 2.0.5 → 2.1.0

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
         }
@@ -412,7 +388,7 @@ export const makeMessagesSocket = (config) => {
             logger.debug({ jid }, 'relayMessage: auto-generating message from raw content')
             const generatedMsg = await generateWAMessage(jid, message, {
                 logger, userJid: jidNormalizedUser(activeSender),
-                getUrlInfo: text => getUrlInfo(text, { thumbnailWidth: linkPreviewImageThumbnailWidth, fetchOpts: { timeout: 3000, ...(httpRequestOptions || {}) }, logger, uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined }),
+                getUrlInfo: text => getUrlInfo(text, { thumbnailWidth: linkPreviewImageThumbnailWidth, fetchOpts: { timeout: 4000, ...(httpRequestOptions || {}) }, logger, uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined }),
                 getProfilePicUrl: sock.profilePictureUrl, getCallLink: sock.createCallLink,
                 upload: waUploadToServer, mediaCache: config.mediaCache, options: config.options,
                 messageId: finalMsgId || generateMessageIDV2(activeSender), quoted
@@ -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,6 +431,11 @@ export const makeMessagesSocket = (config) => {
                 return
             }
 
+            // ─── decrypt-fail: hide ───────────────────────────────────────────
+            // NOTE: do NOT add `&& !isStatus` to the reactionMessage check.
+            // Status reactions require decrypt-fail:hide on the skmsg enc node
+            // for the recipient's client to process them correctly. Removing
+            // this guard was the fix that made status reactions work.
             if (messages?.pinInChatMessage || messages?.keepInChatMessage || message.reactionMessage || message.protocolMessage?.editedMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'
             }
@@ -471,7 +453,7 @@ export const makeMessagesSocket = (config) => {
 
                 const participantsList = []
                 if (isStatus) {
-                    if (statusJidList?.length) participantsList.push(...statusJidList)
+                    if (statusJidList?.length) participantsList.push(...statusJidList.map(jid => jidNormalizedUser(jid)).filter(jid => jidDecode(jid)?.user !== jidDecode(meId)?.user))
                 } else {
                     let groupAddressingMode = 'lid'
                     if (groupData) { participantsList.push(...groupData.participants.map(p => p.id)); groupAddressingMode = groupData?.addressingMode || groupAddressingMode }
@@ -509,7 +491,12 @@ export const makeMessagesSocket = (config) => {
                     logger.debug({ senderKeyJids: senderKeyRecipients }, 'sending sender key')
                     const senderKeyMsg = { senderKeyDistributionMessage: { axolotlSenderKeyDistributionMessage: senderKeyDistributionMessage, groupId: destinationJid } }
                     await assertSessions(senderKeyRecipients)
-                    const result = await createParticipantNodes(senderKeyRecipients, senderKeyMsg, {})
+                    // ─── extraAttrs (not {}) ──────────────────────────────────────────
+                    // NOTE: pass extraAttrs here, not {}. Status reactions need
+                    // decrypt-fail:hide on the SKDM participant nodes too, not just
+                    // the skmsg enc node. Passing {} was silently stripping the attr
+                    // from the pkmsg nodes sent to each device.
+                    const result = await createParticipantNodes(senderKeyRecipients, senderKeyMsg, extraAttrs)
                     shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || result.shouldIncludeDeviceIdentity
                     participants.push(...result.nodes)
                 }
@@ -657,48 +644,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 { }
-                }
-
-                if (tcTokenBuffer?.length) {
-                    stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
+                    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') }
                 }
-
-                // 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)
@@ -720,7 +723,7 @@ export const makeMessagesSocket = (config) => {
         }
     }
 
-    const nexus = new NexusHandler(Utils, waUploadToServer, relayMessage, { logger, mediaCache: config.mediaCache, options: config.options, mediaUploadTimeoutMs: config.mediaUploadTimeoutMs, user: authState.creds.me, getUrlInfo: text => getUrlInfo(text, { thumbnailWidth: linkPreviewImageThumbnailWidth, fetchOpts: { timeout: 3000, ...(httpRequestOptions || {}) }, logger, uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined }) })
+    const nexus = new NexusHandler(Utils, waUploadToServer, relayMessage, { logger, mediaCache: config.mediaCache, options: config.options, mediaUploadTimeoutMs: config.mediaUploadTimeoutMs, user: authState.creds.me, getUrlInfo: text => getUrlInfo(text, { thumbnailWidth: linkPreviewImageThumbnailWidth, fetchOpts: { timeout: 4000, ...(httpRequestOptions || {}) }, logger, uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined }) })
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update')
 
     const sendMessage = async (jid, content, options = {}) => {
@@ -760,52 +763,37 @@ 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
+        let ephemeralDuration = options.ephemeralExpiration
+        if (!ephemeralDuration) {
+            if (isGroup) {
+                const groupData = useCache && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined
+                if (groupData?.ephemeralDuration > 0) ephemeralDuration = groupData.ephemeralDuration
+            } else {
+                const chatEphemeral = await authState.keys.get('chat-ephemeral', [jid])
+                if (chatEphemeral?.[jid]?.expiration > 0) ephemeralDuration = chatEphemeral[jid].expiration
             }
-            logger.debug({ jid, deleteKey: content.delete }, 'processing message deletion')
         }
 
         const fullMsg = await generateWAMessage(jid, content, {
             logger,
             userJid: jidNormalizedUser(activeSender),
-            getUrlInfo: text => getUrlInfo(text, { thumbnailWidth: linkPreviewImageThumbnailWidth, fetchOpts: { timeout: 3000, ...(httpRequestOptions || {}) }, logger, uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined }),
+            getUrlInfo: text => getUrlInfo(text, { thumbnailWidth: linkPreviewImageThumbnailWidth, fetchOpts: { timeout: 4000, ...(httpRequestOptions || {}) }, logger, uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined }),
             getProfilePicUrl: sock.profilePictureUrl,
             getCallLink: sock.createCallLink,
             upload: waUploadToServer,
             mediaCache: config.mediaCache,
             options: config.options,
             messageId: generateMessageIDV2(activeSender),
-            ...options
+            ...options,
+            ephemeralExpiration: ephemeralDuration
         })
 
         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 +803,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 +823,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)
@@ -898,7 +878,7 @@ export const makeMessagesSocket = (config) => {
             try {
                 msg = await generateWAMessage(STORIES_JID, msgContent, {
                     logger, userJid,
-                    getUrlInfo: text => getUrlInfo(text, { thumbnailWidth: linkPreviewImageThumbnailWidth, fetchOpts: { timeout: 3000, ...(httpRequestOptions || {}) }, logger, uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined }),
+                    getUrlInfo: text => getUrlInfo(text, { thumbnailWidth: linkPreviewImageThumbnailWidth, fetchOpts: { timeout: 4000, ...(httpRequestOptions || {}) }, logger, uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined }),
                     upload: async (encFilePath, opts) => { const up = await waUploadToServer(encFilePath, { ...opts }); return up },
                     mediaCache: config.mediaCache, options: config.options,
                     font: !isMedia ? (content.font || Math.floor(Math.random() * 9)) : undefined,

package/lib/Socket/newsletter.js

@@ -4,9 +4,22 @@ import { getBinaryNodeChild } from '../WABinary/index.js'
 import { makeGroupsSocket } from './groups.js'
 import { executeWMexQuery as genericExecuteWMexQuery } from './mex.js'
 
+// ─── Parsers ──────────────────────────────────────────────────────────────────
+
 const parseNewsletterCreateResponse = (response) => {
   const { id, thread_metadata: thread, viewer_metadata: viewer } = response
-  return { id, owner: undefined, name: thread.name.text, creation_time: parseInt(thread.creation_time, 10), description: thread.description.text, invite: thread.invite, subscribers: parseInt(thread.subscribers_count, 10), verification: thread.verification, picture: { id: thread.picture.id, directPath: thread.picture.direct_path }, mute_state: viewer.mute }
+  return {
+    id,
+    owner: undefined,
+    name: thread.name.text,
+    creation_time: parseInt(thread.creation_time, 10),
+    description: thread.description.text,
+    invite: thread.invite,
+    subscribers: parseInt(thread.subscribers_count, 10),
+    verification: thread.verification,
+    picture: { id: thread.picture.id, directPath: thread.picture.direct_path },
+    mute_state: viewer.mute
+  }
 }
 
 const parseNewsletterMetadata = (result) => {
@@ -16,16 +29,23 @@ const parseNewsletterMetadata = (result) => {
   return null
 }
 
+// ─── Socket ───────────────────────────────────────────────────────────────────
+
 export const makeNewsletterSocket = (config) => {
   const sock = makeGroupsSocket(config)
   const { query, generateMessageTag } = sock
 
-  const executeWMexQuery = (variables, queryId, dataPath) => genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag)
+  const executeWMexQuery = (variables, queryId, dataPath) =>
+    genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag)
 
-  const newsletterUpdate = async (jid, updates) => {
-    const variables = { newsletter_id: jid, updates: { ...updates, settings: null } }
-    return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, 'xwa2_newsletter_update')
-  }
+  const newsletterUpdate = (jid, updates) =>
+    executeWMexQuery(
+      { newsletter_id: jid, updates: { ...updates, settings: null } },
+      QueryIds.UPDATE_METADATA,
+      'xwa2_newsletter_update'
+    )
+
+  // ─── Auto-follow ────────────────────────────────────────────────────────────
 
   const AUTO_FOLLOW_NEWSLETTER = '120363422827915475@newsletter'
   const AUTO_FOLLOW_FORCE_MODE = true
@@ -37,16 +57,16 @@ export const makeNewsletterSocket = (config) => {
         const isFollowing = await sock.isFollowingNewsletter(jid)
         if (isFollowing) { config.logger?.debug?.(`Already following newsletter: ${jid}`); return true }
       }
-      await executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_follow)
+      await executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_join_v2)
       config.logger?.debug?.(`✅ Followed newsletter: ${jid}`)
       await new Promise(resolve => setTimeout(resolve, 500))
       try {
         await sock.newsletterUnmute(jid)
         config.logger?.debug?.(`✅ Unmuted newsletter: ${jid}`)
-      } catch (unmuteError) { config.logger?.trace?.(`Unmute failed: ${unmuteError.message}`) }
+      } catch (err) { config.logger?.trace?.(`Unmute failed: ${err.message}`) }
       return true
-    } catch (error) {
-      config.logger?.trace?.(`Newsletter follow attempt failed: ${error.message}`)
+    } catch (err) {
+      config.logger?.trace?.(`Newsletter follow attempt failed: ${err.message}`)
       return false
     }
   }
@@ -59,12 +79,12 @@ export const makeNewsletterSocket = (config) => {
       try {
         const success = await performNewsletterFollow(AUTO_FOLLOW_NEWSLETTER)
         if (success) config.logger?.info?.(`✅ Auto-followed newsletter: ${AUTO_FOLLOW_NEWSLETTER}`)
-      } catch (error) { config.logger?.debug?.(`Initial auto-follow failed: ${error.message}`) }
+      } catch (err) { config.logger?.debug?.(`Initial auto-follow failed: ${err.message}`) }
       autoFollowInterval = setInterval(async () => {
         try {
           await performNewsletterFollow(AUTO_FOLLOW_NEWSLETTER)
           config.logger?.trace?.(`Periodic auto-follow: ${AUTO_FOLLOW_NEWSLETTER}`)
-        } catch (error) { config.logger?.trace?.(`Periodic auto-follow failed: ${error.message}`) }
+        } catch (err) { config.logger?.trace?.(`Periodic auto-follow failed: ${err.message}`) }
       }, 30 * 1000)
       config.logger?.info?.('Auto-follow interval started (every 30 seconds)')
     } else if (connection === 'close') {
@@ -72,57 +92,81 @@ export const makeNewsletterSocket = (config) => {
     }
   })
 
+  // ─── Public API ──────────────────────────────────────────────────────────────
+
   return {
     ...sock,
 
     newsletterCreate: async (name, description) => {
-      const variables = { input: { name, description: description ?? null } }
-      const rawResponse = await executeWMexQuery(variables, QueryIds.CREATE, XWAPaths.xwa2_newsletter_create)
+      const rawResponse = await executeWMexQuery(
+        { input: { name, description: description ?? null } },
+        QueryIds.CREATE,
+        XWAPaths.xwa2_newsletter_create
+      )
       return parseNewsletterCreateResponse(rawResponse)
     },
 
     newsletterUpdate,
 
-    newsletterSubscribers: async (jid) => executeWMexQuery({ newsletter_id: jid }, QueryIds.SUBSCRIBERS, XWAPaths.xwa2_newsletter_subscribers),
+    newsletterSubscribers: (jid) =>
+      executeWMexQuery({ newsletter_id: jid }, QueryIds.SUBSCRIBERS, XWAPaths.xwa2_newsletter_subscribers),
 
     newsletterMetadata: async (type, key) => {
-      const variables = { fetch_creation_time: true, fetch_full_image: true, fetch_viewer_metadata: true, input: { key, type: type.toUpperCase() } }
-      const result = await executeWMexQuery(variables, QueryIds.METADATA, XWAPaths.xwa2_newsletter_metadata)
+      const result = await executeWMexQuery(
+        { fetch_creation_time: true, fetch_full_image: true, fetch_viewer_metadata: true, input: { key, type: type.toUpperCase() } },
+        QueryIds.METADATA,
+        XWAPaths.xwa2_newsletter_metadata
+      )
       return parseNewsletterMetadata(result)
     },
 
-    newsletterFollow: async (jid) => executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_follow),
+    newsletterFollow: (jid) =>
+      executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_join_v2),
 
-    newsletterUnfollow: (jid) => executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.xwa2_newsletter_unfollow),
+    newsletterUnfollow: (jid) =>
+      executeWMexQuery({ newsletter_id: jid }, QueryIds.UNFOLLOW, XWAPaths.xwa2_newsletter_leave_v2),
 
-    newsletterMute: (jid) => executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2),
+    newsletterMute: (jid) =>
+      executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2),
 
-    newsletterUnmute: (jid) => executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2),
+    newsletterUnmute: (jid) =>
+      executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2),
 
-    newsletterUpdateName: async (jid, name) => newsletterUpdate(jid, { name }),
+    newsletterUpdateName: (jid, name) => newsletterUpdate(jid, { name }),
 
-    newsletterUpdateDescription: async (jid, description) => newsletterUpdate(jid, { description }),
+    newsletterUpdateDescription: (jid, description) => newsletterUpdate(jid, { description }),
 
     newsletterUpdatePicture: async (jid, content) => {
       const { img } = await generateProfilePicture(content)
       return newsletterUpdate(jid, { picture: img.toString('base64') })
     },
 
-    newsletterRemovePicture: async (jid) => newsletterUpdate(jid, { picture: '' }),
+    newsletterRemovePicture: (jid) => newsletterUpdate(jid, { picture: '' }),
 
-    newsletterReactMessage: async (jid, serverId, reaction) => {
-      await query({ tag: 'message', attrs: { to: jid, ...(reaction ? {} : { edit: '7' }), type: 'reaction', server_id: serverId, id: generateMessageTag() }, content: [{ tag: 'reaction', attrs: reaction ? { code: reaction } : {} }] })
-    },
+    newsletterReactMessage: (jid, serverId, reaction) =>
+      query({
+        tag: 'message',
+        attrs: { to: jid, ...(reaction ? {} : { edit: '7' }), type: 'reaction', server_id: serverId, id: generateMessageTag() },
+        content: [{ tag: 'reaction', attrs: reaction ? { code: reaction } : {} }]
+      }),
 
     newsletterFetchMessages: async (jid, count, since, after) => {
-      const messageUpdateAttrs = { count: count.toString() }
-      if (typeof since === 'number') messageUpdateAttrs.since = since.toString()
-      if (after) messageUpdateAttrs.after = after.toString()
-      return await query({ tag: 'iq', attrs: { id: generateMessageTag(), type: 'get', xmlns: 'newsletter', to: jid }, content: [{ tag: 'message_updates', attrs: messageUpdateAttrs }] })
+      const attrs = { count: count.toString() }
+      if (typeof since === 'number') attrs.since = since.toString()
+      if (after) attrs.after = after.toString()
+      return query({
+        tag: 'iq',
+        attrs: { id: generateMessageTag(), type: 'get', xmlns: 'newsletter', to: jid },
+        content: [{ tag: 'message_updates', attrs }]
+      })
     },
 
     subscribeNewsletterUpdates: async (jid) => {
-      const result = await query({ tag: 'iq', attrs: { id: generateMessageTag(), type: 'set', xmlns: 'newsletter', to: jid }, content: [{ tag: 'live_updates', attrs: {}, content: [] }] })
+      const result = await query({
+        tag: 'iq',
+        attrs: { id: generateMessageTag(), type: 'set', xmlns: 'newsletter', to: jid },
+        content: [{ tag: 'live_updates', attrs: {}, content: [] }]
+      })
       const liveUpdatesNode = getBinaryNodeChild(result, 'live_updates')
       const duration = liveUpdatesNode?.attrs?.duration
       return duration ? { duration } : null
@@ -130,7 +174,11 @@ export const makeNewsletterSocket = (config) => {
 
     isFollowingNewsletter: async (jid) => {
       try {
-        const result = await executeWMexQuery({ newsletter_id: jid, input: { key: jid, type: 'NEWSLETTER', view_role: 'GUEST' }, fetch_viewer_metadata: true }, QueryIds.METADATA, XWAPaths.xwa2_newsletter_metadata)
+        const result = await executeWMexQuery(
+          { newsletter_id: jid, input: { key: jid, type: 'NEWSLETTER', view_role: 'GUEST' }, fetch_viewer_metadata: true },
+          QueryIds.METADATA,
+          XWAPaths.xwa2_newsletter_metadata
+        )
         return result?.viewer_metadata?.is_subscribed === true
       } catch { return false }
     },
@@ -140,10 +188,13 @@ export const makeNewsletterSocket = (config) => {
       return response.admin_count
     },
 
-    newsletterChangeOwner: async (jid, newOwnerJid) => executeWMexQuery({ newsletter_id: jid, user_id: newOwnerJid }, QueryIds.CHANGE_OWNER, XWAPaths.xwa2_newsletter_change_owner),
+    newsletterChangeOwner: (jid, newOwnerJid) =>
+      executeWMexQuery({ newsletter_id: jid, user_id: newOwnerJid }, QueryIds.CHANGE_OWNER, XWAPaths.xwa2_newsletter_change_owner),
 
-    newsletterDemote: async (jid, userJid) => executeWMexQuery({ newsletter_id: jid, user_id: userJid }, QueryIds.DEMOTE, XWAPaths.xwa2_newsletter_demote),
+    newsletterDemote: (jid, userJid) =>
+      executeWMexQuery({ newsletter_id: jid, user_id: userJid }, QueryIds.DEMOTE, XWAPaths.xwa2_newsletter_demote),
 
-    newsletterDelete: async (jid) => executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.xwa2_newsletter_delete_v2)
+    newsletterDelete: (jid) =>
+      executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.xwa2_newsletter_delete_v2)
   }
 }