@zervonex/baileys 0.0.0-stage → 3.0.1

package/lib/Utils/extras.js

@@ -0,0 +1,186 @@
+import { trimUndefined } from './generics.js'
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID } from 'crypto'
+import { proto } from '../../WAProto/index.js'
+
+export const SCHEDULED_MSG_META_TYPE = 'scheduled_message'
+export const SCHEDULED_MSG_MAX_PER_CHAT = 30
+export const SCHEDULED_MSG_MAX_MEDIA = 1
+export const SCHEDULED_MSG_RESOURCE_LIMIT_NACK_CODE = 419
+export const SCHEDULED_MSG_REVEAL_KEY_BYTES = 32
+export const SCHEDULED_MSG_REVEAL_KEY_IV_BYTES = 12
+export const SCHEDULED_MSG_REVEAL_KEY_RETENTION_DAYS = 30
+export const SCHEDULED_MSG_TAG_BYTES = 16
+export const SCHEDULED_MSG_WINDOW = Object.freeze({ chat: { minSeconds: 600, maxSeconds: 1209600 }, newsletter: { minSeconds: 600, maxSeconds: 2592000 } })
+export const generateRevealKey = () => randomBytes(SCHEDULED_MSG_REVEAL_KEY_BYTES)
+export const generateRevealKeyId = () => randomUUID()
+export const encryptWithRevealKey = (plaintext, revealKey) => {
+    const key = Buffer.from(revealKey)
+    if (key.length !== SCHEDULED_MSG_REVEAL_KEY_BYTES) throw new TypeError(`reveal key must be ${SCHEDULED_MSG_REVEAL_KEY_BYTES} bytes`)
+    const encIv = randomBytes(SCHEDULED_MSG_REVEAL_KEY_IV_BYTES)
+    const cipher = createCipheriv('aes-256-gcm', key, encIv)
+    const body = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()])
+    return { encIv, encPayload: Buffer.concat([body, cipher.getAuthTag()]) }
+}
+export const decryptWithRevealKey = (encPayload, encIv, revealKey) => {
+    const key = Buffer.from(revealKey)
+    const payload = Buffer.from(encPayload)
+    if (payload.length < SCHEDULED_MSG_TAG_BYTES) throw new TypeError('encrypted payload is too short to carry an auth tag')
+    const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(encIv))
+    decipher.setAuthTag(payload.subarray(payload.length - SCHEDULED_MSG_TAG_BYTES))
+    return Buffer.concat([decipher.update(payload.subarray(0, payload.length - SCHEDULED_MSG_TAG_BYTES)), decipher.final()])
+}
+export const buildConditionalRevealMessage = ({ encPayload, encIv, revealKeyId }) => ({ conditionalRevealMessage: { conditionalRevealMessageType: proto.Message.ConditionalRevealMessage.ConditionalRevealMessageType.SCHEDULED_MESSAGE, encPayload: Buffer.from(encPayload), encIv: Buffer.from(encIv), revealKeyId } })
+export const encodeScheduledMessage = (message, revealKey = generateRevealKey()) => {
+    const plaintext = proto.Message.encode(proto.Message.fromObject(message)).finish()
+    const { encIv, encPayload } = encryptWithRevealKey(plaintext, revealKey)
+    const revealKeyId = generateRevealKeyId()
+    return { revealKey, revealKeyId, encIv, encPayload, message: buildConditionalRevealMessage({ encPayload, encIv, revealKeyId }) }
+}
+export const decodeScheduledMessage = (conditionalRevealMessage, revealKey) => {
+    const inner = conditionalRevealMessage?.conditionalRevealMessage ?? conditionalRevealMessage
+    if (!inner?.encPayload || !inner?.encIv) throw new TypeError('conditionalRevealMessage is missing encPayload or encIv')
+    return proto.Message.decode(decryptWithRevealKey(inner.encPayload, inner.encIv, revealKey))
+}
+export const buildScheduledMsgMetaNode = ({ kind = 'schedule', scheduledTimestampS, revealKeyId, revealKey }) => {
+    if (!revealKeyId) throw new TypeError('revealKeyId is required')
+    if (kind === 'schedule' && !revealKey) throw new TypeError('scheduling requires the reveal key')
+    const attrs = { type: SCHEDULED_MSG_META_TYPE }
+    if (kind === 'schedule') {
+        if (!Number.isFinite(Number(scheduledTimestampS))) throw new TypeError('scheduledTimestampS must be a unix timestamp in seconds')
+        attrs.st = String(Math.floor(Number(scheduledTimestampS)))
+    }
+    return { tag: 'meta', attrs, content: [{ tag: 'key', attrs: { rkid: revealKeyId }, content: kind === 'schedule' ? Buffer.from(revealKey) : undefined }] }
+}
+export const buildUnscheduleProtocolMessage = (key) => ({ protocolMessage: { key, type: proto.Message.ProtocolMessage.Type.MESSAGE_UNSCHEDULE } })
+export const isScheduledTimeValid = (scheduledTimestampS, nowSeconds = Math.floor(Date.now() / 1000), window = SCHEDULED_MSG_WINDOW.chat) => {
+    const rounded = Math.floor(nowSeconds / 60) * 60
+    return scheduledTimestampS - rounded >= window.minSeconds && scheduledTimestampS - nowSeconds <= window.maxSeconds
+}
+export const SplitPaymentStatus = Object.freeze({ PENDING: 0, PAID: 1 })
+export const ReminderFrequency = Object.freeze({ REMINDER_FREQUENCY_UNKNOWN: 0, WEEKLY: 1, BI_WEEKLY: 2, MONTHLY: 3, QUARTERLY: 4 })
+export const ReminderStatus = Object.freeze({ REMINDER_STATUS_UNKNOWN: 0, ACTIVE: 1, CANCELLED_BY_CREATOR: 2, STOPPED_BY_RECEIVER: 3, EXPIRED: 4, PAID: 5 })
+export const MONEY_OFFSET = 1000
+const drop = (object) => { for (const key of Object.keys(object)) { if (object[key] === undefined || object[key] === null) delete object[key] } return object }
+export const money = (amount, currencyCode, offset = MONEY_OFFSET) => {
+    const value = Number(amount)
+    if (!Number.isFinite(value) || value < 0) throw new TypeError('money needs a non-negative amount')
+    if (typeof currencyCode !== 'string' || currencyCode.length !== 3) throw new TypeError('money needs a three letter currency code, like IDR or USD')
+    if (!Number.isInteger(offset) || offset <= 0) throw new TypeError('money offset must be a positive integer')
+    return { value: Math.round(value * offset), offset, currencyCode: currencyCode.toUpperCase() }
+}
+export const readMoney = (value) => { if (!value?.offset) return undefined; return { amount: Number(value.value) / Number(value.offset), currencyCode: value.currencyCode } }
+export const buildSplitPayment = ({ splitId, total, currency, description, requesterJid, participants = [], createdAt } = {}) => {
+    if (!splitId) throw new TypeError('buildSplitPayment needs a splitId')
+    if (!participants.length) throw new TypeError('buildSplitPayment needs at least one participant')
+    return drop({ splitId: String(splitId), totalAmount: total === undefined ? undefined : money(total, currency), description, requesterJid, participants: participants.map((p, i) => { if (!p?.jid) throw new TypeError(`participant ${i} needs a jid`); return drop({ jid: p.jid, amount: p.amount === undefined ? undefined : money(p.amount, p.currency ?? currency), status: p.status ?? SplitPaymentStatus.PENDING }) }), createdAtMs: createdAt === undefined ? Date.now() : Number(createdAt) })
+}
+export const buildSplitPaymentUpdate = ({ splitId, participantJid } = {}) => { if (!splitId || !participantJid) throw new TypeError('buildSplitPaymentUpdate needs both splitId and participantJid'); return { splitId: String(splitId), participantJid } }
+export const buildPaymentReminder = ({ reminderId, instanceId, description, frequency = ReminderFrequency.MONTHLY, status = ReminderStatus.ACTIVE, amount, currency, payeeVpa, payeeJid, payerJid } = {}) => {
+    if (!reminderId) throw new TypeError('buildPaymentReminder needs a reminderId')
+    return drop({ reminderId: String(reminderId), instanceId: instanceId === undefined ? undefined : String(instanceId), description, frequency, status, amount: amount === undefined ? undefined : money(amount, currency), payeeVpa, payeeJid, payerJid })
+}
+export const readSplitPayment = (msg) => {
+    const split = (msg?.message ?? msg)?.splitPaymentMessage
+    if (!split) return null
+    return drop({ splitId: split.splitId, total: readMoney(split.totalAmount), description: split.description, requesterJid: split.requesterJid, createdAtMs: split.createdAtMs === undefined ? undefined : Number(split.createdAtMs), participants: (split.participants ?? []).map(p => drop({ jid: p.jid, amount: readMoney(p.amount), status: p.status })) })
+}
+export const readPaymentReminder = (msg) => {
+    const reminder = (msg?.message ?? msg)?.paymentReminderMessage
+    if (!reminder) return null
+    return drop({ reminderId: reminder.reminderId, instanceId: reminder.instanceId, description: reminder.description, frequency: reminder.frequency, status: reminder.status, amount: readMoney(reminder.amount), payeeVpa: reminder.payeeVpa, payeeJid: reminder.payeeJid, payerJid: reminder.payerJid })
+}
+export const StatusLinkType = Object.freeze({ RASTERIZED_LINK_PREVIEW: 1, RASTERIZED_LINK_TRUNCATED: 2, RASTERIZED_LINK_FULL_URL: 3 })
+export const STICKER_DEFAULT_AREA = Object.freeze({ x: 0.25, y: 0.4, width: 0.5, height: 0.2 })
+const fraction = (value, name) => { const n = Number(value); if (!Number.isFinite(n) || n < 0 || n > 1) throw new TypeError(`${name} must be between 0 and 1`); return n }
+export const stickerArea = ({ x, y, width, height } = STICKER_DEFAULT_AREA) => {
+    const left = fraction(x, 'x'), top = fraction(y, 'y'), right = fraction(left + Number(width), 'x + width'), bottom = fraction(top + Number(height), 'y + height')
+    if (right <= left || bottom <= top) throw new TypeError('a sticker area needs a positive width and height')
+    return [{ x: left, y: top }, { x: right, y: top }, { x: right, y: bottom }, { x: left, y: bottom }]
+}
+const annotation = (area, fields) => ({ polygonVertices: Array.isArray(area) ? area : stickerArea(area), ...fields })
+export const locationSticker = ({ latitude, longitude, name, area, skipConfirmation } = {}) => {
+    const degreesLatitude = Number(latitude), degreesLongitude = Number(longitude)
+    if (!Number.isFinite(degreesLatitude) || !Number.isFinite(degreesLongitude)) throw new TypeError('locationSticker needs a numeric latitude and longitude')
+    return annotation(area, { location: { degreesLatitude, degreesLongitude, ...(name ? { name } : {}) }, ...(skipConfirmation === undefined ? {} : { shouldSkipConfirmation: !!skipConfirmation }) })
+}
+export const channelSticker = ({ jid, name, serverMessageId = 0, accessibilityText, area } = {}) => {
+    if (typeof jid !== 'string' || !jid.endsWith('@newsletter')) throw new TypeError('channelSticker needs the channel jid ending in @newsletter')
+    return annotation(area, { newsletter: { newsletterJid: jid, serverMessageId: Number(serverMessageId), ...(name ? { newsletterName: name } : {}), ...(accessibilityText ? { accessibilityText } : {}) } })
+}
+export const linkSticker = ({ url, title, area, linkType = StatusLinkType.RASTERIZED_LINK_PREVIEW } = {}) => {
+    if (typeof url !== 'string' || !url) throw new TypeError('linkSticker needs a url')
+    return annotation(area, { tapAction: { tapUrl: url, ...(title ? { title } : {}) }, statusLinkType: linkType })
+}
+export const musicSticker = ({ songId, title, author, mediaId, artworkDirectPath, artworkSha256, artworkEncSha256, artworkMediaKey, artistAttribution, countryBlocklist, isExplicit, startTimeMs = 0, derivedStartTimeMs, durationMs, area } = {}) => {
+    if (!songId && !mediaId) throw new TypeError('musicSticker needs at least a songId or a musicContentMediaId')
+    const bytes = v => v === undefined ? undefined : Buffer.isBuffer(v) ? v : Buffer.from(v, 'base64')
+    const em = { ...(songId ? { songId: String(songId) } : {}), ...(mediaId ? { musicContentMediaId: String(mediaId) } : {}), ...(title ? { title } : {}), ...(author ? { author } : {}), ...(artistAttribution ? { artistAttribution } : {}), ...(artworkDirectPath ? { artworkDirectPath } : {}), ...(isExplicit === undefined ? {} : { isExplicit: !!isExplicit }), musicSongStartTimeInMs: Number(startTimeMs), ...(derivedStartTimeMs === undefined ? {} : { derivedContentStartTimeInMs: Number(derivedStartTimeMs) }), ...(durationMs === undefined ? {} : { overlapDurationInMs: Number(durationMs) }) }
+    for (const [k, v] of [['artworkSha256', artworkSha256], ['artworkEncSha256', artworkEncSha256], ['artworkMediaKey', artworkMediaKey], ['countryBlocklist', countryBlocklist]]) { const b = bytes(v); if (b) em[k] = b }
+    return annotation(area, { embeddedContent: { embeddedMusic: em } })
+}
+export const messageSticker = ({ stanzaId, message, area } = {}) => {
+    if (!message) throw new TypeError('messageSticker needs the message it embeds')
+    return annotation(area, { embeddedContent: { embeddedMessage: { ...(stanzaId ? { stanzaId } : {}), message } } })
+}
+const STICKER_ACTIONS = ['location', 'newsletter', 'embeddedAction', 'tapAction']
+export const normalizeStickers = (stickers) => {
+    const list = Array.isArray(stickers) ? stickers : [stickers]
+    return list.filter(Boolean).map((sticker, i) => {
+        const v = sticker.polygonVertices
+        if (!Array.isArray(v) || v.length !== 4) throw new TypeError(`sticker ${i} needs four polygonVertices`)
+        const actions = STICKER_ACTIONS.filter(n => sticker[n] !== undefined && sticker[n] !== null)
+        if (actions.length > 1) throw new TypeError(`sticker ${i} sets ${actions.join(' and ')}, but only one action is allowed per sticker`)
+        return proto.InteractiveAnnotation.fromObject(sticker)
+    })
+}
+export const readStickers = (message) => {
+    const media = message?.imageMessage ?? message?.videoMessage ?? message
+    const annotations = media?.interactiveAnnotations
+    if (!Array.isArray(annotations) || !annotations.length) return []
+    return annotations.map(item => {
+        const [topLeft, , bottomRight] = item.polygonVertices ?? []
+        const music = item.embeddedContent?.embeddedMusic
+        return { kind: item.location ? 'location' : item.newsletter ? 'channel' : item.tapAction ? 'link' : music ? 'music' : item.embeddedContent?.embeddedMessage ? 'message' : 'unknown', area: topLeft && bottomRight ? { x: topLeft.x, y: topLeft.y, width: bottomRight.x - topLeft.x, height: bottomRight.y - topLeft.y } : undefined, location: item.location ?? undefined, channel: item.newsletter ?? undefined, link: item.tapAction ? { url: item.tapAction.tapUrl, title: item.tapAction.title, linkType: item.statusLinkType } : undefined, music: music ? { songId: music.songId, title: music.title, author: music.author } : undefined, message: item.embeddedContent?.embeddedMessage ?? undefined, annotation: item }
+    })
+}
+export const MusicMessageStyle = Object.freeze({ UNKNOWN: 0, VINYL: 1 })
+export const MUSIC_ALLOWED_HOSTS = Object.freeze(['.whatsapp.net', '.whatsapp.com', '.fbcdn.net', '.facebook.com', '.instagram.com', '.cdninstagram.com'])
+export const isMusicHostAllowed = (value) => { let host; try { host = new URL(String(value)).hostname.toLowerCase() } catch { return false } return MUSIC_ALLOWED_HOSTS.some(s => host.endsWith(s) || host === s.slice(1)) }
+const assertMusicHost = (value, label) => { if (value === undefined) return undefined; if (!isMusicHostAllowed(value)) throw new TypeError(`${label} must be hosted on ${MUSIC_ALLOWED_HOSTS.join(', ')}`); return value }
+const embeddedMusicOf = (options) => musicSticker(options).embeddedContent.embeddedMusic
+export const buildMusicMessage = ({ songUri, artworkUri, style = MusicMessageStyle.VINYL, contextInfo, ...music } = {}) => trimUndefined({ embeddedMusic: embeddedMusicOf(music), songUri: assertMusicHost(songUri, 'songUri'), artworkUri: assertMusicHost(artworkUri, 'artworkUri'), style, contextInfo })
+export const readMusicMessage = (msg) => {
+    const music = (msg?.message ?? msg)?.musicMessage
+    if (!music) return null
+    const em = music.embeddedMusic ?? {}
+    return { songId: em.songId, mediaId: em.musicContentMediaId, title: em.title, author: em.author, artistAttribution: em.artistAttribution, isExplicit: em.isExplicit, startTimeMs: em.musicSongStartTimeInMs, durationMs: em.overlapDurationInMs, songUri: music.songUri, artworkUri: music.artworkUri, style: music.style, embeddedMusic: em }
+}
+export function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node
+    const stanza = { tag: 'ack', attrs: { id: attrs.id, to: attrs.from, class: tag } }
+    if (errorCode) stanza.attrs.error = errorCode.toString()
+    if (attrs.participant) stanza.attrs.participant = attrs.participant
+    if (attrs.recipient) stanza.attrs.recipient = attrs.recipient
+    if (attrs.type) stanza.attrs.type = attrs.type
+    if (tag === 'message' && meId) stanza.attrs.from = meId
+    return stanza
+}
+export const pickSenderKeyRecipients = (devices, senderKeyMap, { force = false, skip } = {}) => {
+    const recipients = []
+    for (const device of devices) {
+        const deviceJid = device?.jid
+        if (!deviceJid || (!force && senderKeyMap[deviceJid]) || (skip && skip(device))) continue
+        recipients.push(deviceJid)
+    }
+    return recipients
+}
+export const deliveredSenderKeyJids = nodes => { const delivered = new Set(); for (const node of nodes || []) { const jid = node?.attrs?.jid; if (jid) delivered.add(jid) } return delivered }
+export const senderKeyResetSummary = (stored, jid) => { const devices = Object.keys(stored?.[jid] || {}); return { jid, cleared: devices.length, devices } }
+export const commitSenderKeyDelivery = (senderKeyMap, recipients, nodes) => {
+    const delivered = deliveredSenderKeyJids(nodes), marked = [], skipped = []
+    for (const jid of recipients) { if (delivered.has(jid)) { senderKeyMap[jid] = true; marked.push(jid) } else { delete senderKeyMap[jid]; skipped.push(jid) } }
+    return { marked, skipped }
+}
+export const GROUP_ADDRESSING_MODES = Object.freeze(['pn', 'lid'])
+export const isUsableGroupMetadata = metadata => { if (!metadata || typeof metadata !== 'object') return false; if (!Array.isArray(metadata.participants)) return false; return GROUP_ADDRESSING_MODES.includes(metadata.addressingMode) }
+export const describeUnusableGroupMetadata = metadata => { if (!metadata || typeof metadata !== 'object') return 'nothing cached'; if (!Array.isArray(metadata.participants)) return 'no participants'; if (metadata.addressingMode === undefined || metadata.addressingMode === null) return 'no addressingMode'; return `addressingMode ${JSON.stringify(metadata.addressingMode)} is not pn or lid` }

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,39 @@
+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 './key-store.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/key-store.js

@@ -0,0 +1,3 @@
+// ─── Key Store Helpers ─────────────────────────────────────────────────────────
+// Single source of truth for blob key names — change here, changes everywhere
+export const TC_TOKEN_INDEX_KEY = '__index'

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) }
+    }
+}