@zervonex/baileys 0.0.0-stage → 3.0.2

package/lib/Utils/generics.js

@@ -0,0 +1,195 @@
+import { Boom } from '@hapi/boom'
+import { createHash, randomBytes } from 'crypto'
+import { createRequire } from 'module'
+import { proto, fetchProtoBundle } from '../../WAProto/index.js'
+import { DisconnectReason } from '../Types/index.js'
+import { getAllBinaryNodeChildren, jidDecode } from '../WABinary/index.js'
+import { sha256 } from './crypto.js'
+
+export const BufferJSON = {
+  replacer: (k, value) => {
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') return { type: 'Buffer', data: Buffer.from(value?.data || value).toString('base64') }
+    return value
+  },
+  reviver: (_, value) => {
+    if (typeof value === 'object' && value !== null && value.type === 'Buffer' && typeof value.data === 'string') return Buffer.from(value.data, 'base64')
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const keys = Object.keys(value)
+      if (keys.length > 0 && keys.every(k => !isNaN(parseInt(k, 10)))) {
+        const values = Object.values(value)
+        if (values.every(v => typeof v === 'number')) return Buffer.from(values)
+      }
+    }
+    return value
+  }
+}
+
+export const getKeyAuthor = (key, meId = 'me') => (key?.fromMe ? meId : key?.participantAlt || key?.remoteJidAlt || key?.participant || key?.remoteJid) || ''
+export const isStringNullOrEmpty = value => value == null || value === ''
+
+export const writeRandomPadMax16 = msg => { const pad = randomBytes(1); const padLength = (pad[0] & 0x0f) + 1; return Buffer.concat([msg, Buffer.alloc(padLength, padLength)]) }
+export const unpadRandomMax16 = e => { const t = new Uint8Array(e); if (!t.length) throw new Error('unpadPkcs7 given empty bytes'); const r = t[t.length - 1]; if (r > t.length) throw new Error(`unpad given ${t.length} bytes, but pad is ${r}`); return new Uint8Array(t.buffer, t.byteOffset, t.length - r) }
+
+export const generateParticipantHashV2 = participants => { participants.sort(); return '2:' + sha256(Buffer.from(participants.join(''))).toString('base64').slice(0, 6) }
+
+export const encodeWAMessage = message => {
+  try { return writeRandomPadMax16(proto.Message.encode(message?.$type === proto.Message ? message : proto.Message.fromObject(message)).finish()) }
+  catch (error) {
+    try { return writeRandomPadMax16(proto.Message.encode(message).finish()) }
+    catch (e) { console.warn('Message encoding failed:', error.message, e.message); throw new Error(`Failed to encode message: ${error.message}`) }
+  }
+}
+
+export const generateRegistrationId = () => Uint16Array.from(randomBytes(2))[0] & 16383
+
+export const encodeBigEndian = (e, t = 4) => { let r = e; const a = new Uint8Array(t); for (let i = t - 1; i >= 0; i--) { a[i] = 255 & r; r >>>= 8 }; return a }
+
+export const toNumber = t => typeof t === 'object' && t ? ('toNumber' in t ? t.toNumber() : t.low) : t || 0
+export const unixTimestampSeconds = (date = new Date()) => Math.floor(date.getTime() / 1000)
+
+export const debouncedTimeout = (intervalMs = 1000, task) => {
+  let timeout
+  return {
+    start: (newIntervalMs, newTask) => { task = newTask || task; intervalMs = newIntervalMs || intervalMs; if (timeout) clearTimeout(timeout); timeout = setTimeout(() => task?.(), intervalMs) },
+    cancel: () => { if (timeout) clearTimeout(timeout); timeout = undefined },
+    setTask: newTask => (task = newTask),
+    setInterval: newInterval => (intervalMs = newInterval)
+  }
+}
+
+export const delay = ms => delayCancellable(ms).delay
+export const delayCancellable = ms => {
+  const stack = new Error().stack
+  let timeout, reject
+  const delay = new Promise((resolve, _reject) => { timeout = setTimeout(resolve, ms); reject = _reject })
+  return { delay, cancel: () => { clearTimeout(timeout); reject(new Boom('Cancelled', { statusCode: 500, data: { stack } })) } }
+}
+
+export const promiseTimeout = async (ms, promise) => {
+  if (!ms) return new Promise(promise)
+  const stack = new Error().stack
+  const { delay, cancel } = delayCancellable(ms)
+  return new Promise((resolve, reject) => {
+    delay.then(() => reject(new Boom('Timed Out', { statusCode: DisconnectReason.timedOut, data: { stack } }))).catch(reject)
+    promise(resolve, reject)
+  }).finally(cancel)
+}
+
+export const generateMessageIDV2 = userId => {
+  const data = Buffer.alloc(8 + 20 + 16)
+  data.writeBigUInt64BE(BigInt(Math.floor(Date.now() / 1000)))
+  if (userId) { const id = jidDecode(userId); if (id?.user) { data.write(id.user, 8); data.write('@c.us', 8 + id.user.length) } }
+  randomBytes(16).copy(data, 28)
+  return 'ZERVONEX' + createHash('sha256').update(data).digest().toString('hex').toUpperCase().substring(0, 18)
+}
+
+export const generateMessageID = () => 'ZERVONEX' + randomBytes(18).toString('hex').toUpperCase()
+
+export const bindWaitForEvent = (ev, event) => async (check, timeoutMs) => {
+  let listener, closeListener
+  await promiseTimeout(timeoutMs, (resolve, reject) => {
+    closeListener = ({ connection, lastDisconnect }) => { if (connection === 'close') reject(lastDisconnect?.error || new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed })) }
+    ev.on('connection.update', closeListener)
+    listener = async update => { if (await check(update)) resolve() }
+    ev.on(event, listener)
+  }).finally(() => { ev.off(event, listener); ev.off('connection.update', closeListener) })
+}
+
+export const bindWaitForConnectionUpdate = ev => bindWaitForEvent(ev, 'connection.update')
+
+export const fetchLatestWaWebVersion = async () => {
+  const { version } = await fetchProtoBundle()
+  return { version: [2, 3000, parseInt(version)], isLatest: true }
+}
+export const fetchLatestBaileysVersion = fetchLatestWaWebVersion
+
+export const generateMdTagPrefix = () => { const b = randomBytes(4); return `${b.readUInt16BE()}.${b.readUInt16BE(2)}-` }
+
+const STATUS_MAP = { sender: proto.WebMessageInfo.Status.SERVER_ACK, played: proto.WebMessageInfo.Status.PLAYED, read: proto.WebMessageInfo.Status.READ, 'read-self': proto.WebMessageInfo.Status.READ }
+export const getStatusFromReceiptType = type => typeof type === 'undefined' ? proto.WebMessageInfo.Status.DELIVERY_ACK : STATUS_MAP[type]
+
+const CODE_MAP = { conflict: DisconnectReason.connectionReplaced }
+export const getErrorCodeFromStreamError = node => { const [reasonNode] = getAllBinaryNodeChildren(node); let reason = reasonNode?.tag || 'unknown'; const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession); if (statusCode === DisconnectReason.restartRequired) reason = 'restart required'; return { reason, statusCode } }
+
+export const getCallStatusFromNode = ({ tag, attrs }) => {
+  switch (tag) {
+    case 'offer': case 'offer_notice': return 'offer'
+    case 'terminate': return attrs.reason === 'timeout' ? 'timeout' : 'terminate'
+    case 'reject': return 'reject'
+    case 'accept': return 'accept'
+    default: return 'ringing'
+  }
+}
+
+const UNEXPECTED_SERVER_CODE_TEXT = 'Unexpected server response: '
+export const getCodeFromWSError = error => {
+  if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) { const code = +error.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length); if (!Number.isNaN(code) && code >= 400) return code }
+  if (error?.code?.startsWith('E') || error?.message?.includes('timed out')) return 408
+  return 500
+}
+
+export const isWABusinessPlatform = platform => platform === 'smbi' || platform === 'smba'
+export const trimUndefined = obj => { for (const key in obj) if (typeof obj[key] === 'undefined') delete obj[key]; return obj }
+
+const CROCKFORD_CHARACTERS = '123456789ABCDEFGHJKLMNPQRSTVWXYZ'
+export const bytesToCrockford = buffer => {
+  let value = 0, bitCount = 0
+  const crockford = []
+  for (const element of buffer) { value = (value << 8) | (element & 0xff); bitCount += 8; while (bitCount >= 5) { crockford.push(CROCKFORD_CHARACTERS.charAt((value >>> (bitCount - 5)) & 31)); bitCount -= 5 } }
+  if (bitCount > 0) crockford.push(CROCKFORD_CHARACTERS.charAt((value << (5 - bitCount)) & 31))
+  return crockford.join('')
+}
+
+export const encodeNewsletterMessage = message => proto.Message.encode(message).finish()
+
+const _require = createRequire(import.meta.url)
+const Prism = _require('prismjs')
+const loadPrismLanguages = _require('prismjs/components/index')
+let _prismReady = false
+const ensurePrism = () => { if (_prismReady) return; _prismReady = true; try { loadPrismLanguages() } catch { } }
+
+const PRISM_TYPE_MAP = {
+  keyword: 1, 'keyword control': 1, builtin: 1, important: 1, bold: 1,
+  function: 2, 'function-definition': 2, method: 2, 'method-definition': 2,
+  string: 3, 'template-string': 3, 'string interpolation': 3, char: 3, regex: 3,
+  number: 4, constant: 4, boolean: 4, unit: 4,
+  comment: 5, 'block-comment': 5, prolog: 5, doctype: 5
+}
+
+const flattenPrism = (tokens, out = []) => {
+  for (const t of tokens) {
+    if (typeof t === 'string') { if (t) out.push({ codeContent: t, highlightType: 0 }); continue }
+    const type = PRISM_TYPE_MAP[t.type] ?? 0
+    const content = Array.isArray(t.content) ? flattenPrism(t.content, []).map(x => x.codeContent).join('') : String(t.content)
+    if (content) out.push({ codeContent: content, highlightType: type })
+  }
+  return out
+}
+
+const TYPE_NAMES = ['DEFAULT', 'KEYWORD', 'METHOD', 'STR', 'NUMBER', 'COMMENT']
+export const tokenizeCode = (code, language = 'javascript') => {
+  ensurePrism()
+  const grammar = Prism.languages[language.toLowerCase()] ?? Prism.languages.javascript
+  const raw = flattenPrism(Prism.tokenize(code, grammar))
+  const merged = []
+  for (const t of raw) { const prev = merged[merged.length - 1]; if (prev && prev.highlightType === t.highlightType) prev.codeContent += t.codeContent; else merged.push({ ...t }) }
+  return { codeBlocks: merged, unified_codeBlock: merged.map(t => ({ content: t.codeContent, type: TYPE_NAMES[t.highlightType] ?? 'DEFAULT' })) }
+}
+
+export const waitAllPromises = async value => {
+  if (value instanceof Promise) return waitAllPromises(await value)
+  if (Array.isArray(value)) return Promise.all(value.map(waitAllPromises))
+  if (value && typeof value === 'object' && value.constructor === Object) { const keys = Object.keys(value); const vals = await Promise.all(keys.map(k => waitAllPromises(value[k]))); return Object.fromEntries(keys.map((k, i) => [k, vals[i]])) }
+  return value
+}
+
+export const extractIE = (text, extraEntities = []) => {
+  const entities = [...extraEntities]
+  let out = text
+  out = out.replace(/\[\[([^:]+):([^\]]+)\]\]/g, (_, key, url) => { entities.push({ __typename: 'GenAITextInlineEntity', key, metadata: { __typename: 'GenAILatexItem', latex_expression: '.', font_height: 83.333, padding: 15, latex_image: { __typename: 'GenAIMediaItem', mime_type: 'image/png', url, url_fallback: url, width: 400, height: 400, expiration_timestamp_ms: Date.now() + 86400000 } } }); return `{{${key}}}.{{/${key}}}` })
+  out = out.replace(/\[([^\]]+)\]\(>([^)]+)\)/g, (_, display, deeplink) => { const key = `dl_${entities.length}`; entities.push({ __typename: 'GenAITextInlineEntity', key, metadata: { __typename: 'GenAIDeeplinkInlineEntityMetadata', deeplink, display_text: display } }); return `{{${key}}}${display}{{/${key}}}` })
+  out = out.replace(/\[([^\]]+)\]\((https?:\/\/[^)]+)\)/g, (_, display, url) => { const key = `lnk_${entities.length}`; entities.push({ __typename: 'GenAITextInlineEntity', key, metadata: { __typename: 'GenAIHyperlinkInlineEntityMetadata', url, display_text: display } }); return `{{${key}}}${display}{{/${key}}}` })
+  return { text: out, inline_entities: entities }
+}
+
+export const generateVerificationMetadata = () => ({ proofs: [{ version: 1, useCase: 1, signature: randomBytes(32), certificateChain: [randomBytes(64)], certificateChainSki: [] }] })

package/lib/Utils/history.js

@@ -0,0 +1,51 @@
+import { promisify } from 'util'
+import { inflate } from 'zlib'
+import { proto } from '../../WAProto/index.js'
+import { WAMessageStubType } from '../Types/index.js'
+import { isJidUser } from '../WABinary/index.js'
+import { toNumber } from './generics.js'
+import { normalizeMessageContent } from './messages.js'
+import { downloadContentFromMessage } from './messages-media.js'
+
+const inflatePromise = promisify(inflate)
+
+export const downloadHistory = async (msg, options) => {
+    const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options })
+    const chunks = []
+    for await (const chunk of stream) chunks.push(chunk)
+    return proto.HistorySync.decode(await inflatePromise(Buffer.concat(chunks)))
+}
+
+export const processHistoryMessage = item => {
+    const messages = [], contacts = [], chats = []
+    switch (item.syncType) {
+        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case proto.HistorySync.HistorySyncType.RECENT:
+        case proto.HistorySync.HistorySyncType.FULL:
+        case proto.HistorySync.HistorySyncType.ON_DEMAND:
+            for (const chat of (item.conversations ?? [])) {
+                contacts.push({ id: chat.id, name: chat.name || undefined, lid: chat.lidJid || undefined, phoneNumber: chat.pnJid || undefined, jid: isJidUser(chat.id) ? chat.id : undefined })
+                const msgs = chat.messages || []
+                delete chat.messages; delete chat.archived; delete chat.muteEndTime; delete chat.pinned
+                for (const item of msgs) {
+                    const { message } = item
+                    messages.push(message)
+                    if (!chat.messages?.length) chat.messages = [{ message }]
+                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp)
+                    if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP || message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) && message.messageStubParameters?.[0]) contacts.push({ id: message.key.participant || message.key.remoteJid, verifiedName: message.messageStubParameters[0] })
+                }
+                if (isJidUser(chat.id) && chat.readOnly && chat.archived) delete chat.readOnly
+                chats.push({ ...chat })
+            }
+            break
+        case proto.HistorySync.HistorySyncType.PUSH_NAME:
+            for (const c of (item.pushnames ?? [])) contacts.push({ id: c.id, notify: c.pushname })
+            for (const c of (item.inlineContacts ?? [])) { if (c.id) contacts.push({ id: c.id, name: c.fullName || c.firstName || undefined, notify: c.pushName || undefined, lid: c.lidJid || undefined, phoneNumber: c.pnJid || undefined }) }
+            break
+    }
+    return { chats, contacts, messages, syncType: item.syncType, progress: item.progress }
+}
+
+export const downloadAndProcessHistorySyncNotification = async (msg, options) => processHistoryMessage(await downloadHistory(msg, options))
+
+export const getHistoryMsg = message => message ? normalizeMessageContent(message)?.protocolMessage?.historySyncNotification : undefined

package/lib/Utils/identity-change-handler.js

@@ -0,0 +1,19 @@
+import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js'
+import { isStringNullOrEmpty } from './generics.js'
+
+export async function handleIdentityChange(node, ctx) {
+    const from = node.attrs.from
+    if (!from) return { action: 'invalid_notification' }
+    if (!getBinaryNodeChild(node, 'identity')) return { action: 'no_identity_node' }
+    ctx.logger.info({ jid: from }, 'identity changed')
+    const decoded = jidDecode(from)
+    if (decoded?.device && decoded.device !== 0) { ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device'); return { action: 'skipped_companion_device', device: decoded.device } }
+    if (ctx.meId && (areJidsSameUser(from, ctx.meId) || (ctx.meLid && areJidsSameUser(from, ctx.meLid)))) { ctx.logger.info({ jid: from }, 'self primary identity changed'); return { action: 'skipped_self_primary' } }
+    if (ctx.debounceCache.get(from)) { ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)'); return { action: 'debounced' } }
+    ctx.debounceCache.set(from, true)
+    if (!(await ctx.validateSession(from)).exists) { ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh'); return { action: 'skipped_no_session' } }
+    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session')
+    if (!isStringNullOrEmpty(node.attrs.offline)) { ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing'); return { action: 'skipped_offline' } }
+    try { await ctx.assertSessions([from], true); return { action: 'session_refreshed' } }
+    catch (error) { ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change'); return { action: 'session_refresh_failed', error } }
+}

package/lib/Utils/index.js

@@ -0,0 +1,38 @@
+export * from './generics.js'
+export * from './decode-wa-message.js'
+export * from './messages.js'
+export * from './messages-media.js'
+export * from './validate-connection.js'
+export * from './crypto.js'
+export * from './signal.js'
+export * from './make-mutex.js'
+export * from './logger.js'
+export * from './noise-handler.js'
+export * from './history.js'
+export * from './chat-utils.js'
+export * from './lt-hash.js'
+export * from './auth-utils.js'
+export * from './baileys-event-stream.js'
+export * from './use-multi-file-auth-state.js'
+export * from './link-preview.js'
+export * from './event-buffer.js'
+export * from './process-message.js'
+export * from './message-retry-manager.js'
+export * from './browser-utils.js'
+export * from './identity-change-handler.js'
+export * from './reporting-utils.js'
+export * from './companion-reg-client-utils.js'
+export * from './tc-token-utils.js'
+export * from './meta-ai-msmsg.js'
+export * from './spam-report-utils.js'
+export * from './modern-messages.js'
+export * from './extras.js'
+export * from './native-flow.js'
+export * from './consumer-application.js'
+export * from './bot-capabilities.js'
+export * from './meta-compositing.js'
+export * from './bot-planning-replay.js'
+export * from './message-composer.js'
+export * from './business.js'
+export * from './pre-key-manager.js'
+export * from './sync-action-utils.js'

package/lib/Utils/link-preview.js

@@ -0,0 +1,51 @@
+import { unfurl } from 'unfurl.js'
+import { prepareWAMessageMedia } from './messages.js'
+import { extractImageThumb, getHttpStream } from './messages-media.js'
+
+const THUMBNAIL_WIDTH = 192
+const TIMEOUT = 8_000
+const MAX_INFLIGHT = 1000
+const _inflight = new Map()
+
+const _normalize = text => { const t = text.trim(); return /^https?:\/\//i.test(t) ? t : `https://${t}` }
+const _extractImage = data => data?.open_graph?.images?.[0]?.url ?? data?.twitter_card?.images?.[0]?.url ?? data?.oEmbed?.thumbnails?.[0]?.url ?? data?.favicon ?? null
+const _previewType = image => image ? 5 : 0
+const _compressedThumb = async (url, opts) => (await extractImageThumb(await getHttpStream(url, opts.fetchOpts), opts.thumbnailWidth ?? THUMBNAIL_WIDTH)).buffer
+
+const _resolveThumbnail = async (image, opts) => {
+    if (!image) return {}
+    if (opts.uploadImage) {
+        try {
+            const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, { upload: opts.uploadImage, mediaTypeOverride: 'thumbnail-link', options: opts.fetchOpts })
+            const jpeg = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : await _compressedThumb(image, opts).catch(() => undefined)
+            return { jpegThumbnail: jpeg, highQualityThumbnail: imageMessage ?? undefined }
+        } catch { }
+    }
+    try { return { jpegThumbnail: await _compressedThumb(image, opts) } } catch { return {} }
+}
+
+const _fetchMeta = async (url, opts) => {
+    try {
+        const data = await unfurl(url, { timeout: opts.fetchOpts?.timeout ?? TIMEOUT })
+        const title = (data?.open_graph?.title !== data?.title ? data?.open_graph?.title : data?.title) ?? data?.oEmbed?.title
+        if (!title) return undefined
+        return { url: data?.open_graph?.url ?? url, title, description: data?.open_graph?.description ?? data?.description ?? data?.oEmbed?.author_name ?? '', image: _extractImage(data) }
+    } catch (err) { opts.logger?.warn({ err: err?.message || err, url }, 'unfurl failed'); return undefined }
+}
+
+const _buildResult = async (meta, text, opts) => ({
+    'canonical-url': meta.url, 'matched-text': text,
+    title: meta.title, description: meta.description,
+    originalThumbnailUrl: meta.image, previewType: _previewType(meta.image),
+    ...await _resolveThumbnail(meta.image, opts)
+})
+
+export const getUrlInfo = (text, opts = {}) => {
+    const url = _normalize(text)
+    if (_inflight.has(url)) return _inflight.get(url)
+    if (_inflight.size >= MAX_INFLIGHT) return Promise.resolve(undefined)
+    const o = { fetchOpts: { timeout: TIMEOUT, ...opts.fetchOpts }, thumbnailWidth: opts.thumbnailWidth ?? THUMBNAIL_WIDTH, uploadImage: opts.uploadImage, logger: opts.logger }
+    const promise = (async () => { const meta = await _fetchMeta(url, o); return meta ? _buildResult(meta, text, o) : undefined })().finally(() => _inflight.delete(url))
+    _inflight.set(url, promise)
+    return promise
+}

package/lib/Utils/logger.js

@@ -0,0 +1,2 @@
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/lib/Utils/lt-hash.js

@@ -0,0 +1,3 @@
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();

package/lib/Utils/make-mutex.js

@@ -0,0 +1,16 @@
+export const makeMutex = () => {
+    let task = Promise.resolve()
+    return {
+        mutex(code) {
+            task = task.catch(() => { }).then(code)
+            return task
+        }
+    }
+}
+
+export const makeKeyedMutex = () => {
+    const map = {}
+    return {
+        mutex(key, code) { if (!map[key]) map[key] = makeMutex(); return map[key].mutex(code) }
+    }
+}

package/lib/Utils/message-composer.js

@@ -0,0 +1,59 @@
+import { generateMessageIDV2, tokenizeCode } from './generics.js'
+
+const buildRichContextInfo = (quoted, options = {}) => {
+    const ctx = { forwardingScore: 1, isForwarded: true, forwardedAiBotMessageInfo: { botJid: options.botJid || '867051314767696@bot' }, forwardOrigin: 4, ...(options.mentions ? { mentionedJid: options.mentions } : {}) }
+    if (quoted?.key) { ctx.stanzaId = quoted.key.id; ctx.participant = quoted.key.participant || quoted.sender || quoted.key.remoteJid; ctx.quotedMessage = quoted.message }
+    return ctx
+}
+
+const buildBotForwardedMessage = (submessages, contextInfo, unifiedResponse) => {
+    const rich = { messageType: 1, submessages, contextInfo }
+    if (unifiedResponse) rich.unifiedResponse = unifiedResponse
+    return { botForwardedMessage: { message: { richResponseMessage: rich } } }
+}
+
+const wrap = (sub, quoted, options) => ({ message: buildBotForwardedMessage(sub, buildRichContextInfo(quoted, options)), messageId: generateMessageIDV2() })
+const text = msg => ({ messageType: 2, messageText: msg })
+const table = (title, rows) => ({ messageType: 4, tableMetadata: { title, rows } })
+
+export const generateTableContent = (title, headers, rows, quoted, options = {}) => {
+    const { footer, headerText } = options
+    const sub = [...(headerText ? [text(headerText)] : []), table(title, [{ items: headers, isHeading: true }, ...rows.map(row => ({ items: row.map(String) }))]), ...(footer ? [text(footer)] : [])]
+    return wrap(sub, quoted, options)
+}
+
+export const generateListContent = (title, items, quoted, options = {}) => {
+    const { footer, headerText } = options
+    const sub = [...(headerText ? [text(headerText)] : []), table(title, items.map(item => ({ items: Array.isArray(item) ? item.map(String) : [String(item)] }))), ...(footer ? [text(footer)] : [])]
+    return wrap(sub, quoted, options)
+}
+
+export const generateCodeBlockContent = (code, quoted, options = {}) => {
+    const { title, footer, language = 'javascript' } = options
+    const sub = [...(title ? [text(title)] : []), { messageType: 5, codeMetadata: { codeLanguage: language, codeBlocks: tokenizeCode(code, language) } }, ...(footer ? [text(footer)] : [])]
+    return wrap(sub, quoted, options)
+}
+
+export const generateLatexContent = (quoted, options = {}) => {
+    const { text: txt, expressions = [], headerText, footer } = options
+    const latexExpressions = expressions.map(({ latexExpression, url, width, height, fontHeight, imageTopPadding, imageLeadingPadding, imageBottomPadding, imageTrailingPadding }) => {
+        const e = { latexExpression, url, width, height }
+        if (fontHeight !== undefined) e.fontHeight = fontHeight
+        if (imageTopPadding !== undefined) e.imageTopPadding = imageTopPadding
+        if (imageLeadingPadding !== undefined) e.imageLeadingPadding = imageLeadingPadding
+        if (imageBottomPadding !== undefined) e.imageBottomPadding = imageBottomPadding
+        if (imageTrailingPadding !== undefined) e.imageTrailingPadding = imageTrailingPadding
+        return e
+    })
+    const sub = [...(headerText ? [text(headerText)] : []), { messageType: 8, latexMetadata: { text: txt || '', expressions: latexExpressions } }, ...(footer ? [text(footer)] : [])]
+    return wrap(sub, quoted, options)
+}
+
+export const captureUnifiedResponse = msg => {
+    const rich = msg?.botForwardedMessage?.message?.richResponseMessage
+    if (!rich?.unifiedResponse?.data) return null
+    return { unifiedResponse: { data: rich.unifiedResponse.data }, submessages: rich.submessages || [], contextInfo: rich.contextInfo || {} }
+}
+
+export const generateUnifiedResponseContent = (quoted, captured) => wrap(captured.submessages, quoted, { unifiedResponse: captured.unifiedResponse })
+export const generateRichMessageContent = (submessages, quoted, options) => wrap(submessages, quoted, options)

package/lib/Utils/message-retry-manager.js

@@ -0,0 +1,48 @@
+import { LRUCache } from 'lru-cache'
+
+const RECENT_MESSAGES_SIZE = 512
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000
+const PHONE_REQUEST_DELAY = 3000
+
+export class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger
+        this.maxMsgRetryCount = maxMsgRetryCount
+        this.recentMessagesMap = new LRUCache({ max: RECENT_MESSAGES_SIZE })
+        this.sessionRecreateHistory = new LRUCache({ ttl: RECREATE_SESSION_TIMEOUT * 2, ttlAutopurge: true })
+        this.retryCounters = new LRUCache({ ttl: 15 * 60 * 1000, ttlAutopurge: true, updateAgeOnGet: true })
+        this.pendingPhoneRequests = {}
+        this.statistics = { totalRetries: 0, successfulRetries: 0, failedRetries: 0, mediaRetries: 0, sessionRecreations: 0, phoneRequests: 0 }
+    }
+
+    keyToString(key) { return `${key.to}:${key.id}` }
+
+    addRecentMessage(to, id, message) { this.recentMessagesMap.set(this.keyToString({ to, id }), { message, timestamp: Date.now() }) }
+    getRecentMessage(to, id) { return this.recentMessagesMap.get(this.keyToString({ to, id })) }
+
+    shouldRecreateSession(jid, retryCount, hasSession) {
+        if (!hasSession) { this.sessionRecreateHistory.set(jid, Date.now()); this.statistics.sessionRecreations++; return { reason: "we don't have a Signal session with them", recreate: true } }
+        if (retryCount < 2) return { reason: '', recreate: false }
+        const now = Date.now()
+        const prevTime = this.sessionRecreateHistory.get(jid)
+        if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) { this.sessionRecreateHistory.set(jid, now); this.statistics.sessionRecreations++; return { reason: 'retry count > 1 and over an hour since last recreation', recreate: true } }
+        return { reason: '', recreate: false }
+    }
+
+    incrementRetryCount(messageId) { this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1); this.statistics.totalRetries++; return this.retryCounters.get(messageId) }
+    getRetryCount(messageId) { return this.retryCounters.get(messageId) || 0 }
+    hasExceededMaxRetries(messageId) { return this.getRetryCount(messageId) >= this.maxMsgRetryCount }
+
+    markRetrySuccess(messageId) { this.statistics.successfulRetries++; this.retryCounters.delete(messageId); this.cancelPendingPhoneRequest(messageId) }
+    markRetryFailed(messageId) { this.statistics.failedRetries++; this.retryCounters.delete(messageId) }
+
+    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+        this.cancelPendingPhoneRequest(messageId)
+        this.pendingPhoneRequests[messageId] = setTimeout(() => { delete this.pendingPhoneRequests[messageId]; this.statistics.phoneRequests++; callback() }, delay)
+    }
+
+    cancelPendingPhoneRequest(messageId) {
+        const timeout = this.pendingPhoneRequests[messageId]
+        if (timeout) { clearTimeout(timeout); delete this.pendingPhoneRequests[messageId] }
+    }
+}