@nexustechpro/baileys 2.0.6 → 2.1.0

package/lib/Socket/chats.js

@@ -181,10 +181,19 @@ export const makeChatsSocket = (config) => {
         const usyncQuery = new USyncQuery()
         let contactEnabled = false
 
-        for (const jid of jids) {
+        for (let jid of jids) {
             if (isLidUser(jid)) {
-                logger.warn('LIDs not supported with onWhatsApp')
-                continue
+                const pn = await signalRepository.lidMapping.getPNForLID(jid)
+                if (pn) {
+                    jid = pn
+                } else {
+                    if (!contactEnabled) {
+                        contactEnabled = true
+                        usyncQuery.withContactProtocol().withLIDProtocol()
+                    }
+                    usyncQuery.withUser(new USyncUser().withId(jid))
+                    continue
+                }
             }
             if (!contactEnabled) {
                 contactEnabled = true
@@ -201,18 +210,18 @@ export const makeChatsSocket = (config) => {
 
         return Promise.all(
             results.list
-                .filter(a => a.contact === true)
+                .filter(a => a.contact === true && a.id && a.id !== 'undefined')
                 .map(async ({ id, lid }) => {
                     try {
                         const businessProfile = await getBusinessProfile(id)
                         const isBusiness = businessProfile && Object.keys(businessProfile).length > 0
                         if (isBusiness) {
                             const { wid, ...businessInfo } = businessProfile
-                            return { jid: id, exists: true, lid, status: 'business', businessInfo }
+                            return { jid: id, exists: true, lid: lid || id, status: 'business', businessInfo }
                         }
-                        return { jid: id, exists: true, lid, status: 'regular' }
+                        return { jid: id, exists: true, lid: lid || id, status: 'regular' }
                     } catch (error) {
-                        return { jid: id, exists: true, lid, status: 'error', error: error?.message }
+                        return { jid: id, exists: true, lid: lid || id, status: 'error', error: error?.message }
                     }
                 })
         )
@@ -610,7 +619,9 @@ export const makeChatsSocket = (config) => {
 
         const historyMsg = getHistoryMsg(msg.message)
         const shouldProcessHistoryMsg = historyMsg
-            ? shouldSyncHistoryMessage(historyMsg) && PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
+            ? !!historyMsg.mediaKey?.length
+            && shouldSyncHistoryMessage(historyMsg)
+            && PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
             : false
 
         // History sync progress tracking

package/lib/Socket/messages-send.js

@@ -388,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
@@ -431,7 +431,12 @@ export const makeMessagesSocket = (config) => {
                 return
             }
 
-            if (messages?.pinInChatMessage || messages?.keepInChatMessage || (message.reactionMessage && !isStatus) || message.protocolMessage?.editedMessage) {
+            // ─── 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'
             }
 
@@ -448,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 }
@@ -474,10 +479,9 @@ 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: bytesU8, meId: groupSenderIdentity })
+                const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({ group: destinationJid, data: bytes, meId: groupSenderIdentity })
 
                 const senderKeyRecipients = devices
                     .filter(d => !isHostedLidUser(d.jid) && !isHostedPnUser(d.jid) && d.device !== 99)
@@ -487,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)
                 }
@@ -505,10 +514,9 @@ 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: bytesU8, meId: groupSenderIdentity })
+                const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({ group: destinationJid, data: bytes, meId: groupSenderIdentity })
 
                 const senderKeyMsg = { senderKeyDistributionMessage: { axolotlSenderKeyDistributionMessage: senderKeyDistributionMessage, groupId: destinationJid } }
                 await assertSessions([participant.jid])
@@ -715,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 = {}) => {
@@ -744,9 +752,7 @@ export const makeMessagesSocket = (config) => {
             content = { ...rest, interactiveMessage: interactive }
         }
 
-        // never route status reactions through nexus
-        const isStatusJid = jid === 'status@broadcast'
-        const messageType = !isStatusJid && nexus.detectType(content)
+        const messageType = nexus.detectType(content)
         if (messageType) return await nexus.processMessage(content, jid, quoted)
 
         if (content.disappearingMessagesInChat && isJidGroup(jid)) {
@@ -758,17 +764,29 @@ export const makeMessagesSocket = (config) => {
         }
 
 
+        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
+            }
+        }
+
         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 = []
@@ -860,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)
   }
 }

package/lib/Socket/nexus-handler.js

@@ -145,7 +145,7 @@ class NexusHandler {
             const res = await this.utils.generateWAMessageContent(src, { upload: this.upload })
             prodImg = res?.imageMessage || res?.message?.imageMessage
         }
-        const product = proto.Message.ProductMessage.Product.create({
+        const product = proto.Message.ProductMessage.ProductSnapshot.create({
             productId: p.productId,
             title: p.title || '',
             description: p.description || '',
@@ -242,10 +242,10 @@ class NexusHandler {
                 starred: true,
                 labels: ['Y', 'Important'],
                 isHighlighted: true,
-                businessMessageForwardInfo: proto.BusinessMessageForwardInfo.create({ businessOwnerJid: jid }),
-                dataSharingContext: proto.DataSharingContext.create({ showMmDisclosure: true })
+                businessMessageForwardInfo: proto.ContextInfo.BusinessMessageForwardInfo.create({ businessOwnerJid: jid }),
+                dataSharingContext: proto.ContextInfo.DataSharingContext.create({ showMmDisclosure: true })
             })
-            img.message.forwardedNewsletterMessageInfo = proto.ForwardedNewsletterMessageInfo.create({
+            img.message.forwardedNewsletterMessageInfo = proto.ContextInfo.ForwardedNewsletterMessageInfo.create({
                 newsletterJid: '0@newsletter',
                 serverMessageId: 1,
                 newsletterName: 'WhatsApp',
@@ -274,36 +274,32 @@ class NexusHandler {
     async handleEvent(content, jid, quoted) {
         const e = content.eventMessage
         const msg = await this.genFromContent(jid, {
-            viewOnceMessage: {
-                message: {
-                    messageContextInfo: proto.MessageContextInfo.create({
-                        deviceListMetadata: {},
-                        deviceListMetadataVersion: 2,
-                        messageSecret: crypto.randomBytes(32),
-                        supportPayload: JSON.stringify({ version: 2, is_ai_message: true, should_show_system_message: true, ticket_id: crypto.randomBytes(16).toString('hex') })
-                    }),
-                    eventMessage: proto.Message.EventMessage.create({
-                        contextInfo: proto.ContextInfo.create({
-                            mentionedJid: [jid],
-                            participant: jid,
-                            remoteJid: 'status@broadcast',
-                            forwardedNewsletterMessageInfo: proto.ForwardedNewsletterMessageInfo.create({
-                                newsletterName: 'Nexus Events',
-                                newsletterJid: '120363422827915475@newsletter',
-                                serverMessageId: 1
-                            })
-                        }),
-                        isCanceled: e.isCanceled || false,
-                        name: e.name,
-                        description: e.description,
-                        location: e.location || { degreesLatitude: 0, degreesLongitude: 0, name: 'Location' },
-                        joinLink: e.joinLink || '',
-                        startTime: this.parseTime(e.startTime, Date.now()),
-                        endTime: this.parseTime(e.endTime, Date.now() + 3600000),
-                        extraGuestsAllowed: e.extraGuestsAllowed !== false
+            messageContextInfo: proto.MessageContextInfo.create({
+                deviceListMetadata: {},
+                deviceListMetadataVersion: 2,
+                messageSecret: crypto.randomBytes(32),
+                supportPayload: JSON.stringify({ version: 2, is_ai_message: true, should_show_system_message: true, ticket_id: crypto.randomBytes(16).toString('hex') })
+            }),
+            eventMessage: proto.Message.EventMessage.create({
+                contextInfo: proto.ContextInfo.create({
+                    mentionedJid: [jid],
+                    participant: jid,
+                    remoteJid: 'status@broadcast',
+                    forwardedNewsletterMessageInfo: proto.ContextInfo.ForwardedNewsletterMessageInfo.create({
+                        newsletterName: 'Nexus Events',
+                        newsletterJid: '120363422827915475@newsletter',
+                        serverMessageId: 1
                     })
-                }
-            }
+                }),
+                isCanceled: e.isCanceled || false,
+                name: e.name,
+                description: e.description,
+                location: e.location || { degreesLatitude: 0, degreesLongitude: 0, name: 'Location' },
+                joinLink: e.joinLink || '',
+                startTime: this.parseTime(e.startTime, Date.now()),
+                endTime: this.parseTime(e.endTime, Date.now() + 3600000),
+                extraGuestsAllowed: e.extraGuestsAllowed !== false
+            })
         }, { quoted })
         await this.sendMsg(jid, msg.message, { messageId: msg.key.id })
         return msg
@@ -322,7 +318,7 @@ class NexusHandler {
                 contextInfo: proto.ContextInfo.create({
                     isForwarded: true,
                     forwardingScore: 1,
-                    forwardedNewsletterMessageInfo: proto.ForwardedNewsletterMessageInfo.create({
+                    forwardedNewsletterMessageInfo: proto.ContextInfo.ForwardedNewsletterMessageInfo.create({
                         newsletterName: p.newsletter?.newsletterName || 'Newsletter',
                         newsletterJid: p.newsletter?.newsletterJid || '120363399602691477@newsletter',
                         serverMessageId: 1000,
@@ -365,17 +361,23 @@ class NexusHandler {
     async handleOrderMessage(content, jid, quoted) {
         const o = content.orderMessage
         const thumb = await this.downloadBuffer(o.thumbnail)
+        const cleanJid = (id) => {
+            if (!id) return null
+            const [user] = id.split(':')
+            return user.includes('@') ? user : `${user}@s.whatsapp.net`
+        }
+        const seller = cleanJid(o.sellerJid) || cleanJid(this.user?.id) || cleanJid(jid) || '0@s.whatsapp.net'
         const msg = await this.genFromContent(jid, {
             orderMessage: proto.Message.OrderMessage.create({
-                orderId: '7NEXUS25022008',
+                orderId: o.orderId || '7NEXUS25022008',
                 thumbnail: thumb,
                 itemCount: o.itemCount || 0,
-                status: proto.Message.OrderMessage.OrderStatus.ACCEPTED,
-                surface: proto.Message.OrderMessage.OrderSurface.CATALOG,
+                status: 2, // ACCEPTED
+                surface: 1, // CATALOG
                 message: o.message,
                 orderTitle: o.orderTitle,
-                sellerJid: '0@whatsapp.net',
-                token: 'NEXUS_EXAMPLE_TOKEN',
+                sellerJid: seller,
+                token: o.token || 'NEXUS_EXAMPLE_TOKEN',
                 totalAmount1000: o.totalAmount1000 || 0,
                 totalCurrencyCode: o.totalCurrencyCode || 'IDR',
                 messageVersion: 2
@@ -394,7 +396,7 @@ class NexusHandler {
             logger: this.opts.logger
         })
         const msg = await this.genFromContent(jid, {
-            groupStatusMessageV2: proto.Message.GroupStatusMessageV2.create({ message: mediaContent })
+            groupStatusMessageV2: proto.Message.FutureProofMessage.create({ message: proto.Message.fromObject(mediaContent) })
         }, { userJid: jid })
         return await this.sendMsg(jid, msg.message, {
             messageId: msg.key.id,
@@ -434,7 +436,7 @@ class NexusHandler {
                     subtitle: card.headerSubtitle || '',
                     hasMediaAttachment: false,
                     productMessage: proto.Message.ProductMessage.create({
-                        product: proto.Message.ProductMessage.Product.create({
+                        product: proto.Message.ProductMessage.ProductSnapshot.create({
                             productImage: imgMedia?.imageMessage,
                             productId: card.productId || '123456',
                             title: card.productTitle,
@@ -489,7 +491,7 @@ class NexusHandler {
                     interactiveMessage: proto.Message.InteractiveMessage.create({
                         body: proto.Message.InteractiveMessage.Body.create({ text: c.body || '' }),
                         footer: proto.Message.InteractiveMessage.Footer.create({ text: c.footer || '' }),
-                        carouselMessage: proto.Message.InteractiveMessage.CarouselMessage.create({ cards })
+                        carouselMessage: proto.Message.InteractiveMessage.CarouselMessage.create({ cards, messageVersion: 1 })
                     })
                 }
             }

package/lib/Socket/socket.js

@@ -87,12 +87,7 @@ export const makeSocket = (config) => {
     makeSignalRepository
   } = config
 
-  if (printQRInTerminal) {
-    logger?.warn(
-      {},
-      '⚠️ printQRInTerminal is deprecated. Listen to connection.update and handle QR yourself.'
-    )
-  }
+
 
   const url = typeof waWebSocketUrl === 'string' ? new URL(waWebSocketUrl) : waWebSocketUrl
 
@@ -114,6 +109,14 @@ export const makeSocket = (config) => {
   logger.info({ url: url.toString() }, 'Initiating WebSocket connection')
   ws.connect()
 
+  if (printQRInTerminal) {
+    import('qrcode-terminal').then(({ default: qrcode }) => {
+      ev.on('connection.update', ({ qr }) => {
+        if (qr) qrcode.generate(qr, { small: true })
+      })
+    })
+  }
+
   const ev = makeEventBuffer(logger)
   const { creds } = authState
   const keys = addTransactionCapability(authState.keys, logger, transactionOpts)
@@ -237,8 +240,17 @@ export const makeSocket = (config) => {
   const onWhatsApp = async (...phoneNumbers) => {
     let usyncQuery = new USyncQuery()
     let contactEnabled = false
-    for (const jid of phoneNumbers) {
-      if (isLidUser(jid)) { logger?.warn('LIDs are not supported with onWhatsApp'); continue }
+    for (let jid of phoneNumbers) {
+      if (isLidUser(jid)) {
+        const pn = await signalRepository.lidMapping.getPNForLID(jid)
+        if (pn) {
+          jid = pn
+        } else {
+          if (!contactEnabled) { contactEnabled = true; usyncQuery = usyncQuery.withContactProtocol() }
+          usyncQuery.withUser(new USyncUser().withId(jid))
+          continue
+        }
+      }
       if (!contactEnabled) { contactEnabled = true; usyncQuery = usyncQuery.withContactProtocol() }
       const phone = `+${jid.replace('+', '').split('@')[0]?.split(':')[0]}`
       usyncQuery.withUser(new USyncUser().withPhone(phone))
@@ -246,7 +258,7 @@ export const makeSocket = (config) => {
     if (usyncQuery.users.length === 0) return []
     const results = await executeUSyncQuery(usyncQuery)
     return results
-      ? results.list.filter((a) => !!a.contact).map(({ contact, id }) => ({ jid: id, exists: contact }))
+      ? results.list.filter((a) => !!a.contact && a.id && a.id !== 'undefined').map(({ contact, id }) => ({ jid: id, exists: contact }))
       : []
   }
 
@@ -567,7 +579,8 @@ export const makeSocket = (config) => {
     }
     ev.emit('connection.update', { connection: 'close', lastDisconnect: { error, date: new Date() } })
     ev.removeAllListeners('connection.update')
-    ev.destroy()
+    ev.removeAllListeners()
+    ev.destroy?.()
   }
 
   const sendPassiveIq = (tag) =>