@zervonex/baileys 3.0.8 → 4.0.0

package/lib/Builders/base.js

@@ -1,6 +1,6 @@
 import crypto from 'crypto'
 import { proto } from '../../WAProto/index.js'
-import { generateWAMessage, generateWAMessageFromContent, getUrlInfo, prepareWAMessageMedia } from '../Utils/index.js'
+import { generateWAMessage, generateWAMessageFromContent, getUrlInfo, prepareWAMessageMedia, resolveNativeFlowButtons } from '../Utils/index.js'
 
 export const getRandomHex = () => '#' + Array.from(crypto.getRandomValues(new Uint8Array(3)), b => b.toString(16).padStart(2, '0')).join('')
 
@@ -100,7 +100,7 @@ export async function handlePollResult(sock, jid, p) {
         pollResultSnapshotMessage: proto.Message.PollResultSnapshotMessage.create({
             name: p.name,
             pollVotes: (p.pollVotes ?? []).map(v => proto.Message.PollResultSnapshotMessage.PollVote.create({ optionName: v.optionName, optionVoteCount: String(v.optionVoteCount ?? 0) })),
-            contextInfo: proto.ContextInfo.create({ isForwarded: true, forwardingScore: 1, forwardedNewsletterMessageInfo: proto.ContextInfo.ForwardedNewsletterMessageInfo.create({ newsletterName: p.newsletter?.newsletterName ?? 'Newsletter', newsletterJid: p.newsletter?.newsletterJid ?? '120363399602691477@newsletter', serverMessageId: 1000, contentType: 'UPDATE' }) })
+            contextInfo: proto.ContextInfo.create({ isForwarded: true, forwardingScore: 1 })
         })
     }, { userJid: sock.user?.id })
     await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
@@ -109,6 +109,16 @@ export async function handlePollResult(sock, jid, p) {
 
 export const q = quoted => quoted ? { quoted } : {}
 
+export async function handleNativeFlow(sock, jid, content, opts = {}) {
+    const rawButtons = content.nativeFlow
+    const resolved = resolveNativeFlowButtons(rawButtons)
+    const offerParams = content.offerText ? { limited_time_offer: { text: content.offerText, url: content.offerUrl || '', copy_code: content.offerCode || '', expiration_time: content.offerExpiration ? Math.floor(content.offerExpiration / 1000) : 0 } } : {}
+    const messageParams = { ...offerParams }
+    if (content.optionText) messageParams.bottom_sheet = { in_thread_buttons_limit: 1, divider_indices: Array.from({ length: resolved.length }, (_, i) => i), list_title: content.optionTitle || content.optionText, button_title: content.optionText }
+    if (content.interactiveAsTemplate) return sock.sendMessage(jid, { ...content, nativeFlow: undefined, interactiveButtons: undefined, templateButtons: resolved.map(b => { const p = JSON.parse(b.buttonParamsJson ?? '{}'); return b.name === 'cta_url' ? { text: p.display_text, url: p.url } : b.name === 'cta_call' ? { text: p.display_text, call: p.phone_number } : { text: p.display_text, id: p.id } }) }, opts)
+    return sock.sendMessage(jid, { ...content, nativeFlow: undefined, interactiveButtons: resolved, ...(Object.keys(messageParams).length ? { messageParamsJson: JSON.stringify(messageParams) } : {}) }, opts)
+}
+
 export const PRIMITIVE_SHORTCUTS = {
     sendText: sock => (jid, text, opts = {}) => sock.sendMessage(jid, { text }, opts),
     sendImage: sock => (jid, image, caption = '', opts = {}) => sock.sendMessage(jid, { image, caption }, opts),
@@ -126,5 +136,6 @@ export const HANDLER_SHORTCUTS = {
     sendStatusMentionMessage: (sock, config) => (jid, data) => handleStatusMention(sock, jid, norm(data), config),
     sendStatusMentions: (sock, config) => (jid, data) => handleStatusMention(sock, jid, norm(data), config),
     sendPollResultMessage: sock => (jid, data) => handlePollResult(sock, jid, norm(data)),
-    sendGroupStatusMessage: (sock, config) => (jid, content, opts = {}) => handleGroupStatus(sock, jid, norm(content), config)
+    sendGroupStatusMessage: (sock, config) => (jid, content, opts = {}) => handleGroupStatus(sock, jid, norm(content), config),
+    sendNativeFlow: sock => (jid, content, opts = {}) => handleNativeFlow(sock, jid, norm(content), opts)
 }

package/lib/Builders/builders.js

@@ -1,7 +1,7 @@
 import crypto from 'crypto'
 import { proto } from '../../WAProto/index.js'
 import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js'
-import { generateWAMessage, generateWAMessageFromContent, generateMessageIDV2, prepareStickerPackMessage, prepareWAMessageMedia } from '../Utils/index.js'
+import { generateWAMessage, generateWAMessageFromContent, generateMessageIDV2, prepareStickerPackMessage, prepareWAMessageMedia, resolveNativeFlowButtons } from '../Utils/index.js'
 import { getBizBinaryNode } from '../WABinary/index.js'
 import { BaseBuilder, norm, q } from './base.js'
 
@@ -43,9 +43,7 @@ export class Button {
     setLimitedTimeOffer(exp) { this.#params.limited_time_offer = { expiration_time_ms: exp }; return this }
     setBottomSheet(opts = {}) { this.#params.bottom_sheet = opts; return this }
     setTapTargetConfiguration(opts = {}) { this.#params.tap_target_configuration = opts; return this }
-
     #addNative(name, params) { this.#mode = 'native'; this.#buttons.push({ name, buttonParamsJson: JSON.stringify(params) }); return this }
-
     reply(text, id) { return this.#addNative('quick_reply', { display_text: text, id }) }
     url(text, url, merchantUrl) { return this.#addNative('cta_url', { display_text: text, url, merchant_url: merchantUrl ?? url }) }
     call(text, phone) { return this.#addNative('cta_call', { display_text: text, phone_number: phone }) }
@@ -118,7 +116,7 @@ export class Interactive extends BaseBuilder {
         const footerText = typeof i.footer === 'string' ? i.footer : (i.footer?.text ?? '')
         const headerTitle = typeof i.header === 'string' ? i.header : (i.header?.title ?? '')
         let nativeFlow = null
-        if (i.buttons?.length || i.nativeFlowMessage) { const nfm = i.nativeFlowMessage ?? {}; nativeFlow = proto.Message.InteractiveMessage.NativeFlowMessage.create({ buttons: i.buttons ?? nfm.buttons ?? [], messageParamsJson: nfm.messageParamsJson ?? '' }) }
+        if (i.buttons?.length || i.nativeFlowMessage) { const nfm = i.nativeFlowMessage ?? {}; const rawButtons = i.buttons ?? nfm.buttons ?? []; nativeFlow = proto.Message.InteractiveMessage.NativeFlowMessage.create({ buttons: resolveNativeFlowButtons(rawButtons), messageParamsJson: nfm.messageParamsJson ?? '' }) }
         const headerMedia = {}
         if (media?.imageMessage) headerMedia.imageMessage = media.imageMessage
         if (media?.videoMessage) headerMedia.videoMessage = media.videoMessage
@@ -139,7 +137,7 @@ export class Carousel extends BaseBuilder {
 
     static dispatchKeys = ['carouselMessage']
     static shortcuts = {
-        sendCarouselMessage: sock => (jid, data, quoted) => { const d = norm(data); const c = new Carousel(sock); if (d.caption) c.setCaption(d.caption); if (d.footer) c.setFooter(d.footer); (d.cards ?? []).forEach(card => c.card(card)); return c.send(jid, q(quoted)) },
+        sendCarouselMessage: sock => (jid, data, quoted) => { const d = norm(data); const c = new Carousel(sock); if (d.caption) c.setCaption(d.caption); if (d.footer) c.setFooter(d.footer); (d.cards ?? []).forEach(card => { const resolved = card.nativeFlow ? { ...card, nativeFlow: undefined, nativeFlowMessage: { buttons: resolveNativeFlowButtons(Array.isArray(card.nativeFlow) ? card.nativeFlow : [card.nativeFlow]) } } : card; c.card(resolved) }); return c.send(jid, q(quoted)) },
         sendCarouselProtoMessage: sock => (jid, data, quoted) => Carousel.shortcuts.sendCarouselMessage(sock)(jid, data, quoted),
     }
 
@@ -150,20 +148,20 @@ export class Carousel extends BaseBuilder {
         if (d.caption) this.setCaption(d.caption)
         if (d.footer) this.setFooter(d.footer)
         if (d.cardType) this.setCardType(d.cardType)
-            ; (d.cards ?? []).forEach(card => this.card(card))
+            ; (d.cards ?? []).forEach(card => { const resolved = card.nativeFlow ? { ...card, nativeFlow: undefined, nativeFlowMessage: { buttons: resolveNativeFlowButtons(Array.isArray(card.nativeFlow) ? card.nativeFlow : [card.nativeFlow]) } } : card; this.card(resolved) })
         return this
     }
 
     setCaption(t) { this.#caption = t; return this }
     setFooter(t) { this.#footer = t; return this }
     setCardType(t) { this.#cardType = t; return this }
-    card(b) { this.#cards.push(b instanceof Button ? b.toCard() : b); return this }
+    card(b) { this.#cards.push(b instanceof Button ? b.toCard() : (b.text || b.url || b.id ? new Button(this.client).reply(b.text ?? '', b.id ?? '').toCard() : b)); return this }
 
     async send(jid, opts = {}) {
         if (this.#cards.length < 2) throw new Error('Carousel requires at least 2 cards')
         if (this.#cards.length > 10) throw new Error('Carousel max 10 cards')
         const cards = this.#cards.map(c => ({ ...c, header: (c.header?.imageMessage || c.header?.hasMediaAttachment) ? c.header : { ...c.header, hasMediaAttachment: true, imageMessage: { url: Carousel.#PLACEHOLDER } } }))
-        const msg = await await generateWAMessageFromContent(jid, { interactiveMessage: proto.Message.InteractiveMessage.create({ header: proto.Message.InteractiveMessage.Header.create({ hasMediaAttachment: false }), body: proto.Message.InteractiveMessage.Body.create({ text: this.#caption }), footer: proto.Message.InteractiveMessage.Footer.create({ text: this.#footer }), carouselMessage: proto.Message.InteractiveMessage.CarouselMessage.create({ cards: cards.map(c => ({ header: proto.Message.InteractiveMessage.Header.create({ title: c.header?.title ?? '', hasMediaAttachment: c.header?.hasMediaAttachment ?? false, ...c.header }), body: proto.Message.InteractiveMessage.Body.create({ text: c.body?.text ?? '' }), footer: proto.Message.InteractiveMessage.Footer.create({ text: c.footer?.text ?? '' }), nativeFlowMessage: proto.Message.InteractiveMessage.NativeFlowMessage.create({ buttons: c.nativeFlowMessage?.buttons ?? [] }) })), messageVersion: 1, carouselCardType: this.#cardType === 'ALBUM_IMAGE' ? 2 : 1 }) }) }, { userJid: this.client.user?.id, waUploadToServer: this.client.waUploadToServer })
+        const msg = await await generateWAMessageFromContent(jid, { interactiveMessage: proto.Message.InteractiveMessage.create({ header: proto.Message.InteractiveMessage.Header.create({ hasMediaAttachment: false }), body: proto.Message.InteractiveMessage.Body.create({ text: this.#caption }), footer: proto.Message.InteractiveMessage.Footer.create({ text: this.#footer }), carouselMessage: proto.Message.InteractiveMessage.CarouselMessage.create({ cards: cards.map(c => ({ header: proto.Message.InteractiveMessage.Header.create({ title: c.header?.title ?? '', hasMediaAttachment: c.header?.hasMediaAttachment ?? false, ...c.header }), body: proto.Message.InteractiveMessage.Body.create({ text: c.body?.text ?? '' }), footer: proto.Message.InteractiveMessage.Footer.create({ text: c.footer?.text ?? '' }), nativeFlowMessage: proto.Message.InteractiveMessage.NativeFlowMessage.create({ buttons: resolveNativeFlowButtons(c.nativeFlowMessage?.buttons ?? []) }) })), messageVersion: 1, carouselCardType: this.#cardType === 'ALBUM_IMAGE' ? 2 : 1 }) }) }, { userJid: this.client.user?.id, waUploadToServer: this.client.waUploadToServer })
         const bizNode = getBizBinaryNode(msg.message)
         await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
         return msg
@@ -234,13 +232,17 @@ export class Payment extends BaseBuilder {
     setExpiry(t) { this.data.expiry = t; return this }
     setNote(n) { this.data.note = n; return this }
     setFrom(j) { this.data.from = j; return this }
+    setBackground(b) { this.data.background = b; return this }
 
     async send(jid, opts = {}) {
         const d = this.data
+        const currency = d.currency ?? 'NGN'
+        const amount = d.amount ?? 0
         const ctx = opts.quoted ? { stanzaId: opts.quoted.key?.id, participant: opts.quoted.key?.participant, quotedMessage: opts.quoted.message } : {}
         const notes = d.note ? { extendedTextMessage: { text: d.note, contextInfo: ctx } } : {}
-        const msg = await await generateWAMessageFromContent(jid, { requestPaymentMessage: proto.Message.RequestPaymentMessage.fromObject({ expiryTimestamp: d.expiry ?? 0, amount1000: d.amount ?? 0, currencyCodeIso4217: d.currency ?? 'NGN', requestFrom: d.from ?? '0@s.whatsapp.net', noteMessage: notes, background: d.background ?? { id: 'DEFAULT', placeholderArgb: 0xfff0f0f0 } }) }, { userJid: this.client.user?.id, waUploadToServer: this.client.waUploadToServer })
-        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id })
+        const msg = await generateWAMessageFromContent(jid, { requestPaymentMessage: proto.Message.RequestPaymentMessage.fromObject({ expiryTimestamp: d.expiry ?? 0, amount1000: amount, currencyCodeIso4217: currency, requestFrom: d.from ?? '0@s.whatsapp.net', noteMessage: notes, amount: proto.Money.create({ value: amount, offset: 1000, currencyCode: currency }), ...(d.background ? { background: proto.PaymentBackground.create({ id: d.background.id ?? 'DEFAULT', placeholderArgb: d.background.placeholderArgb ?? 0xfff0f0f0, textArgb: d.background.textArgb ?? 0, subtextArgb: d.background.subtextArgb ?? 0, type: proto.PaymentBackground.Type.DEFAULT }) } : {}) }) }, { userJid: this.client.user?.id, waUploadToServer: this.client.waUploadToServer })
+        const bizNode = getBizBinaryNode(msg.message)
+        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
         return msg
     }
 }
@@ -262,8 +264,9 @@ export class Order extends BaseBuilder {
         }
         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(userJid) ?? cleanJid(jid) ?? '0@s.whatsapp.net'
-        const msg = await await generateWAMessageFromContent(jid, { orderMessage: proto.Message.OrderMessage.create({ orderId: o.orderId ?? `zervonex${Date.now()}`, thumbnail: thumb, itemCount: o.itemCount ?? 0, status: 2, surface: 1, message: o.message, orderTitle: o.orderTitle, sellerJid: seller, token: o.token ?? 'zervonex_TOKEN', totalAmount1000: o.totalAmount1000 ?? 0, totalCurrencyCode: o.totalCurrencyCode ?? 'NGN', messageVersion: 2 }) }, { userJid, quoted: opts.quoted, waUploadToServer: this.client.waUploadToServer })
-        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id })
+        const msg = await generateWAMessageFromContent(jid, { orderMessage: proto.Message.OrderMessage.create({ orderId: o.orderId ?? `zervonex${Date.now()}`, thumbnail: thumb, itemCount: o.itemCount ?? 0, status: o.status ?? proto.Message.OrderMessage.OrderStatus.INQUIRY, surface: o.surface ?? proto.Message.OrderMessage.OrderSurface.CATALOG, message: o.message, orderTitle: o.orderTitle, sellerJid: seller, token: o.token ?? 'zervonex_TOKEN', totalAmount1000: o.totalAmount1000 ?? 0, totalCurrencyCode: o.totalCurrencyCode ?? 'NGN', messageVersion: o.messageVersion ?? 2, ...(o.catalogType ? { catalogType: o.catalogType } : {}), ...(o.contextInfo ? { contextInfo: o.contextInfo } : {}) }) }, { userJid, quoted: opts.quoted, waUploadToServer: this.client.waUploadToServer })
+        const bizNode = getBizBinaryNode(msg.message)
+        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
         return msg
     }
 }
@@ -271,25 +274,27 @@ export class Order extends BaseBuilder {
 // ─── Event ────────────────────────────────────────────────────────────────────
 export class Event extends BaseBuilder {
     static dispatchKeys = ['eventMessage']
-    static shortcuts = {
-        sendEventMessage: sock => (jid, data, quoted) => new Event(sock).from(data).send(jid, q(quoted)),
-    }
+    static shortcuts = { sendEventMessage: sock => (jid, data, quoted) => new Event(sock).from(data).send(jid, q(quoted)) }
 
     setName(n) { this.data.name = n; return this }
     setDescription(d) { this.data.description = d; return this }
     setLocation(l) { this.data.location = l; return this }
     setJoinLink(l) { this.data.joinLink = l; return this }
-    setStartTime(t) { this.data.startTime = t; return this }
-    setEndTime(t) { this.data.endTime = t; return this }
+    setStartTime(t) { this.data.startDate = t instanceof Date ? t : new Date(t); return this }
+    setEndTime(t) { this.data.endDate = t instanceof Date ? t : new Date(t); return this }
     setCanceled(v = true) { this.data.isCanceled = v; return this }
     setReminder(sec) { this.data.hasReminder = true; this.data.reminderOffsetSec = sec; return this }
     setScheduledCall(v = true) { this.data.isScheduleCall = v; return this }
+    setMessageSecret(s) { this.data.messageSecret = s; return this }
 
     async send(jid, opts = {}) {
         const e = this.data
-        const parseTime = (val, def) => typeof val === 'string' ? parseInt(val) : (val ?? def)
-        const msg = await await generateWAMessageFromContent(jid, { 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: 'zervonex 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: parseTime(e.startTime, Date.now()), endTime: parseTime(e.endTime, Date.now() + 3600000), extraGuestsAllowed: e.extraGuestsAllowed !== false, ...(e.hasReminder ? { hasReminder: true, reminderOffsetSec: e.reminderOffsetSec ?? 3600 } : {}), ...(e.isScheduleCall !== undefined ? { isScheduleCall: e.isScheduleCall } : {}) }) }, { userJid: this.client.user?.id, quoted: opts.quoted, waUploadToServer: this.client.waUploadToServer })
-        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id })
+        if (!e.name) throw new Error('Event name is required')
+        const startDate = e.startDate instanceof Date ? e.startDate : new Date(e.startDate ?? Date.now())
+        const endDate = e.endDate ? (e.endDate instanceof Date ? e.endDate : new Date(e.endDate)) : null
+        const msg = await generateWAMessageFromContent(jid, { messageContextInfo: proto.MessageContextInfo.create({ messageSecret: e.messageSecret || crypto.randomBytes(32) }), eventMessage: proto.Message.EventMessage.create({ isCanceled: e.isCanceled ?? false, name: e.name, description: e.description ?? '', location: e.location ?? { degreesLatitude: 0, degreesLongitude: 0, name: 'Location' }, joinLink: e.joinLink ?? '', startTime: Math.floor(startDate.getTime() / 1000), endTime: endDate ? Math.floor(endDate.getTime() / 1000) : undefined, extraGuestsAllowed: e.extraGuestsAllowed !== false, isScheduleCall: e.isScheduleCall ?? false, hasReminder: e.hasReminder ?? false, reminderOffsetSec: e.reminderOffsetSec ?? 0 }) }, { userJid: this.client.user?.id, quoted: opts.quoted, waUploadToServer: this.client.waUploadToServer })
+        const bizNode = getBizBinaryNode(msg.message)
+        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
         return msg
     }
 }
@@ -353,7 +358,9 @@ export class VerticalAlbum extends BaseBuilder {
             messageContextInfo: { botMetadata: { pluginMetadata: {}, botRenderingConfigMetadata: BOT_RENDERING_CONFIG_METADATA } },
             botForwardedMessage: { message: { richResponseMessage: proto.Message.AIRichResponseMessage?.create?.({ messageType: 1, submessages: [], unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' }, forwardOrigin: 4 } }) ?? { messageType: 1, submessages: [], unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' }, forwardOrigin: 4 } } } }
         }, { userJid: this.client.user?.id, waUploadToServer: this.client.waUploadToServer })
-        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id })
+        const bizNode = getBizBinaryNode(msg.message)
+        const relayFn = this.client.relayRichMessage ?? this.client.relayMessage
+        await relayFn(jid, msg, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
         return msg
     }
 }
@@ -383,7 +390,9 @@ export class GridImage extends BaseBuilder {
             messageContextInfo: { botMetadata: { pluginMetadata: {}, botRenderingConfigMetadata: BOT_RENDERING_CONFIG_METADATA } },
             botForwardedMessage: { message: { richResponseMessage: { messageType: 1, submessages, unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' }, forwardOrigin: 4 } } } }
         }, { userJid: this.client.user?.id, waUploadToServer: this.client.waUploadToServer })
-        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id })
+        const bizNode = getBizBinaryNode(msg.message)
+        const relayFn = this.client.relayRichMessage ?? this.client.relayMessage
+        await relayFn(jid, msg, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
         return msg
     }
 }
@@ -409,51 +418,134 @@ export class VideoGrid extends BaseBuilder {
             messageContextInfo: { botMetadata: { pluginMetadata: {}, botRenderingConfigMetadata: BOT_RENDERING_CONFIG_METADATA } },
             botForwardedMessage: { message: { richResponseMessage: { messageType: 1, submessages: [], unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) }, contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' }, forwardOrigin: 4 } } } }
         }, { userJid: this.client.user?.id, waUploadToServer: this.client.waUploadToServer })
-        await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id })
+        const bizNode = getBizBinaryNode(msg.message)
+        const relayFn = this.client.relayRichMessage ?? this.client.relayMessage
+        await relayFn(jid, msg, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
         return msg
     }
 }
 
 // ─── A2UI ─────────────────────────────────────────────────────────────────────
 export class A2UI extends BaseBuilder {
+    static VERSION = 'v0.9'
+    static get CATALOG() { return `https://a2ui.org/specification/${this.VERSION}/catalogs/basic/catalog.json` }
     static dispatchKeys = ['a2uiMessage']
     static shortcuts = {
         sendA2UIMessage: sock => (jid, data, opts = {}) => new A2UI(sock).from(data, opts).send(jid, opts),
-        sendA2UICommandMenu: sock => (jid, data, opts = {}) => new A2UI(sock).from(data, { __commandMenu: true, ...opts }).send(jid, opts)
+        sendA2UICommandMenu: sock => (jid, data, opts = {}) => new A2UI(sock).from(data, { __commandMenu: true, ...opts }).send(jid, opts),
+        sendA2UI: sock => (jid, components, opts = {}) => new A2UI(sock).addComponents(components).send(jid, opts)
     }
-
+    static #v = { imgVariant: ['icon', 'avatar', 'smallFeature', 'mediumFeature', 'largeFeature', 'header'], imgFit: ['contain', 'cover', 'fill', 'none', 'scaleDown'], textVariant: ['h1', 'h2', 'h3', 'h4', 'h5', 'caption', 'body'], btnVariant: ['default', 'primary', 'borderless'], colJustify: ['start', 'center', 'end', 'spaceBetween', 'spaceAround', 'spaceEvenly', 'stretch'], rowJustify: ['center', 'end', 'spaceAround', 'spaceBetween', 'spaceEvenly', 'start', 'stretch'], align: ['start', 'center', 'end', 'stretch'], listDir: ['vertical', 'horizontal'], tfVariant: ['longText', 'number', 'shortText', 'obscured'], cpVariant: ['mutuallyExclusive', 'multipleSelection'], cpDisplay: ['checkbox', 'chips'], divAxis: ['horizontal', 'vertical'], icons: ['accountCircle', 'add', 'arrowBack', 'arrowForward', 'attachFile', 'calendarToday', 'call', 'camera', 'check', 'close', 'delete', 'download', 'edit', 'event', 'error', 'fastForward', 'favorite', 'favoriteOff', 'folder', 'help', 'home', 'info', 'locationOn', 'lock', 'lockOpen', 'mail', 'menu', 'moreVert', 'moreHoriz', 'notificationsOff', 'notifications', 'pause', 'payment', 'person', 'phone', 'photo', 'play', 'print', 'refresh', 'rewind', 'search', 'send', 'settings', 'share', 'shoppingCart', 'skipNext', 'skipPrevious', 'star', 'starHalf', 'starOff', 'stop', 'upload', 'visibility', 'visibilityOff', 'volumeDown', 'volumeMute', 'volumeOff', 'volumeUp', 'warning'] }
+    static #pick(val, list, def) { return list.includes(val) ? val : def }
+    static #id(id, name) { if (!id) throw new TypeError(`${name} requires an id`); return id }
+    static text(id, text, { variant = 'body' } = {}) { return { id: A2UI.#id(id, 'text'), component: 'Text', text: String(text), variant: A2UI.#pick(variant, A2UI.#v.textVariant, 'body') } }
+    static image(id, input, { variant = 'mediumFeature', fit = 'fill' } = {}) { if (!input) throw new TypeError('image requires a url, buffer, or file path'); return { id: A2UI.#id(id, 'image'), component: 'Image', url: '', _raw: input, variant: A2UI.#pick(variant, A2UI.#v.imgVariant, 'mediumFeature'), fit: A2UI.#pick(fit, A2UI.#v.imgFit, 'fill') } }
+    static icon(id, name) { if (!name) throw new TypeError('icon requires a name'); if (typeof name === 'string' && !A2UI.#v.icons.includes(name)) throw new TypeError(`invalid icon: ${name}`); return { id: A2UI.#id(id, 'icon'), component: 'Icon', name } }
+    static video(id, url) { if (!url) throw new TypeError('video requires a url'); return { id: A2UI.#id(id, 'video'), component: 'Video', url: String(url) } }
+    static audio(id, url, { description = '' } = {}) { if (!url) throw new TypeError('audio requires a url'); return { id: A2UI.#id(id, 'audio'), component: 'AudioPlayer', url: String(url), ...(description ? { description: String(description) } : {}) } }
+    static column(id, children = [], { justify = 'start', align = 'stretch' } = {}) { if (!children.length) throw new TypeError('column requires at least one child'); return { id: A2UI.#id(id, 'column'), component: 'Column', children: children.map(String), justify: A2UI.#pick(justify, A2UI.#v.colJustify, 'start'), align: A2UI.#pick(align, A2UI.#v.align, 'stretch') } }
+    static row(id, children = [], { justify = 'start', align = 'stretch' } = {}) { if (!children.length) throw new TypeError('row requires at least one child'); return { id: A2UI.#id(id, 'row'), component: 'Row', children: children.map(String), justify: A2UI.#pick(justify, A2UI.#v.rowJustify, 'start'), align: A2UI.#pick(align, A2UI.#v.align, 'stretch') } }
+    static list(id, children = [], { direction = 'vertical', align = 'stretch' } = {}) { if (!children.length) throw new TypeError('list requires at least one child'); return { id: A2UI.#id(id, 'list'), component: 'List', children: children.map(String), direction: A2UI.#pick(direction, A2UI.#v.listDir, 'vertical'), align: A2UI.#pick(align, A2UI.#v.align, 'stretch') } }
+    static card(id, child) { if (!child) throw new TypeError('card requires a child id'); return { id: A2UI.#id(id, 'card'), component: 'Card', child: String(child) } }
+    static tabs(id, tabs = []) { if (!tabs.length) throw new TypeError('tabs requires at least one tab'); return { id: A2UI.#id(id, 'tabs'), component: 'Tabs', tabs: tabs.map((t, i) => ({ title: String(t.title ?? t.label ?? `Tab ${i + 1}`), child: String(t.child) })) } }
+    static modal(id, trigger, content) { if (!trigger) throw new TypeError('modal requires a trigger id'); if (!content) throw new TypeError('modal requires a content id'); return { id: A2UI.#id(id, 'modal'), component: 'Modal', trigger: String(trigger), content: String(content) } }
+    static divider(id, { axis = 'horizontal' } = {}) { return { id: A2UI.#id(id, 'divider'), component: 'Divider', axis: A2UI.#pick(axis, A2UI.#v.divAxis, 'horizontal') } }
+    static button(id, child, action, { variant = 'default' } = {}) { if (!child) throw new TypeError('button requires a child id'); if (!action) throw new TypeError('button requires an action'); return { id: A2UI.#id(id, 'button'), component: 'Button', child: String(child), action, variant: A2UI.#pick(variant, A2UI.#v.btnVariant, 'default') } }
+    static textField(id, label, { value = '', variant = 'shortText', validationRegexp = '' } = {}) { if (!label) throw new TypeError('textField requires a label'); return { id: A2UI.#id(id, 'textField'), component: 'TextField', label: String(label), value: String(value), variant: A2UI.#pick(variant, A2UI.#v.tfVariant, 'shortText'), ...(validationRegexp ? { validationRegexp: String(validationRegexp) } : {}) } }
+    static checkBox(id, label, value = false) { if (!label) throw new TypeError('checkBox requires a label'); return { id: A2UI.#id(id, 'checkBox'), component: 'CheckBox', label: String(label), value: Boolean(value) } }
+    static choicePicker(id, options = [], value = [], { label = '', variant = 'mutuallyExclusive', displayStyle = 'checkbox', filterable = false } = {}) { if (!options.length) throw new TypeError('choicePicker requires at least one option'); return { id: A2UI.#id(id, 'choicePicker'), component: 'ChoicePicker', options: options.map(o => typeof o === 'string' ? { label: o, value: o } : { label: String(o.label), value: String(o.value) }), value: (Array.isArray(value) ? value : [value]).map(String), ...(label ? { label: String(label) } : {}), variant: A2UI.#pick(variant, A2UI.#v.cpVariant, 'mutuallyExclusive'), displayStyle: A2UI.#pick(displayStyle, A2UI.#v.cpDisplay, 'checkbox'), filterable: Boolean(filterable) } }
+    static slider(id, value, max, { label = '', min = 0 } = {}) { if (max == null) throw new TypeError('slider requires a max'); return { id: A2UI.#id(id, 'slider'), component: 'Slider', value: Number(value), max: Number(max), min: Number(min), ...(label ? { label: String(label) } : {}) } }
+    static dateTimeInput(id, value = '', { label = '', enableDate = false, enableTime = false, min = '', max = '' } = {}) { return { id: A2UI.#id(id, 'dateTimeInput'), component: 'DateTimeInput', value: String(value), enableDate: Boolean(enableDate), enableTime: Boolean(enableTime), ...(label ? { label: String(label) } : {}), ...(min ? { min: String(min) } : {}), ...(max ? { max: String(max) } : {}) } }
+    static surface(components, { surfaceId, catalogId = A2UI.CATALOG, version = A2UI.VERSION } = {}) { const id = surfaceId ?? `zervonex-a2ui-${crypto.randomUUID()}`; return Buffer.from(JSON.stringify({ version, createSurface: { surfaceId: id, catalogId, sendDataModel: false, components } }), 'utf8') }
+    static async #resolveImage(input, upload) {
+        if (Buffer.isBuffer(input)) { const p = await prepareWAMessageMedia({ image: input }, { upload }); return { url: p.imageMessage?.url ?? '' } }
+        if (typeof input === 'string' && !input.startsWith('http')) { const { readFile } = await import('node:fs/promises'); const p = await prepareWAMessageMedia({ image: await readFile(input) }, { upload }); return { url: p.imageMessage?.url ?? '' } }
+        if (typeof input === 'string') return { url: input }
+        if (input?.url) return { url: input.url }
+        if (input?.image) { const p = await prepareWAMessageMedia({ image: input.image }, { upload }); return { url: p.imageMessage?.url ?? '' } }
+        throw new TypeError('invalid image input')
+    }
+    #components = []; #buttons = []; #surfaceId = `zervonex-a2ui-${crypto.randomUUID()}`; #fallback = ''; #imageMessage = null
+    async #resolveComponents() {
+        const upload = this.client.waUploadToServer
+        return Promise.all(this.#components.map(async c => {
+            if (c.component !== 'Image' || !c._raw) return c
+            const { _raw, ...rest } = c
+            const { url } = await A2UI.#resolveImage(_raw, upload)
+            return { ...rest, url }
+        }))
+    }
+    async #buildHeader(upload) {
+        if (!this.#imageMessage) return { header: { hasMediaAttachment: false } }
+        const input = this.#imageMessage
+        if (Buffer.isBuffer(input)) { const p = await prepareWAMessageMedia({ image: input }, { upload }); return { header: { ...p, hasMediaAttachment: true } } }
+        if (input?.image) { const p = await prepareWAMessageMedia({ image: input.image }, { upload }); return { header: { ...p, hasMediaAttachment: true } } }
+        const url = input?.url ?? (typeof input === 'string' ? input : null)
+        if (url) return { header: { imageMessage: { url }, hasMediaAttachment: true } }
+        return { header: { hasMediaAttachment: false } }
+    }
+    addComponent(obj) { if (!obj?.id) throw new TypeError('addComponent requires an object with an id'); this.#components.push(obj); return this }
+    addComponents(arr) { if (!Array.isArray(arr)) throw new TypeError('addComponents requires an array'); for (const c of arr) this.addComponent(c); return this }
+    addText(id, text, opts = {}) { return this.addComponent(A2UI.text(id, text, opts)) }
+    addImage(id, input, opts = {}) { return this.addComponent(A2UI.image(id, input, opts)) }
+    addIcon(id, name) { return this.addComponent(A2UI.icon(id, name)) }
+    addVideo(id, url) { return this.addComponent(A2UI.video(id, url)) }
+    addAudio(id, url, opts = {}) { return this.addComponent(A2UI.audio(id, url, opts)) }
+    addColumn(id, children = [], opts = {}) { return this.addComponent(A2UI.column(id, children, opts)) }
+    addRow(id, children = [], opts = {}) { return this.addComponent(A2UI.row(id, children, opts)) }
+    addList(id, children = [], opts = {}) { return this.addComponent(A2UI.list(id, children, opts)) }
+    addCard(id, child) { return this.addComponent(A2UI.card(id, child)) }
+    addTabs(id, tabs = []) { return this.addComponent(A2UI.tabs(id, tabs)) }
+    addModal(id, trigger, content) { return this.addComponent(A2UI.modal(id, trigger, content)) }
+    addDivider(id, opts = {}) { return this.addComponent(A2UI.divider(id, opts)) }
+    addButtonComponent(id, child, action, opts = {}) { return this.addComponent(A2UI.button(id, child, action, opts)) }
+    addTextField(id, label, opts = {}) { return this.addComponent(A2UI.textField(id, label, opts)) }
+    addCheckBox(id, label, value = false) { return this.addComponent(A2UI.checkBox(id, label, value)) }
+    addChoicePicker(id, options, value, opts = {}) { return this.addComponent(A2UI.choicePicker(id, options, value, opts)) }
+    addSlider(id, value, max, opts = {}) { return this.addComponent(A2UI.slider(id, value, max, opts)) }
+    addDateTimeInput(id, value, opts = {}) { return this.addComponent(A2UI.dateTimeInput(id, value, opts)) }
+    addButton(nameOrShorthand, params = {}) {
+        if (!nameOrShorthand) throw new TypeError('addButton requires a name or shorthand object')
+        if (typeof nameOrShorthand === 'object') { const [r] = resolveNativeFlowButtons([nameOrShorthand]); this.#buttons.push(r) }
+        else this.#buttons.push({ name: nameOrShorthand, buttonParamsJson: typeof params === 'string' ? params : JSON.stringify(params) })
+        return this
+    }
+    setFallback(text) { this.#fallback = String(text); return this }
+    setSurfaceId(id) { this.#surfaceId = String(id); return this }
+    setImage(input) { if (!input) throw new TypeError('setImage requires a url, buffer, or file path'); this.#imageMessage = input; return this }
     async send(jid, opts = {}) {
         const d = this.data
+        if (d.components?.length) { this.addComponents(d.components); if (d.buttons?.length) for (const b of d.buttons) this.#buttons.push(b) }
+        const upload = this.client.waUploadToServer
+        if (this.#components.length) {
+            if (!this.#components.some(c => c.id === 'root')) throw new Error('A2UI components must include one with id "root"')
+            const [components, { header }] = await Promise.all([this.#resolveComponents(), this.#buildHeader(upload)])
+            const buttons = [...this.#buttons, ...(opts.buttons ?? [])]
+            const content = { interactiveMessage: { header, body: { text: d.body ?? d.text ?? '\u200b' }, bloksWidget: { uuid: this.#surfaceId, type: 'im_a2ui', data: A2UI.surface(components, { surfaceId: this.#surfaceId }), fallback: this.#fallback }, ...(buttons.length ? { nativeFlowMessage: { messageParamsJson: JSON.stringify(opts.nativeFlowParams ?? {}), buttons, messageVersion: 1 } } : {}) } }
+            const msg = await generateWAMessageFromContent(jid, content, { userJid: this.client.user?.id, waUploadToServer: upload })
+            const bizNode = getBizBinaryNode(msg.message)
+            await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
+            return msg
+        }
         let content
         if (d.__commandMenu) {
-            // command menu preset — builds bloksWidget + nativeFlowMessage together
             const rows = (d.rows ?? []).map((r, i) => ({ title: String(r?.[0] ?? r?.title ?? `Command ${i + 1}`), description: String(r?.[1] ?? r?.description ?? ''), id: String(r?.[2] ?? r?.id ?? r?.[0] ?? `command_${i + 1}`) }))
             const buttons = (d.buttons ?? []).map((b, i) => ({ id: `a2ui_button_${i + 1}`, label: String(b?.text ?? b?.label ?? `Button ${i + 1}`), url: String(b?.url ?? '') }))
-            const componentIds = ['title', 'divider', 'tableCard', 'footer', ...(buttons.length ? ['buttonRow'] : [])]
-            const components = [
-                { id: 'root', component: 'Column', align: 'center', children: componentIds },
-                { id: 'title', component: 'Text', text: String(d.title ?? 'Menu'), variant: 'h2' },
-                { id: 'divider', component: 'Divider' },
-                { id: 'tableCard', component: 'Card', child: 'tableColumn' },
-                { id: 'tableColumn', component: 'Column', children: ['headerRow', ...rows.flatMap((_, i) => [`divider_${i}`, `row_${i}`])] },
-                { id: 'headerRow', component: 'Row', children: ['headerCommand', 'headerFunction'] },
-                { id: 'headerCommand', component: 'Text', text: 'Command', variant: 'h5' },
-                { id: 'headerFunction', component: 'Text', text: 'Function', variant: 'h5' },
-                ...rows.flatMap((r, i) => [{ id: `divider_${i}`, component: 'Divider' }, { id: `row_${i}`, component: 'Row', children: [`command_${i}`, `description_${i}`] }, { id: `command_${i}`, component: 'Text', text: r.title }, { id: `description_${i}`, component: 'Text', text: r.description }]),
-                { id: 'footer', component: 'Text', text: d.footer ?? 'Powered by zervonex', variant: 'caption' }
-            ]
-            if (buttons.length) {
-                components.push({ id: 'buttonRow', component: 'Row', justify: 'spaceEvenly', children: buttons.flatMap((b, i) => [`buttonLabel_${i}`, `button_${i}`]) })
-                buttons.forEach((b, i) => { components.push({ id: `buttonLabel_${i}`, component: 'Text', text: b.label }); components.push({ id: `button_${i}`, component: 'Button', child: `buttonLabel_${i}`, variant: 'primary', action: { call: 'openUrl', args: { url: b.url } } }) })
-            }
+            const components = [{ id: 'root', component: 'Column', align: 'center', children: ['title', 'divider', 'tableCard', 'footer', ...(buttons.length ? ['buttonRow'] : [])] }, { id: 'title', component: 'Text', text: String(d.title ?? 'Menu'), variant: 'h2' }, { id: 'divider', component: 'Divider' }, { id: 'tableCard', component: 'Card', child: 'tableColumn' }, { id: 'tableColumn', component: 'Column', children: ['headerRow', ...rows.flatMap((_, i) => [`divider_${i}`, `row_${i}`])] }, { id: 'headerRow', component: 'Row', children: ['headerCommand', 'headerFunction'] }, { id: 'headerCommand', component: 'Text', text: 'Command', variant: 'h5' }, { id: 'headerFunction', component: 'Text', text: 'Function', variant: 'h5' }, ...rows.flatMap((r, i) => [{ id: `divider_${i}`, component: 'Divider' }, { id: `row_${i}`, component: 'Row', children: [`command_${i}`, `description_${i}`] }, { id: `command_${i}`, component: 'Text', text: r.title }, { id: `description_${i}`, component: 'Text', text: r.description }]), { id: 'footer', component: 'Text', text: String(d.footer ?? 'Powered by zervonex'), variant: 'caption' }]
+            if (buttons.length) { components.push({ id: 'buttonRow', component: 'Row', justify: 'spaceEvenly', children: buttons.flatMap((_, i) => [`buttonLabel_${i}`, `button_${i}`]) }); buttons.forEach((b, i) => { components.push({ id: `buttonLabel_${i}`, component: 'Text', text: b.label }); components.push({ id: `button_${i}`, component: 'Button', child: `buttonLabel_${i}`, variant: 'primary', action: { call: 'openUrl', args: { url: b.url } } }) }) }
             const surfaceId = `zervonex-a2ui-${crypto.randomUUID()}`
-            content = { interactiveMessage: { ...(d.imageMessage ? { header: { imageMessage: d.imageMessage, hasMediaAttachment: true } } : {}), bloksWidget: { type: 'im_a2ui', data: JSON.stringify([{ version: 'v0.9.1', createSurface: { surfaceId, root: 'root', catalogId: 'https://a2ui.org/specification/v0_9_1/catalogs/basic/catalog.json' } }, { version: 'v0.9.1', updateComponents: { surfaceId, components } }, { version: 'v0.9.1', updateDataModel: { surfaceId, value: { title: String(d.title ?? 'Menu'), footer: d.footer ?? 'Powered by zervonex', rows } } }]), fallback: String(d.fallback ?? d.title ?? '') }, nativeFlowMessage: { messageParamsJson: JSON.stringify({ limited_time_offer: { text: String(d.title ?? ''), url: buttons[0]?.url ?? '', copy_code: String(d.title ?? ''), expiration_time: Date.now() * 1000 } }), buttons: [{ name: 'single_select', buttonParamsJson: JSON.stringify({ title: String(d.title ?? ''), sections: [{ title: 'Available Commands', rows }] }) }] } } }
+            let cmdHeader = { hasMediaAttachment: false }
+            if (d.imageMessage) cmdHeader = { imageMessage: d.imageMessage, hasMediaAttachment: true }
+            else if (d.image) { const { url } = await A2UI.#resolveImage(d.image, upload); cmdHeader = { imageMessage: { url }, hasMediaAttachment: true } }
+            content = { interactiveMessage: { header: cmdHeader, body: { text: d.body ?? d.text ?? '\u200b' }, bloksWidget: { uuid: surfaceId, type: 'im_a2ui', data: A2UI.surface(components, { surfaceId }), fallback: String(d.fallback ?? d.title ?? '') }, nativeFlowMessage: { messageParamsJson: JSON.stringify({ limited_time_offer: { text: String(d.title ?? ''), url: buttons[0]?.url ?? '', copy_code: String(d.title ?? ''), expiration_time: Date.now() * 1000 } }), buttons: [{ name: 'single_select', buttonParamsJson: JSON.stringify({ title: String(d.title ?? ''), sections: [{ title: 'Available Commands', rows }] }) }], messageVersion: 1 } } }
         } else {
-            // generic A2UI envelope
-            const { imageMessage, bloksWidget = {}, nativeFlowMessage, fallback = '', ...rest } = d
-            content = { interactiveMessage: { ...rest, ...(imageMessage ? { header: { imageMessage, hasMediaAttachment: true } } : {}), bloksWidget: { type: bloksWidget.type ?? 'im_a2ui', data: typeof bloksWidget.data === 'string' ? bloksWidget.data : JSON.stringify(bloksWidget.data ?? {}), ...(bloksWidget.fallback || fallback ? { fallback: String(bloksWidget.fallback ?? fallback) } : {}) }, ...(nativeFlowMessage ? { nativeFlowMessage: { ...nativeFlowMessage, ...(nativeFlowMessage.buttons ? { buttons: nativeFlowMessage.buttons } : {}) } } : {}) } }
+            const { imageMessage, image, bloksWidget = {}, nativeFlowMessage, fallback = '', ...rest } = d
+            let elseHeader = { hasMediaAttachment: false }
+            if (imageMessage) elseHeader = { imageMessage, hasMediaAttachment: true }
+            else if (image) { const { url } = await A2UI.#resolveImage(image, upload); elseHeader = { imageMessage: { url }, hasMediaAttachment: true } }
+            content = { interactiveMessage: { ...rest, header: elseHeader, body: { text: d.body ?? d.text ?? '\u200b' }, bloksWidget: { uuid: bloksWidget.uuid ?? crypto.randomUUID(), type: bloksWidget.type ?? 'im_a2ui', data: Buffer.isBuffer(bloksWidget.data) ? bloksWidget.data : Buffer.from(typeof bloksWidget.data === 'string' ? bloksWidget.data : JSON.stringify(bloksWidget.data ?? {}), 'utf8'), ...(bloksWidget.fallback || fallback ? { fallback: String(bloksWidget.fallback ?? fallback) } : {}) }, ...(nativeFlowMessage ? { nativeFlowMessage: { ...nativeFlowMessage, messageVersion: nativeFlowMessage.messageVersion ?? 1 } } : {}) } }
         }
-        const msg = await await generateWAMessageFromContent(jid, content, { userJid: this.client.user?.id, waUploadToServer: this.client.waUploadToServer })
+        const msg = await generateWAMessageFromContent(jid, content, { userJid: this.client.user?.id, waUploadToServer: upload })
         const bizNode = getBizBinaryNode(msg.message)
         await this.client.relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes: bizNode ? [bizNode] : [] })
         return msg

package/lib/Defaults/index.js

@@ -208,6 +208,10 @@ export const INITIAL_PREKEY_COUNT = 95;
 export const UPLOAD_TIMEOUT = 30000;
 export const MIN_UPLOAD_INTERVAL = 5000;
 export const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120000;
+export const DEFAULT_PREKEY_RETENTION = 150
+export const DEFAULT_CLEANUP_THRESHOLD = 50
+export const CLEANUP_INTERVAL_MS = 10 * 60 * 1000
+export const DEFAULT_COLLECTION_NAME = 'zervonex'
 export const DEFAULT_CACHE_TTLS = {
     SIGNAL_STORE: 5 * 60,
     MSG_RETRY: 60 * 60,

package/lib/Socket/spam-report.js

@@ -1,55 +1,130 @@
 import { createReportingInfoStore } from '../Store/index.js'
-import { SPAM_FLOWS, resolveReportJid, normalizeReportingTag, buildSpamReportIq, buildSimpleReportNode, parseSpamReportResponse } from '../Utils/index.js'
+import { SPAM_FLOWS, REPORT_REASON_CODES, resolveReportContext, buildSpamReportIq, buildSimpleReportNode, parseSpamReportResponse } from '../Utils/index.js'
 import { isJidGroup, isPnUser, isLidUser, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js'
 
 export const makeSpamReportSocket = (sock, config) => {
-    const { query, signalRepository, updateBlockStatus, logger } = sock
+    const { query, generateMessageTag, signalRepository, logger } = sock
+    const store = config.reportingInfoStore ?? createReportingInfoStore()
 
-    if (!config.reportingInfoStore) config.reportingInfoStore = createReportingInfoStore()
-    const store = config.reportingInfoStore
+    if (!signalRepository?.lidMapping) logger?.warn?.({}, 'makeSpamReportSocket: signalRepository.lidMapping unavailable — LID resolution disabled')
 
     const simpleReportQuery = (jid, messageKeys) => query({
         tag: 'iq',
         attrs: { type: 'set', xmlns: 'spam', to: S_WHATSAPP_NET },
-        content: [buildSimpleReportNode(jid, messageKeys)]
+        content: [buildSimpleReportNode(jid, messageKeys)],
     })
 
+    const wReportQuery = async (node, label, meta, waitForAckMs = 5000) => {
+        try {
+            await query(node, waitForAckMs)
+            logger?.info?.(meta, `${label} (ack received)`)
+            return true
+        } catch (err) {
+            const code = err?.output?.statusCode || err?.statusCode
+            if (code === 408 || err?.message?.toLowerCase?.().includes('timed out')) {
+                logger?.warn?.(meta, `${label} (no ack; request likely sent)`)
+                return false
+            }
+            throw err
+        }
+    }
+
+    const resolveToPN = async jid => {
+        if (!isLidUser(jid)) return jidNormalizedUser(jid)
+        const pn = await signalRepository?.lidMapping?.getPNForLID?.(jid)
+        if (!pn) {
+            logger?.error?.({ jid }, 'resolveToPN: could not resolve LID to PN')
+            throw new Error(`resolveToPN: no PN found for LID ${jid}`)
+        }
+        logger?.debug?.({ lid: jid, pn }, 'resolveToPN: resolved LID → PN')
+        return jidNormalizedUser(pn)
+    }
+
     const reportSpam = async (jid, options = {}) => {
-        const { spamFlow = SPAM_FLOWS.ACCOUNT_INFO_REPORT, messages: manualMessages, maxMessages = 5 } = options
-        const reportJid = await resolveReportJid(jid, signalRepository?.lidMapping)
+        const { spamFlow: manualFlow, messages: manualMessages, maxMessages = 5 } = options
+        const { reportJid, spamFlow: autoFlow, isGroup } = await resolveReportContext(jid, signalRepository?.lidMapping)
+        const spamFlow = manualFlow ?? autoFlow
         let messages = manualMessages
         if (!messages?.length) {
             messages = store.getForJid(reportJid, maxMessages)
-            if (!messages.length) messages = store.getForJid(jid, maxMessages)
+            if (!messages.length && !isGroup) {
+                messages = store.getForJid(jid, maxMessages)
+                if (messages.length) logger?.debug?.({ jid, reportJid }, 'reportSpam: fell back to raw JID for store lookup')
+            }
+        }
+        if (!messages?.length) {
+            logger?.error?.({ jid, reportJid }, 'reportSpam: no reporting_tag stored — receive at least one message first')
+            throw new Error(`reportSpam: no reporting_tag stored for ${jid}`)
         }
-        if (!messages?.length) throw new Error(`reportSpam: no reporting_tag stored for ${jid}. Receive at least one message first.`)
         const normalized = messages.slice(0, maxMessages).map(m => ({
             stanzaId: m.stanzaId || m.id,
-            timestamp: Number(m.timestamp || m.sendTimestamp || m.t),
-            reportingTag: normalizeReportingTag(m.reportingTag || m.tag),
-            text: m.text ?? m.raw ?? '',
+            timestamp: Number(m.timestamp || m.sendTimestamp || m.t) || Math.floor(Date.now() / 1000),
+            reportingTag: m.reportingTag || m.tag,
+            text: m.text != null ? String(m.text) : m.raw != null ? String(m.raw) : '',
             pushName: m.pushName || m.reportedPushName || '',
             messageType: m.messageType || m.type || 'text',
-            fromJid: m.fromJid || m.from || reportJid
+            fromJid: m.fromJid || m.from || reportJid,
         }))
-        logger?.debug?.({ jid: reportJid, spamFlow, count: normalized.length }, 'sending spam report IQ')
-        const result = await query(buildSpamReportIq(reportJid, normalized, spamFlow))
+        logger?.debug?.({ jid: reportJid, spamFlow, count: normalized.length }, 'reportSpam: raw sending IQ')
+        const result = await query(buildSpamReportIq(reportJid, normalized, spamFlow, logger))
         return { ...parseSpamReportResponse(result), messageCount: normalized.length }
     }
 
     const reportContact = async (jid, messageKeys = []) => {
-        const normalized = jidNormalizedUser(jid)
-        if (!isPnUser(normalized) && !isLidUser(normalized)) throw new Error('reportContact requires a valid contact JID')
-        const result = await simpleReportQuery(normalized, messageKeys)
-        await updateBlockStatus(normalized, 'block')
-        return parseSpamReportResponse(result)
+        if (!isPnUser(jid) && !isLidUser(jid)) {
+            logger?.error?.({ jid }, 'reportContact: invalid contact JID')
+            throw new Error('reportContact requires a valid contact JID')
+        }
+        const pnJid = await resolveToPN(jid)
+        return parseSpamReportResponse(await simpleReportQuery(pnJid, messageKeys))
     }
 
     const reportGroup = async (jid, messageKeys = []) => {
-        if (!isJidGroup(jid)) throw new Error('reportGroup requires a valid group JID')
-        const result = await simpleReportQuery(jid, messageKeys)
-        await query({ tag: 'iq', attrs: { type: 'set', xmlns: 'w:g2', to: '@g.us' }, content: [{ tag: 'leave', attrs: {}, content: [{ tag: 'group', attrs: { id: jid } }] }] })
-        return parseSpamReportResponse(result)
+        if (!isJidGroup(jid)) {
+            logger?.error?.({ jid }, 'reportGroup: invalid group JID')
+            throw new Error('reportGroup requires a valid group JID')
+        }
+        const parsed = parseSpamReportResponse(await simpleReportQuery(jid, messageKeys))
+        if (parsed.success) {
+            try {
+                await query({ tag: 'iq', attrs: { type: 'set', xmlns: 'w:g2', to: '@g.us' }, content: [{ tag: 'leave', attrs: {}, content: [{ tag: 'group', attrs: { id: jid } }] }] })
+                logger?.info?.({ jid }, 'reportGroup: left group after successful report')
+            } catch (err) {
+                logger?.warn?.({ jid, err: err?.message }, 'reportGroup: leave failed after successful report')
+            }
+        }
+        return parsed
+    }
+
+    const reportUser = async (jid, reason = 'spam', waitForAckMs = 5000) => {
+        const pnJid = await resolveToPN(jid)
+        return wReportQuery(
+            { tag: 'iq', attrs: { id: generateMessageTag(), xmlns: 'w:report', to: 's.whatsapp.net', type: 'set' }, content: [{ tag: 'user', attrs: { jid: pnJid, reason: String(REPORT_REASON_CODES[reason] ?? 1) } }] },
+            'reported user', { jid: pnJid, reason }, waitForAckMs,
+        )
+    }
+
+    const reportMessage = async (jid, messageId, reason = 'spam', participantJid, waitForAckMs = 5000) => {
+        const pnJid = await resolveToPN(jid)
+        const participant = participantJid ? await resolveToPN(participantJid) : undefined
+        const attrs = { id: String(messageId), reason: String(REPORT_REASON_CODES[reason] ?? 1), ...(participant ? { participant } : {}) }
+        return wReportQuery(
+            { tag: 'iq', attrs: { id: generateMessageTag(), xmlns: 'w:report', to: 's.whatsapp.net', type: 'set' }, content: [{ tag: 'message', attrs }] },
+            'reported message', { jid: pnJid, messageId, reason, participant }, waitForAckMs,
+        )
+    }
+
+    const reportAndBlockUser = async (jid, reason = 'spam', options = {}) => {
+        const { waitForAckMs = 5000, maxAttempts = 4, delayMs = 1500 } = options
+        const pnJid = await resolveToPN(jid)
+        let attempts = 0
+        while (attempts < maxAttempts) {
+            await reportUser(pnJid, reason, waitForAckMs)
+            attempts++
+            logger?.debug?.({ jid: pnJid, attempts }, 'reportAndBlockUser: attempt sent')
+            await new Promise(r => setTimeout(r, delayMs))
+        }
+        return { attempts }
     }
 
     return {
@@ -57,9 +132,13 @@ export const makeSpamReportSocket = (sock, config) => {
         reportSpam,
         reportContact,
         reportGroup,
+        reportUser,
+        reportMessage,
+        reportAndBlockUser,
         getStoredReportingInfo: (jid, max = 5) => store.getForJid(jid, max),
         clearStoredReportingInfo: jid => store.clear(jid),
         reportingInfoStore: store,
-        SPAM_FLOWS
+        SPAM_FLOWS,
+        REPORT_REASON_CODES,
     }
 }