@zervonex/baileys 0.0.0-stage → 3.0.1

package/lib/Utils/meta-ai-msmsg.js

@@ -0,0 +1,122 @@
+import { hkdf, aesDecryptGCM } from './crypto.js'
+import { unpadRandomMax16 } from './generics.js'
+import { jidNormalizedUser } from '../WABinary/index.js'
+import { proto } from '../../WAProto/index.js'
+
+const BOT_MESSAGE_INFO = 'Bot Message'
+const KEY_LENGTH = 32
+const AUTH_TAG_LENGTH = 16
+const MSG_ID_HEX_RE = /^[0-9A-Fa-f]{32}$/
+
+const toBuffer = value => {
+    if (Buffer.isBuffer(value)) return value
+    if (value instanceof Uint8Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength)
+    return Buffer.from(value)
+}
+
+const buildMessageIdRepresentations = messageId => {
+    const ascii = Buffer.from(messageId)
+    const binary = MSG_ID_HEX_RE.test(messageId) ? Buffer.from(messageId, 'hex') : ascii
+    return [{ label: 'msgIdAscii', value: ascii }, ...(binary.equals(ascii) ? [] : [{ label: 'msgIdBinary', value: binary }])]
+}
+
+const pushUnique = (items, seen, item) => {
+    const key = JSON.stringify([item.messageId, item.idSource, item.idSources, item.infoSource, item.aadSource, item.info.toString('hex'), item.aad.toString('hex')])
+    if (!seen.has(key)) { seen.add(key); items.push(item) }
+}
+
+const getCandidateIds = messageKey => {
+    const ordered = [
+        messageKey?.botType === 'full' ? { source: 'stanzaId', messageId: messageKey?.stanzaId } : { source: 'botEditTargetId', messageId: messageKey?.botEditTargetId },
+        { source: 'targetId', messageId: messageKey?.targetId },
+        { source: 'metaTargetId', messageId: messageKey?.metaTargetId },
+        { source: 'stanzaId', messageId: messageKey?.stanzaId },
+    ]
+    const candidates = Array.isArray(messageKey?.targetIdCandidates) ? messageKey.targetIdCandidates : []
+    for (let i = 0; i < candidates.length; i++) ordered.push({ source: `targetIdCandidates[${i}]`, messageId: candidates[i] })
+    const grouped = new Map()
+    for (const c of ordered) {
+        if (!c.messageId) continue
+        const id = String(c.messageId)
+        const existing = grouped.get(id)
+        if (existing) { if (!existing.idSources.includes(c.source)) existing.idSources.push(c.source) }
+        else grouped.set(id, { messageId: id, idSource: c.source, idSources: [c.source] })
+    }
+    return Array.from(grouped.values())
+}
+
+const getJidCandidates = messageKey => {
+    const ordered = [
+        { source: 'meId', jid: messageKey?.meId },
+        { source: 'conversationJid', jid: messageKey?.conversationJid },
+        { source: 'senderJid', jid: messageKey?.senderJid },
+        { source: 'meLidNormalized', jid: jidNormalizedUser(messageKey?.meLid) },
+    ]
+    const seen = new Set()
+    const result = []
+    for (const c of ordered) {
+        if (!c.jid) continue
+        const jid = String(c.jid)
+        if (!seen.has(jid)) { seen.add(jid); result.push({ source: c.source, jid, value: Buffer.from(jid) }) }
+    }
+    return result
+}
+
+const buildMsmsgDecryptionStrategies = messageKey => {
+    const botJid = String(messageKey?.participant || '')
+    const botJidBuffer = Buffer.from(botJid)
+    const targetIds = getCandidateIds(messageKey)
+    const jidCandidates = getJidCandidates(messageKey)
+    const primaryJid = jidCandidates[0]
+    const alternateJid = jidCandidates.find(c => c.source !== primaryJid?.source && c.jid !== botJid)
+    const strategies = [], seen = new Set()
+    for (const idCandidate of targetIds) {
+        for (const idForm of buildMessageIdRepresentations(idCandidate.messageId)) {
+            pushUnique(strategies, seen, { mode: '2step', idSource: idCandidate.idSource, idSources: idCandidate.idSources, infoSource: `${idForm.label}+meId+botJid`, aadSource: `${idForm.label}+0+botJid`, authTagLayout: 'trailing', messageId: idCandidate.messageId, info: Buffer.concat([idForm.value, primaryJid.value, botJidBuffer, Buffer.alloc(0)]), aad: Buffer.concat([idForm.value, Buffer.from([0]), botJidBuffer]), attemptLabel: `${idCandidate.idSource}:${idForm.label}:primary` })
+            if (alternateJid) pushUnique(strategies, seen, { mode: '2step', idSource: idCandidate.idSource, idSources: idCandidate.idSources, infoSource: `${idForm.label}+${alternateJid.source}+botJid`, aadSource: `${idForm.label}+0+${alternateJid.source}`, authTagLayout: 'trailing', messageId: idCandidate.messageId, info: Buffer.concat([idForm.value, alternateJid.value, botJidBuffer, Buffer.alloc(0)]), aad: Buffer.concat([idForm.value, Buffer.from([0]), alternateJid.value]), attemptLabel: `${idCandidate.idSource}:${idForm.label}:${alternateJid.source}` })
+        }
+    }
+    return strategies.slice(0, 12)
+}
+
+const assertRequired = (value, label) => {
+    if (!value || (Buffer.isBuffer(value) && value.length === 0) || (value instanceof Uint8Array && value.byteLength === 0)) throw new Error(`Missing required ${label} for msmsg decryption`)
+}
+
+const decryptWithStrategy = (messageSecret, msMsg, strategy) => {
+    const baseSecret = Buffer.from(hkdf(toBuffer(messageSecret), KEY_LENGTH, { info: BOT_MESSAGE_INFO }))
+    const key = Buffer.from(hkdf(baseSecret, KEY_LENGTH, { info: strategy.info }))
+    const payload = toBuffer(msMsg.encPayload)
+    const ciphertextWithTag = Buffer.concat([payload.slice(0, -AUTH_TAG_LENGTH), payload.slice(-AUTH_TAG_LENGTH)])
+    return Buffer.from(aesDecryptGCM(ciphertextWithTag, key, toBuffer(msMsg.encIv), strategy.aad))
+}
+
+export const decodeDecryptedMsmsgMessage = decrypted => {
+    const messageBuffer = toBuffer(decrypted)
+    try {
+        const unpadded = Buffer.from(unpadRandomMax16(messageBuffer))
+        const decoded = proto.Message.decode(unpadded)
+        if (Object.keys(decoded).some(key => key !== 'messageContextInfo' && decoded[key] != null)) return decoded
+    } catch { }
+    return proto.Message.decode(messageBuffer)
+}
+
+export const decryptMsmsgBotMessage = async (messageSecret, messageKey, msMsg) => {
+    assertRequired(messageSecret, 'messageSecret')
+    assertRequired(messageKey?.participant, 'participant')
+    assertRequired(messageKey?.meId, 'meId')
+    assertRequired(msMsg?.encIv, 'encIv')
+    assertRequired(msMsg?.encPayload, 'encPayload')
+    if (getCandidateIds(messageKey).length === 0) throw new Error('Missing required target message id for msmsg decryption')
+    const strategies = buildMsmsgDecryptionStrategies(messageKey)
+    const attemptedStrategies = []
+    let lastError
+    for (const strategy of strategies) {
+        try { return decryptWithStrategy(messageSecret, msMsg, strategy) }
+        catch (error) { attemptedStrategies.push({ idSource: strategy.idSource, idSources: strategy.idSources, infoSource: strategy.infoSource, aadSource: strategy.aadSource, messageId: strategy.messageId }); lastError = error }
+    }
+    const error = new Error('Failed to decrypt msmsg with bounded deterministic strategies')
+    error.attemptedStrategies = attemptedStrategies
+    error.cause = lastError
+    throw error
+}

package/lib/Utils/meta-compositing.js

@@ -0,0 +1,75 @@
+import { proto } from '../../WAProto/index.js'
+import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js'
+import { BotCapabilityType, buildBotCapabilityMetadata } from './bot-capabilities.js'
+import { delay } from './generics.js'
+
+export const PlanningStepStatus = { IN_PROGRESS: 0, DONE: 1, FAILED: 2 }
+
+export const buildProgressIndicator = (description, steps = [], estimatedMs) => {
+    const stepsMetadata = steps.map(s => {
+        const m = { statusTitle: s.title, status: s.status ?? PlanningStepStatus.IN_PROGRESS }
+        if (s.body) m.statusBody = s.body
+        if (s.isReasoning) m.isReasoning = true
+        if (s.isEnhancedSearch) m.isEnhancedSearch = true
+        return m
+    })
+    const indicator = { stepsMetadata }
+    if (description) indicator.progressDescription = description
+    if (estimatedMs != null) indicator.estimatedCompletionTime = estimatedMs
+    return indicator
+}
+
+export const buildCompositingPlaceholder = ({ description = 'Thinking…', steps = [], estimatedMs, placeholderText = '', verificationMetadata } = {}) => {
+    const progressIndicatorMetadata = buildProgressIndicator(description, steps, estimatedMs)
+    const unifiedData = new TextEncoder().encode(JSON.stringify({
+        response_id: crypto.randomUUID(),
+        sections: placeholderText ? [{ view_model: { primitive: { text: placeholderText, inline_entities: [], __typename: 'GenAIMarkdownTextUXPrimitive' }, __typename: 'GenAISingleLayoutViewModel' } }] : []
+    }))
+    const capabilities = [BotCapabilityType.PROGRESS_INDICATOR, ...(steps.length ? [BotCapabilityType.AGENTIC_PLANNING] : [])]
+    return {
+        messageContextInfo: {
+            botMetadata: {
+                capabilityMetadata: buildBotCapabilityMetadata(capabilities),
+                pluginMetadata: {},
+                progressIndicatorMetadata,
+                botRenderingConfigMetadata: BOT_RENDERING_CONFIG_METADATA,
+                ...(verificationMetadata ? { verificationMetadata } : {}),
+            }
+        },
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+                    unifiedResponse: { data: unifiedData },
+                    submessages: [],
+                }
+            }
+        }
+    }
+}
+
+export const buildPlainPlaceholder = (description = 'Thinking…', steps = [], placeholderText = '') => {
+    const lines = steps.map(s => {
+        const icon = s.status === PlanningStepStatus.DONE ? '✓' : s.status === PlanningStepStatus.FAILED ? '✗' : '○'
+        return `${icon} ${s.title}`
+    }).join('\n')
+    let text = `_${description}_`
+    if (lines) text += `\n\n${lines}`
+    if (placeholderText) text += `\n\n${placeholderText}`
+    return { text }
+}
+
+export const metaTyping = async (sock, jid, { description = 'Thinking…', steps = [], estimatedMs, placeholderText = '' } = {}) => {
+    await sock.sendPresenceUpdate('composing', jid)
+    const pending = steps.map(s => ({ ...s, status: PlanningStepStatus.IN_PROGRESS }))
+    return sock.sendMessage(jid, buildPlainPlaceholder(description, pending, placeholderText))
+}
+
+export const sendMetaComposited = async (sock, jid, content, { thinkingMs = 2000, description = 'Thinking…', steps = [], placeholderText = '', sendOptions = {} } = {}) => {
+    const placeholder = await metaTyping(sock, jid, { description, steps, estimatedMs: thinkingMs, placeholderText })
+    try { await delay(thinkingMs); if (placeholder?.key) await sock.sendMessage(jid, { delete: placeholder.key }) } catch (_) { }
+    await sock.sendPresenceUpdate('paused', jid)
+    return sock.sendMessage(jid, content, sendOptions)
+}
+
+export const buildSteps = (titles, status = PlanningStepStatus.IN_PROGRESS) => titles.map(title => ({ title, status }))

package/lib/Utils/modern-messages.js

@@ -0,0 +1,235 @@
+import { proto } from '../../WAProto/index.js'
+
+const requireObject = (value, name) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError(`${name} must be an object`)
+    return value
+}
+
+const requireKey = (value, name = 'key') => {
+    requireObject(value, name)
+    if (!value.id) throw new TypeError(`${name}.id is required`)
+    return value
+}
+
+const enumValue = (enumObject, value, fallback) => {
+    if (typeof value === 'number') return value
+    if (typeof value === 'string') { const key = value.trim().toUpperCase(); if (key in enumObject) return enumObject[key] }
+    return fallback
+}
+
+export const STATUS_NOTIFICATION_TYPES = Object.freeze({ ...proto.Message.StatusNotificationMessage.StatusNotificationType, STATUS_GROUP_STATUS_REPLY: 4 })
+
+const toSeconds = value => value instanceof Date ? Math.floor(value.getTime() / 1000) : value
+const toMilliseconds = value => value instanceof Date ? value.getTime() : value
+
+const makeInnerCommentMessage = content => {
+    const data = requireObject(content, 'comment.content')
+    if (data.raw && typeof data.raw === 'object') return data.raw
+    if (typeof data.text === 'string') return { extendedTextMessage: proto.Message.ExtendedTextMessage.create({ text: data.text, contextInfo: data.contextInfo }) }
+    const keys = Object.keys(data)
+    if (keys.some(key => key.endsWith('Message'))) return data
+    throw new TypeError('comment.content supports text, raw, or protobuf message fields')
+}
+
+export const makeQuestionMessage = input => {
+    const data = requireObject(input, 'question')
+    if (typeof data.text !== 'string' || !data.text.length) throw new TypeError('question.text is required')
+    return { questionMessage: proto.Message.FutureProofMessage.create({ message: { extendedTextMessage: proto.Message.ExtendedTextMessage.create({ text: data.text, contextInfo: { ...(data.contextInfo || {}), isQuestion: true } }) } }) }
+}
+
+export const makeQuestionResponseMessage = input => {
+    const data = requireObject(input, 'questionResponse')
+    requireKey(data.key, 'questionResponse.key')
+    return { questionResponseMessage: proto.Message.QuestionResponseMessage.create({ key: data.key, text: data.text ?? '' }) }
+}
+
+export const makeQuestionReplyMessage = input => {
+    const data = requireObject(input, 'questionReply')
+    if (typeof data.text !== 'string' || !data.text.length) throw new TypeError('questionReply.text is required')
+    if (data.serverQuestionId === undefined || data.serverQuestionId === null) throw new TypeError('questionReply.serverQuestionId is required')
+    const quoted = { serverQuestionId: Number(data.serverQuestionId) }
+    if (data.quotedQuestion) quoted.quotedQuestion = data.quotedQuestion
+    if (data.quotedResponse) quoted.quotedResponse = data.quotedResponse
+    return { questionReplyMessage: proto.Message.FutureProofMessage.create({ message: { extendedTextMessage: proto.Message.ExtendedTextMessage.create({ text: data.text, contextInfo: { ...(data.contextInfo || {}), questionReplyQuotedMessage: quoted } }) } }) }
+}
+
+export const makeStatusQuestionAnswerMessage = input => {
+    const data = requireObject(input, 'statusQuestionAnswer')
+    requireKey(data.key, 'statusQuestionAnswer.key')
+    return { statusQuestionAnswerMessage: proto.Message.StatusQuestionAnswerMessage.create({ key: data.key, text: data.text ?? '' }) }
+}
+
+export const makeStatusQuotedMessage = input => {
+    const data = requireObject(input, 'statusQuoted')
+    requireKey(data.originalStatusId, 'statusQuoted.originalStatusId')
+    const type = enumValue(proto.Message.StatusQuotedMessage.StatusQuotedMessageType, data.type, proto.Message.StatusQuotedMessage.StatusQuotedMessageType.QUESTION_ANSWER)
+    return { statusQuotedMessage: proto.Message.StatusQuotedMessage.create({ type, text: data.text, thumbnail: data.thumbnail, originalStatusId: data.originalStatusId }) }
+}
+
+export const makeStatusStickerInteractionMessage = input => {
+    const data = requireObject(input, 'statusStickerInteraction')
+    requireKey(data.key, 'statusStickerInteraction.key')
+    if (!data.stickerKey) throw new TypeError('statusStickerInteraction.stickerKey is required')
+    const type = enumValue(proto.Message.StatusStickerInteractionMessage.StatusStickerType, data.type, proto.Message.StatusStickerInteractionMessage.StatusStickerType.REACTION)
+    return { statusStickerInteractionMessage: proto.Message.StatusStickerInteractionMessage.create({ key: data.key, stickerKey: data.stickerKey, type }) }
+}
+
+export const makeStatusNotificationMessage = input => {
+    const data = requireObject(input, 'statusNotification')
+    requireKey(data.responseMessageKey, 'statusNotification.responseMessageKey')
+    requireKey(data.originalMessageKey, 'statusNotification.originalMessageKey')
+    const type = enumValue(STATUS_NOTIFICATION_TYPES, data.type, STATUS_NOTIFICATION_TYPES.UNKNOWN)
+    return { statusNotificationMessage: proto.Message.StatusNotificationMessage.create({ responseMessageKey: data.responseMessageKey, originalMessageKey: data.originalMessageKey, type }) }
+}
+
+export const makeNewsletterAdminInviteMessage = input => {
+    const data = requireObject(input, 'newsletterAdminInvite')
+    if (!data.newsletterJid) throw new TypeError('newsletterAdminInvite.newsletterJid is required')
+    return { newsletterAdminInviteMessage: proto.Message.NewsletterAdminInviteMessage.create({ newsletterJid: data.newsletterJid, newsletterName: data.newsletterName, jpegThumbnail: data.jpegThumbnail, caption: data.caption, inviteExpiration: data.inviteExpiration, contextInfo: data.contextInfo }) }
+}
+
+export const makeNewsletterFollowerInviteMessage = input => {
+    const data = requireObject(input, 'newsletterFollowerInvite')
+    if (!data.newsletterJid) throw new TypeError('newsletterFollowerInvite.newsletterJid is required')
+    return { newsletterFollowerInviteMessageV2: proto.Message.NewsletterFollowerInviteMessage.create({ newsletterJid: data.newsletterJid, newsletterName: data.newsletterName, jpegThumbnail: data.jpegThumbnail, caption: data.caption, contextInfo: data.contextInfo }) }
+}
+
+export const makePollAddOptionMessage = input => {
+    const data = requireObject(input, 'pollAddOption')
+    requireKey(data.pollCreationMessageKey, 'pollAddOption.pollCreationMessageKey')
+    const addOption = typeof data.option === 'string' ? { optionName: data.option } : data.addOption || data.option
+    if (!addOption?.optionName) throw new TypeError('pollAddOption.option is required')
+    return { pollAddOptionMessage: proto.Message.PollAddOptionMessage.create({ pollCreationMessageKey: data.pollCreationMessageKey, addOption, metadata: data.metadata }) }
+}
+
+export const makeCommentMessage = input => {
+    const data = requireObject(input, 'comment')
+    requireKey(data.targetMessageKey, 'comment.targetMessageKey')
+    const message = data.message || (data.content ? makeInnerCommentMessage(data.content) : null)
+    requireObject(message, 'comment.message')
+    return { commentMessage: proto.Message.CommentMessage.create({ message, targetMessageKey: data.targetMessageKey }) }
+}
+
+export const makeEventInviteMessage = input => {
+    const data = requireObject(input, 'eventInvite')
+    if (!data.eventId) throw new TypeError('eventInvite.eventId is required')
+    return { eventInviteMessage: proto.Message.EventInviteMessage.create({ contextInfo: data.contextInfo, eventId: data.eventId, eventTitle: data.eventTitle, jpegThumbnail: data.jpegThumbnail, startTime: toSeconds(data.startTime), caption: data.caption, isCanceled: data.isCanceled, endTime: toSeconds(data.endTime), callLink: data.callLink }) }
+}
+
+export const makeScheduledCallCreationMessage = input => {
+    const data = requireObject(input, 'scheduledCall')
+    if (!data.scheduledTimestampMs) throw new TypeError('scheduledCall.scheduledTimestampMs is required')
+    const callType = enumValue(proto.Message.ScheduledCallCreationMessage.CallType, data.callType, proto.Message.ScheduledCallCreationMessage.CallType.UNKNOWN)
+    return { scheduledCallCreationMessage: proto.Message.ScheduledCallCreationMessage.create({ scheduledTimestampMs: toMilliseconds(data.scheduledTimestampMs), callType, title: data.title }) }
+}
+
+export const makeScheduledCallEditMessage = input => {
+    const data = requireObject(input, 'scheduledCallEdit')
+    requireKey(data.key, 'scheduledCallEdit.key')
+    const editType = enumValue(proto.Message.ScheduledCallEditMessage.EditType, data.editType, proto.Message.ScheduledCallEditMessage.EditType.CANCEL)
+    return { scheduledCallEditMessage: proto.Message.ScheduledCallEditMessage.create({ key: data.key, editType }) }
+}
+
+export const makeGroupStatusReactionMessage = input => {
+    const data = requireObject(input, 'groupStatusReaction')
+    requireKey(data.key, 'groupStatusReaction.key')
+    return { groupStatusMessageV2: proto.Message.FutureProofMessage.create({ message: { reactionMessage: proto.Message.ReactionMessage.create({ key: data.key, text: data.text ?? '', groupingKey: data.groupingKey, senderTimestampMs: data.senderTimestampMs || Date.now() }) } }) }
+}
+
+export const makeNewsletterStatusAttribution = input => {
+    const data = requireObject(input, 'newsletterStatus')
+    if (!data.newsletterJid) throw new TypeError('newsletterStatus.newsletterJid is required')
+    if (data.messageId === undefined || data.messageId === null) throw new TypeError('newsletterStatus.messageId is required')
+    return proto.StatusAttribution.create({ type: proto.StatusAttribution.Type.NEWSLETTER_STATUS, actionUrl: data.actionUrl, statusReshare: { source: proto.StatusAttribution.StatusReshare.Source.CHANNEL_RESHARE, metadata: { duration: data.duration, channelJid: data.newsletterJid, channelMessageId: Number(data.messageId), hasMultipleReshares: data.hasMultipleReshares ?? false } } })
+}
+
+export const makeGroupStatusAttribution = input => {
+    const data = requireObject(input, 'groupStatusAttribution')
+    if (!data.authorJid) throw new TypeError('groupStatusAttribution.authorJid is required')
+    return proto.StatusAttribution.create({ type: proto.StatusAttribution.Type.GROUP_STATUS, actionUrl: data.actionUrl, groupStatus: { authorJid: data.authorJid } })
+}
+
+export const STATUS_AUDIENCE_DEFAULT_LIST_NAME = 'Close friends'
+export const STATUS_AUDIENCE_DEFAULT_EMOJI = '⭐'
+
+export const makeStatusAudienceMetadata = input => {
+    const data = typeof input === 'string' ? { listName: input } : requireObject(input, 'statusAudience')
+    const audienceType = enumValue(proto.ContextInfo.StatusAudienceMetadata.AudienceType, data.audienceType, proto.ContextInfo.StatusAudienceMetadata.AudienceType.CLOSE_FRIENDS)
+    const listName = data.listName === undefined ? STATUS_AUDIENCE_DEFAULT_LIST_NAME : String(data.listName)
+    const listEmoji = data.listEmoji === undefined ? STATUS_AUDIENCE_DEFAULT_EMOJI : String(data.listEmoji)
+    return proto.ContextInfo.StatusAudienceMetadata.create({ audienceType, listName, listEmoji })
+}
+
+export const makeMessageAssociation = input => {
+    const data = requireObject(input, 'messageAssociation')
+    const parentMessageKey = data.parentMessageKey ?? data.key
+    requireKey(parentMessageKey, 'messageAssociation.parentMessageKey')
+    const associationType = enumValue(proto.MessageAssociation.AssociationType, data.associationType ?? data.type, proto.MessageAssociation.AssociationType.UNKNOWN)
+    return proto.MessageAssociation.create({ associationType, parentMessageKey, messageIndex: data.messageIndex })
+}
+
+export const makeStatusAddYoursAssociation = input => {
+    const data = input && typeof input === 'object' && !Array.isArray(input) && input.id ? { key: input } : requireObject(input, 'addYours')
+    const parentMessageKey = data.key ?? data.parentMessageKey
+    requireKey(parentMessageKey, 'addYours.key')
+    const associationType = enumValue(proto.MessageAssociation.AssociationType, data.type ?? data.associationType, proto.MessageAssociation.AssociationType.STATUS_ADD_YOURS)
+    return proto.MessageAssociation.create({ associationType, parentMessageKey, messageIndex: data.messageIndex })
+}
+
+export const makeStatusMentionMessage = input => {
+    const data = requireObject(input, 'statusMention')
+    requireKey(data.key, 'statusMention.key')
+    const field = data.group ? 'groupStatusMentionMessage' : 'statusMentionMessage'
+    return { [field]: proto.Message.FutureProofMessage.create({ message: { protocolMessage: proto.Message.ProtocolMessage.create({ key: data.key, type: proto.Message.ProtocolMessage.Type.STATUS_MENTION_MESSAGE }) } }) }
+}
+
+const modernBuilders = [
+    ['question', makeQuestionMessage],
+    ['questionReply', makeQuestionReplyMessage],
+    ['questionResponse', makeQuestionResponseMessage],
+    ['statusQuestionAnswer', makeStatusQuestionAnswerMessage],
+    ['statusQuoted', makeStatusQuotedMessage],
+    ['statusStickerInteraction', makeStatusStickerInteractionMessage],
+    ['statusNotification', makeStatusNotificationMessage],
+    ['newsletterAdminInvite', makeNewsletterAdminInviteMessage],
+    ['newsletterFollowerInvite', makeNewsletterFollowerInviteMessage],
+    ['pollAddOption', makePollAddOptionMessage],
+    ['comment', makeCommentMessage],
+    ['eventInvite', makeEventInviteMessage],
+    ['scheduledCall', makeScheduledCallCreationMessage],
+    ['scheduledCallEdit', makeScheduledCallEditMessage],
+    ['groupStatusReaction', makeGroupStatusReactionMessage],
+    ['statusMention', makeStatusMentionMessage]
+]
+
+export const prepareModernMessageContent = content => {
+    if (!content || typeof content !== 'object' || Array.isArray(content)) return content
+    let output = { ...content }
+    const attributions = Array.isArray(output.contextInfo?.statusAttributions) ? [...output.contextInfo.statusAttributions] : []
+    if (output.newsletterStatus) { attributions.push(makeNewsletterStatusAttribution(output.newsletterStatus)); delete output.newsletterStatus }
+    if (output.groupStatusAttribution) { attributions.push(makeGroupStatusAttribution(output.groupStatusAttribution)); delete output.groupStatusAttribution }
+    if (Array.isArray(output.statusAttributions)) { attributions.push(...output.statusAttributions); delete output.statusAttributions }
+    const carried = []
+    const audience = output.statusAudience
+    if (audience !== undefined && audience !== null) {
+        carried.push('statusAudience')
+        output.contextInfo = { ...(output.contextInfo || {}), statusAudienceMetadata: makeStatusAudienceMetadata(audience) }
+        delete output.statusAudience
+    }
+    if (attributions.length) output.contextInfo = { ...(output.contextInfo || {}), statusAttributions: attributions }
+    if (output.addYours !== undefined && output.addYours !== null) {
+        carried.push('addYours')
+        output.messageAssociation = makeStatusAddYoursAssociation(output.addYours)
+        delete output.addYours
+    } else if (output.messageAssociation !== undefined && output.messageAssociation !== null) {
+        carried.push('messageAssociation')
+        output.messageAssociation = makeMessageAssociation(output.messageAssociation)
+    }
+    for (const [key, builder] of modernBuilders) {
+        if (output[key] !== undefined && output[key] !== null) {
+            if (carried.length) throw new TypeError(`${carried.join(' and ')} cannot be combined with ${key}: ${key} builds its own message and keeps no room for them. Build it with the low-level makers and generateWAMessageFromContent instead.`)
+            return { raw: true, ...builder(output[key]) }
+        }
+    }
+    return output
+}

package/lib/Utils/native-flow.js

@@ -0,0 +1,55 @@
+const parseJsonObject = v => {
+    if (!v) return {}
+    if (typeof v === 'object') return v
+    try { const p = JSON.parse(v); return p && typeof p === 'object' ? p : {} } catch { return {} }
+}
+
+export const parseNativeFlowResponse = message => {
+    const content = message?.message || message
+    const response = content?.interactiveResponseMessage?.nativeFlowResponseMessage || content?.nativeFlowResponseMessage
+    if (!response) return null
+    const params = parseJsonObject(response.paramsJson)
+    const actionPayload = params.flow_action_payload || params.flowActionPayload || {}
+    const data = params.data || params.response || params.form_data || params.formData || actionPayload.data || {}
+    return {
+        name: response.name || '',
+        version: response.version,
+        paramsJson: response.paramsJson || '',
+        params,
+        isFlow: response.name === 'galaxy_message' || response.name === 'flow' || !!(params.flow_id || params.flow_token || params.flow_message_version),
+        flowId: params.flow_id || params.flowId,
+        flowToken: params.flow_token || params.flowToken,
+        screen: params.screen || actionPayload.screen,
+        action: params.flow_action || params.flowAction || actionPayload.action,
+        actionPayload,
+        data,
+        buttonId: params.id || params.button_id || params.buttonId,
+        displayText: params.display_text || params.displayText,
+        raw: response,
+    }
+}
+
+export const parseWhatsAppFlowResponse = message => {
+    const response = parseNativeFlowResponse(message)
+    return response?.isFlow ? response : null
+}
+
+export const buildWhatsAppFlowButton = ({ flowId, flowToken, cta = 'Open form', action = 'navigate', actionPayload, mode = 'published', flowMessageVersion = '3', metadata, name = 'galaxy_message' } = {}) => {
+    if (!flowId) throw new TypeError('flowId is required')
+    if (!flowToken) throw new TypeError('flowToken is required')
+    return {
+        name,
+        flow_message_version: String(flowMessageVersion),
+        flow_token: String(flowToken),
+        flow_id: String(flowId),
+        flow_cta: String(cta),
+        flow_action: action,
+        ...(actionPayload ? { flow_action_payload: actionPayload } : {}),
+        ...(metadata ? { flow_metadata: metadata } : {}),
+    }
+}
+
+export const makeWhatsAppFlowButton = flow => ({
+    name: flow?.nativeFlowName || 'galaxy_message',
+    buttonParamsJson: JSON.stringify(buildWhatsAppFlowButton(flow)),
+})

package/lib/Utils/noise-handler.js

@@ -0,0 +1,161 @@
+import { Boom } from '@hapi/boom'
+import { proto } from '../../WAProto/index.js'
+import { NOISE_MODE, WA_CERT_DETAILS } from '../Defaults/index.js'
+import { decodeBinaryNode } from '../WABinary/index.js'
+import { aesDecryptGCM, aesEncryptGCM, Curve, hkdf, sha256 } from './crypto.js'
+
+const IV_LENGTH = 12
+const EMPTY_BUFFER = Buffer.alloc(0)
+
+class TransportState {
+    constructor(encKey, decKey) {
+        this.encKey = encKey
+        this.decKey = decKey
+        this.readCounter = 0
+        this.writeCounter = 0
+        this.iv = new Uint8Array(IV_LENGTH)
+    }
+
+    #writeIV(c) {
+        this.iv[8] = (c >>> 24) & 0xff
+        this.iv[9] = (c >>> 16) & 0xff
+        this.iv[10] = (c >>> 8) & 0xff
+        this.iv[11] = c & 0xff
+    }
+
+    encrypt(plaintext) { this.#writeIV(this.writeCounter++); return aesEncryptGCM(plaintext, this.encKey, this.iv, EMPTY_BUFFER) }
+    decrypt(ciphertext) { this.#writeIV(this.readCounter++); return aesDecryptGCM(ciphertext, this.decKey, this.iv, EMPTY_BUFFER) }
+}
+
+const buildIntroHeader = (NOISE_HEADER, routingInfo) => {
+    if (!routingInfo) return Buffer.from(NOISE_HEADER)
+    const buf = Buffer.alloc(7 + routingInfo.byteLength + NOISE_HEADER.length)
+    buf.write('ED', 0, 'utf8')
+    buf.writeUint8(0, 2)
+    buf.writeUint8(1, 3)
+    buf.writeUint8(routingInfo.byteLength >> 16, 4)
+    buf.writeUint16BE(routingInfo.byteLength & 65535, 5)
+    buf.set(routingInfo, 7)
+    buf.set(NOISE_HEADER, 7 + routingInfo.byteLength)
+    return buf
+}
+
+export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }) => {
+    logger = logger.child({ class: 'ns' })
+
+    const data = Buffer.from(NOISE_MODE)
+    let hash = data.byteLength === 32 ? data : sha256(data)
+    let salt = hash
+    let encKey = hash
+    let decKey = hash
+    let counter = 0
+    let sentIntro = false
+
+    let inBytes = Buffer.alloc(0)
+    let transport = null
+    let isWaitingForTransport = false
+    let pendingOnFrame = null
+
+    const introHeader = buildIntroHeader(NOISE_HEADER, routingInfo)
+
+    const generateIV = c => {
+        const iv = new ArrayBuffer(IV_LENGTH)
+        new DataView(iv).setUint32(8, c)
+        return new Uint8Array(iv)
+    }
+
+    const authenticate = d => { if (!transport) hash = sha256(Buffer.concat([hash, d])) }
+
+    const localHKDF = d => {
+        const key = hkdf(Buffer.from(d), 64, { salt, info: '' })
+        return [key.subarray(0, 32), key.subarray(32)]
+    }
+
+    const mixIntoKey = d => {
+        const [write, read] = localHKDF(d)
+        salt = write; encKey = read; decKey = read; counter = 0
+    }
+
+    const encrypt = plaintext => {
+        if (transport) return transport.encrypt(plaintext)
+        const result = aesEncryptGCM(plaintext, encKey, generateIV(counter++), hash)
+        authenticate(result)
+        return result
+    }
+
+    const decrypt = ciphertext => {
+        if (transport) return transport.decrypt(ciphertext)
+        const result = aesDecryptGCM(ciphertext, decKey, generateIV(counter++), hash)
+        authenticate(ciphertext)
+        return result
+    }
+
+    const processData = async onFrame => {
+        while (inBytes.length >= 3) {
+            const size = (inBytes[0] << 16) | (inBytes[1] << 8) | inBytes[2]
+            if (inBytes.length < size + 3) return
+            let frame = inBytes.subarray(3, size + 3)
+            inBytes = inBytes.subarray(size + 3)
+            if (transport) frame = await decodeBinaryNode(transport.decrypt(frame))
+            onFrame(frame)
+        }
+    }
+
+    const finishInit = async () => {
+        isWaitingForTransport = true
+        const [write, read] = localHKDF(new Uint8Array(0))
+        transport = new TransportState(write, read)
+        isWaitingForTransport = false
+        if (pendingOnFrame) { await processData(pendingOnFrame); pendingOnFrame = null }
+    }
+
+    authenticate(NOISE_HEADER)
+    authenticate(publicKey)
+
+    return {
+        encrypt,
+        decrypt,
+        authenticate,
+        mixIntoKey,
+        finishInit,
+        processHandshake: ({ serverHello }, noiseKey) => {
+            authenticate(serverHello.ephemeral)
+            mixIntoKey(Curve.sharedKey(privateKey, serverHello.ephemeral))
+
+            const decStaticContent = decrypt(serverHello.static)
+            mixIntoKey(Curve.sharedKey(privateKey, decStaticContent))
+
+            const { intermediate: certIntermediate, leaf } = proto.CertChain.decode(decrypt(serverHello.payload))
+
+            if (!leaf?.details || !leaf?.signature) throw new Boom('invalid noise leaf certificate', { statusCode: 400 })
+            if (!certIntermediate?.details || !certIntermediate?.signature) throw new Boom('invalid noise intermediate certificate', { statusCode: 400 })
+
+            const details = proto.CertChain.NoiseCertificate.Details.decode(certIntermediate.details)
+
+            if (!Curve.verify(details.key, leaf.details, leaf.signature)) throw new Boom('noise certificate signature invalid', { statusCode: 400 })
+            if (!Curve.verify(WA_CERT_DETAILS.PUBLIC_KEY, certIntermediate.details, certIntermediate.signature)) throw new Boom('noise intermediate certificate signature invalid', { statusCode: 400 })
+            if (details.issuerSerial !== WA_CERT_DETAILS.SERIAL) throw new Boom('certification match failed', { statusCode: 400 })
+
+            const keyEnc = encrypt(noiseKey.public)
+            mixIntoKey(Curve.sharedKey(noiseKey.private, serverHello.ephemeral))
+            return keyEnc
+        },
+        encodeFrame: data => {
+            if (transport) data = transport.encrypt(data)
+            const dataLen = data.byteLength
+            const introSize = sentIntro ? 0 : introHeader.length
+            const frame = Buffer.allocUnsafe(introSize + 3 + dataLen)
+            if (!sentIntro) { frame.set(introHeader); sentIntro = true }
+            frame[introSize] = (dataLen >>> 16) & 0xff
+            frame[introSize + 1] = (dataLen >>> 8) & 0xff
+            frame[introSize + 2] = dataLen & 0xff
+            frame.set(data, introSize + 3)
+            return frame
+        },
+        decodeFrame: async (newData, onFrame) => {
+            if (isWaitingForTransport) { inBytes = Buffer.concat([inBytes, newData]); pendingOnFrame = onFrame; return }
+            inBytes = inBytes.length === 0 ? Buffer.from(newData) : Buffer.concat([inBytes, newData])
+            await processData(onFrame)
+        },
+    }
+}