@badzz88/baileys 8.4.9 → 8.5.1

package/{src → lib}/Utils/signal.js

@@ -4,6 +4,7 @@ exports.getNextPreKeysNode =
 	exports.getNextPreKeys =
 	exports.extractDeviceJids =
 	exports.parseAndInjectE2ESessions =
+	exports.extractE2ESessionFromRetryReceipt =
 	exports.xmppPreKey =
 	exports.xmppSignedPreKey =
 	exports.generateOrGetPreKeys =
@@ -53,11 +54,9 @@ const generateOrGetPreKeys = (creds, range) => {
 	}
 }
 exports.generateOrGetPreKeys = generateOrGetPreKeys
-// cipherSuite: 0x05 = X25519/Curve25519 (standard Signal), 0x2a = Kyber-1024 (PQXDH) —
-// only pass it when mixing in a non-default cipher; omit for plain Curve25519 uploads.
-const xmppSignedPreKey = (key, cipherSuite) => ({
+const xmppSignedPreKey = key => ({
 	tag: 'skey',
-	attrs: cipherSuite !== undefined ? { key_cipher_suite: cipherSuite } : {},
+	attrs: {},
 	content: [
 		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
 		{ tag: 'value', attrs: {}, content: key.keyPair.public },
@@ -65,27 +64,63 @@ const xmppSignedPreKey = (key, cipherSuite) => ({
 	]
 })
 exports.xmppSignedPreKey = xmppSignedPreKey
-const xmppPreKey = (pair, id, cipherSuite) => ({
+const xmppPreKey = (pair, id) => ({
 	tag: 'key',
-	attrs: cipherSuite !== undefined ? { key_cipher_suite: cipherSuite } : {},
+	attrs: {},
 	content: [
 		{ tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
 		{ tag: 'value', attrs: {}, content: pair.public }
 	]
 })
 exports.xmppPreKey = xmppPreKey
-const parseAndInjectE2ESessions = async (node, repository) => {
-	const extractKey = key => {
-		if (!key) return undefined
-		const cipherSuite = key.attrs?.key_cipher_suite
-		return {
-			keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
-			publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
-			signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature'),
-			// 0x05 = Curve25519 (standard Signal), 0x2a = Kyber-1024 (PQXDH)
-			...(cipherSuite !== undefined ? { cipherSuite } : {})
+const isValidUInt = n => typeof n === 'number' && Number.isInteger(n)
+const extractE2ESessionFromRetryReceipt = receipt => {
+	const keysNode = (0, WABinary_1.getBinaryNodeChild)(receipt, 'keys')
+	if (!keysNode) return null
+	const typeBuf = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'type')
+	if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== Defaults_1.KEY_BUNDLE_TYPE[0]) return null
+	const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(keysNode, 'identity')
+	const skey = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'skey')
+	if (!identity || identity.length !== 32 || !skey) return null
+	const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(receipt, 'registration', 4)
+	if (!isValidUInt(registrationId)) return null
+	const signedPubKey = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'value')
+	const signedSig = (0, WABinary_1.getBinaryNodeChildBuffer)(skey, 'signature')
+	const signedKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(skey, 'id', 3)
+	if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
+		return null
+	}
+	const preKeyNode = (0, WABinary_1.getBinaryNodeChild)(keysNode, 'key')
+	let preKey
+	if (preKeyNode) {
+		const preKeyPub = (0, WABinary_1.getBinaryNodeChildBuffer)(preKeyNode, 'value')
+		const preKeyId = (0, WABinary_1.getBinaryNodeChildUInt)(preKeyNode, 'id', 3)
+		if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
+			return null
 		}
+		preKey = { keyId: preKeyId, publicKey: (0, crypto_1.generateSignalPubKey)(preKeyPub) }
+	}
+	return {
+		registrationId,
+		identityKey: (0, crypto_1.generateSignalPubKey)(identity),
+		signedPreKey: {
+			keyId: signedKeyId,
+			publicKey: (0, crypto_1.generateSignalPubKey)(signedPubKey),
+			signature: signedSig
+		},
+		preKey
 	}
+}
+exports.extractE2ESessionFromRetryReceipt = extractE2ESessionFromRetryReceipt
+const parseAndInjectE2ESessions = async (node, repository) => {
+	const extractKey = key =>
+		key
+			? {
+					keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
+					publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
+					signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature')
+				}
+			: undefined
 	const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user')
 	for (const node of nodes) {
 		;(0, WABinary_1.assertNodeErrorFree)(node)
@@ -180,9 +215,6 @@ const getNextPreKeysNode = async (state, count) => {
 			{ tag: 'registration', attrs: {}, content: (0, generics_1.encodeBigEndian)(creds.registrationId) },
 			{ tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
 			{ tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
-			// key_cipher_suite is only sent when the bundle mixes in a non-default cipher
-			// (e.g. Kyber/PQXDH alongside Curve25519) — a plain Curve25519-only upload
-			// omits it entirely on real clients, confirmed against live capture.
 			{ tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
 			(0, exports.xmppSignedPreKey)(creds.signedPreKey)
 		]

package/{src → lib}/Utils/stanza-ack.js

@@ -1,34 +1,6 @@
 'use strict'
 Object.defineProperty(exports, '__esModule', { value: true })
 exports.buildAckStanza = buildAckStanza
-// Standalone call stanzas use class="call" + type=<tag>, not class=<tag>.
-// Kept in sync with messages-recv.js's CALL_STATE_TAGS + CB: registration loop.
-const CALL_STANZA_TAGS = new Set([
-	'offer',
-	'offer_notice',
-	'terminate',
-	'accept',
-	'reject',
-	'preaccept',
-	'transport',
-	'video',
-	'duration',
-	'mute_v2',
-	'lobby',
-	'heartbeat',
-	'relaylatency',
-	'link_query',
-	'group_update',
-	'accept_ack',
-	'enc-rekey',
-	'enc_rekey',
-	'peer_state',
-	'group_info',
-	'video_state',
-	'video_state_ack',
-	'flow_control',
-	'waiting_room_request'
-])
 /**
  * Builds an ACK stanza for a received node.
  * Pure function -- no I/O, no side effects.
@@ -39,19 +11,14 @@ const CALL_STANZA_TAGS = new Set([
  */
 function buildAckStanza(node, errorCode, meId) {
 	const { tag, attrs } = node
-	const isCallStanza = CALL_STANZA_TAGS.has(tag)
 	const stanza = {
 		tag: 'ack',
 		attrs: {
 			id: attrs.id,
 			to: attrs.from,
-			class: isCallStanza ? 'call' : tag
+			class: tag
 		}
 	}
-	// For standalone call stanzas, WA Web puts the original tag into `type`
-	if (isCallStanza) {
-		stanza.attrs.type = tag
-	}
 	if (errorCode) {
 		stanza.attrs.error = errorCode.toString()
 	}
@@ -62,8 +29,7 @@ function buildAckStanza(node, errorCode, meId) {
 		stanza.attrs.recipient = attrs.recipient
 	}
 	// WA Web always includes type when present: `n.type || DROP_ATTR`
-	// For call stanzas the type is already set to the tag name above; don't override it.
-	if (attrs.type && !isCallStanza) {
+	if (attrs.type) {
 		stanza.attrs.type = attrs.type
 	}
 	// WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs

package/lib/Utils/sticker.d.ts

@@ -0,0 +1,17 @@
+export interface StickerMetaOptions {
+	packName?: string
+	packPublisher?: string
+	categories?: string[]
+}
+
+export function addExifToWebp(webpBuffer: Buffer, options?: StickerMetaOptions): Promise<Buffer>
+
+export function imageToWebpSticker(
+	imageBuffer: Buffer,
+	options?: StickerMetaOptions & { quality?: number }
+): Promise<Buffer>
+
+export function videoToWebpSticker(
+	videoBuffer: Buffer,
+	options?: StickerMetaOptions & { fps?: number; seconds?: number }
+): Promise<Buffer>

package/lib/Utils/sticker.js

@@ -0,0 +1,145 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.imageToWebpSticker = exports.videoToWebpSticker = exports.addExifToWebp = void 0
+const os = require('os')
+const path = require('path')
+const fs = require('fs')
+const crypto = require('crypto')
+const { exec } = require('child_process')
+
+/**
+ * Builds and writes the EXIF metadata WhatsApp expects on sticker webp files
+ * (pack name / author, shown when a user long-presses a sticker).
+ * Converts the file to the "extended" (VP8X) WebP container if it isn't already,
+ * since that's the container format that actually carries an EXIF chunk.
+ * Returns the new buffer with EXIF attached.
+ */
+const addExifToWebp = async (webpBuffer, { packName = '', packPublisher = '', categories = [] } = {}) => {
+	const json = {
+		'sticker-pack-id': crypto.randomBytes(16).toString('hex'),
+		'sticker-pack-name': packName,
+		'sticker-pack-publisher': packPublisher,
+		emojis: categories.length ? categories : ['😀']
+	}
+	const jsonBuffer = Buffer.from(JSON.stringify(json), 'utf-8')
+	// TIFF header + IFD entry pointing at a single custom tag (0x5741 "AW") holding
+	// the JSON payload -- this is the exact structure WhatsApp's client parses.
+	const exifAttr = Buffer.from([
+		0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
+		0x00, 0x00, 0x00
+	])
+	exifAttr.writeUIntLE(jsonBuffer.length, 14, 4)
+	const exifPayload = Buffer.concat([exifAttr, jsonBuffer])
+	const pad = buf => (buf.length % 2 === 1 ? Buffer.concat([buf, Buffer.from([0x00])]) : buf)
+	const makeChunk = (tag, data) => {
+		const sizeField = Buffer.alloc(4)
+		sizeField.writeUInt32LE(data.length, 0)
+		return Buffer.concat([Buffer.from(tag, 'ascii'), sizeField, pad(data)])
+	}
+	const exifChunk = makeChunk('EXIF', exifPayload)
+	if (webpBuffer.slice(0, 4).toString('ascii') !== 'RIFF' || webpBuffer.slice(8, 12).toString('ascii') !== 'WEBP') {
+		throw new Error('addExifToWebp expects a valid WebP buffer')
+	}
+	let offset = 12
+	let vp8xChunk = null
+	let vp8xOffset = -1
+	const otherChunks = []
+	while (offset < webpBuffer.length) {
+		const tag = webpBuffer.slice(offset, offset + 4).toString('ascii')
+		const size = webpBuffer.readUInt32LE(offset + 4)
+		const dataStart = offset + 8
+		const dataEnd = dataStart + size
+		const chunkTotal = 8 + size + (size % 2)
+		if (tag === 'VP8X') {
+			vp8xChunk = webpBuffer.slice(offset, offset + chunkTotal)
+			vp8xOffset = offset
+		} else if (tag !== 'EXIF') {
+			// drop any pre-existing EXIF chunk, keep everything else (VP8/VP8L/ANIM/ANMF/ICCP/...)
+			otherChunks.push(webpBuffer.slice(offset, offset + chunkTotal))
+		}
+		offset += chunkTotal
+	}
+	let flags
+	let canvasWidth
+	let canvasHeight
+	if (vp8xChunk) {
+		flags = vp8xChunk.readUInt8(8)
+		canvasWidth = vp8xChunk.readUIntLE(12, 3) + 1
+		canvasHeight = vp8xChunk.readUIntLE(15, 3) + 1
+	} else {
+		flags = 0
+		let sharp
+		try {
+			sharp = require('sharp')
+		} catch (error) {
+			throw new Error('addExifToWebp needs the optional "sharp" dependency to read image dimensions')
+		}
+		const meta = await sharp(webpBuffer).metadata()
+		canvasWidth = meta.width
+		canvasHeight = meta.height
+	}
+	flags |= 0x08 // set the "has EXIF metadata" bit
+	const vp8xData = Buffer.alloc(10)
+	vp8xData.writeUInt8(flags, 0)
+	vp8xData.writeUIntLE(canvasWidth - 1, 4, 3)
+	vp8xData.writeUIntLE(canvasHeight - 1, 7, 3)
+	const newVp8xChunk = makeChunk('VP8X', vp8xData)
+	const body = Buffer.concat([newVp8xChunk, ...otherChunks, exifChunk])
+	const fileSize = Buffer.alloc(4)
+	fileSize.writeUInt32LE(4 + body.length, 0) // 4 = 'WEBP'
+	return Buffer.concat([Buffer.from('RIFF', 'ascii'), fileSize, Buffer.from('WEBP', 'ascii'), body])
+}
+exports.addExifToWebp = addExifToWebp
+
+/**
+ * Converts a static image buffer to a WhatsApp sticker-ready webp buffer using `sharp`.
+ * @param {Buffer} imageBuffer
+ * @param {{ packName?: string, packPublisher?: string, categories?: string[], quality?: number }} [options]
+ * @returns {Promise<Buffer>}
+ */
+const imageToWebpSticker = async (imageBuffer, options = {}) => {
+	let sharp
+	try {
+		sharp = require('sharp')
+	} catch (error) {
+		throw new Error('imageToWebpSticker requires the optional "sharp" dependency to be installed')
+	}
+	const webp = await sharp(imageBuffer)
+		.resize(512, 512, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+		.webp({ quality: options.quality ?? 80 })
+		.toBuffer()
+	return addExifToWebp(webp, options)
+}
+exports.imageToWebpSticker = imageToWebpSticker
+
+/**
+ * Converts a video buffer to an animated WhatsApp sticker-ready webp buffer.
+ * Requires the `ffmpeg` binary to be available on PATH.
+ * @param {Buffer} videoBuffer
+ * @param {{ packName?: string, packPublisher?: string, categories?: string[], fps?: number, seconds?: number }} [options]
+ * @returns {Promise<Buffer>}
+ */
+const videoToWebpSticker = async (videoBuffer, options = {}) => {
+	const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'xazbails-sticker-'))
+	const inputPath = path.join(tmpDir, 'input.mp4')
+	const outputPath = path.join(tmpDir, 'output.webp')
+	fs.writeFileSync(inputPath, videoBuffer)
+	const fps = options.fps ?? 10
+	const seconds = options.seconds ?? 5
+	const cmd =
+		`ffmpeg -y -i ${inputPath} -t ${seconds} -vf ` +
+		`"fps=${fps},scale=512:512:force_original_aspect_ratio=decrease,` +
+		`pad=512:512:(ow-iw)/2:(oh-ih)/2:color=0x00000000,split[a][b];` +
+		`[a]palettegen=reserve_transparent=1[p];[b][p]paletteuse" ` +
+		`-loop 0 -preset default -an -vsync 0 ${outputPath}`
+	try {
+		await new Promise((resolve, reject) => {
+			exec(cmd, err => (err ? reject(err) : resolve()))
+		})
+		const webp = fs.readFileSync(outputPath)
+		return await addExifToWebp(webp, options)
+	} finally {
+		fs.rmSync(tmpDir, { recursive: true, force: true })
+	}
+}
+exports.videoToWebpSticker = videoToWebpSticker

package/{src → lib}/Utils/tc-token-utils.js

@@ -64,7 +64,7 @@ async function buildMergedTcTokenIndexWrite(keys, addedJids) {
 // WA Web has separate sender/receiver AB props for these but they're identical today
 function isTcTokenExpired(timestamp) {
 	if (timestamp === null || timestamp === undefined) return true
-	const ts = typeof timestamp === 'string' ? parseInt(timestamp, 10) : timestamp
+	const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp
 	if (isNaN(ts)) return true
 	const now = Math.floor(Date.now() / 1000)
 	const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)

package/{src → lib}/Utils/validate-connection.js

@@ -7,40 +7,24 @@ exports.encodeSignedDeviceIdentity =
 		void 0
 const boom_1 = require('@hapi/boom')
 const crypto_1 = require('crypto')
-const rb = require('whatsapp-rust-bridge-baron')
+const Crypto_1 = require('./crypto')
 const index_js_1 = require('../../WAProto/index.js')
 const Defaults_1 = require('../Defaults')
 const WABinary_1 = require('../WABinary')
 const crypto_2 = require('./crypto')
 const generics_1 = require('./generics')
 const signal_1 = require('./signal')
-const MOBILE_PLATFORMS = new Set(['Android', 'iOS'])
 const getUserAgent = config => {
-	const os = config.browser[0]
-	let platform, device, osVersion
-	if (os === 'Android') {
-		platform = index_js_1.proto.ClientPayload.UserAgent.Platform.ANDROID
-		device = 'Android'
-		osVersion = config.browser[2] || '15.0.0'
-	} else if (os === 'iOS') {
-		platform = index_js_1.proto.ClientPayload.UserAgent.Platform.IOS
-		device = 'iPhone'
-		osVersion = config.browser[2] || '18.0'
-	} else {
-		platform = index_js_1.proto.ClientPayload.UserAgent.Platform.WEB
-		device = 'Desktop'
-		osVersion = '0.1'
-	}
 	return {
 		appVersion: {
 			primary: config.version[0],
 			secondary: config.version[1],
 			tertiary: config.version[2]
 		},
-		platform,
-		releaseChannel: index_js_1.proto.ClientPayload.UserAgent.ReleaseChannel.DEBUG,
-		osVersion,
-		device,
+		platform: index_js_1.proto.ClientPayload.UserAgent.Platform.WEB,
+		releaseChannel: index_js_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+		osVersion: '0.1',
+		device: 'Desktop',
 		osBuildNumber: '0.1',
 		localeLanguageIso6391: 'en',
 		mnc: '000',
@@ -50,9 +34,7 @@ const getUserAgent = config => {
 }
 const PLATFORM_MAP = {
 	'Mac OS': index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-	Windows: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32,
-	Android: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER,
-	iOS: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
+	Windows: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
 }
 const getWebInfo = config => {
 	let webSubPlatform = index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER
@@ -67,9 +49,7 @@ const getClientPayload = config => {
 		connectReason: index_js_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
 		userAgent: getUserAgent(config)
 	}
-	if (!MOBILE_PLATFORMS.has(config.browser[0])) {
-		payload.webInfo = getWebInfo(config)
-	}
+	payload.webInfo = getWebInfo(config)
 	return payload
 }
 const generateLoginNode = (userJid, config, creds) => {
@@ -105,18 +85,16 @@ const getPlatformType = platform => {
 const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
 	// the app version needs to be md5 hashed
 	// and passed in
-	const appVersionBuf = Buffer.from(rb.md5(Buffer.from(config.version.join('.'))))
+	const appVersionBuf = Buffer.from(Crypto_1.md5(Buffer.from(config.version.join('.'))))
 	const companion = {
 		os: config.browser[0],
 		platformType: getPlatformType(config.browser[1]),
 		requireFullSync: config.syncFullHistory,
 		historySyncConfig: {
-			fullSyncDaysLimit: undefined,
-			fullSyncSizeMbLimit: undefined,
 			storageQuotaMb: 10240,
 			inlineInitialPayloadInE2EeMsg: true,
 			recentSyncDaysLimit: undefined,
-			supportCallLogHistory: true,
+			supportCallLogHistory: false,
 			supportBotUserAgentChatHistory: true,
 			supportCagReactionsAndPolls: true,
 			supportBizHostedMsg: true,
@@ -125,16 +103,9 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
 			supportFbidBotChatHistory: true,
 			supportAddOnHistorySyncMigration: undefined,
 			supportMessageAssociation: true,
-			supportGroupHistory: true,
+			supportGroupHistory: false,
 			onDemandReady: undefined,
-			supportGuestChat: true,
-			completeOnDemandReady: undefined,
-			thumbnailSyncDaysLimit: undefined,
-			initialSyncMaxMessagesPerChat: undefined,
-			supportManusHistory: true,
-			supportHatchHistory: true,
-			supportedBotChannelFbids: undefined,
-			supportInlineContacts: true
+			supportGuestChat: undefined
 		},
 		version: {
 			primary: 10,

package/lib/Utils/view-once-cache.d.ts

@@ -0,0 +1,9 @@
+export interface AutoCacheViewOnceOptions {
+	cacheDir?: string
+	logger?: any
+	onCached?: (info: { id: string; jid: string; filePath: string; type: string }) => void
+}
+
+export function getViewOnceContent(message: any): Record<string, any> | null
+
+export function autoCacheViewOnceMedia(sock: any, options?: AutoCacheViewOnceOptions): () => void

package/lib/Utils/view-once-cache.js

@@ -0,0 +1,79 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.autoCacheViewOnceMedia = void 0
+const path = require('path')
+const fs = require('fs')
+const Messages_1 = require('./messages')
+const MessagesMedia_1 = require('./messages-media')
+
+const VIEW_ONCE_WRAPPER_KEYS = ['viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension']
+const VIEW_ONCE_INNER_KEYS = ['imageMessage', 'videoMessage', 'audioMessage']
+
+/**
+ * Unwraps a message and returns the inner view-once media content if present, otherwise null.
+ * Handles both the wrapper style (viewOnceMessage[V2/V2Extension] -> message -> ...)
+ * and the inline style (imageMessage/videoMessage with viewOnce: true set directly).
+ */
+const getViewOnceContent = message => {
+	if (!message) return null
+	const content = (0, Messages_1.extractMessageContent)(message)
+	if (!content) return null
+	for (const wrapperKey of VIEW_ONCE_WRAPPER_KEYS) {
+		const wrapper = content[wrapperKey]
+		if (wrapper?.message) {
+			const inner = (0, Messages_1.extractMessageContent)(wrapper.message)
+			if (inner) return inner
+		}
+	}
+	for (const key of VIEW_ONCE_INNER_KEYS) {
+		if (content[key]?.viewOnce) {
+			return { [key]: content[key] }
+		}
+	}
+	return null
+}
+
+/**
+ * Registers a `messages.upsert` listener on the given socket that automatically
+ * downloads and saves view-once media (image/video/audio) to `cacheDir` as soon
+ * as it arrives, before the sender's app can mark it as opened/consumed.
+ *
+ * @param {ReturnType<typeof import('../Socket').default>} sock - an active Baileys socket
+ * @param {{ cacheDir?: string, logger?: any, onCached?: (info: { id: string, jid: string, filePath: string, type: string }) => void }} [options]
+ * @returns {() => void} a function that removes the listener
+ */
+const autoCacheViewOnceMedia = (sock, options = {}) => {
+	const cacheDir = options.cacheDir || './viewonce-cache'
+	const logger = options.logger || sock.logger
+	if (!fs.existsSync(cacheDir)) {
+		fs.mkdirSync(cacheDir, { recursive: true })
+	}
+	const handler = async ({ messages, type }) => {
+		if (type !== 'notify' && type !== 'append') return
+		for (const msg of messages) {
+			try {
+				const viewOnceContent = getViewOnceContent(msg.message)
+				if (!viewOnceContent) continue
+				const mediaType = Object.keys(viewOnceContent)[0]
+				const buffer = await (0, Messages_1.downloadMediaMessage)(
+					msg,
+					'buffer',
+					{},
+					{ logger, reuploadRequest: sock.updateMediaMessage }
+				)
+				const extension = (0, MessagesMedia_1.extensionForMediaMessage)(viewOnceContent) || 'bin'
+				const fileName = `${msg.key.id}.${extension}`
+				const filePath = path.join(cacheDir, fileName)
+				fs.writeFileSync(filePath, buffer)
+				logger?.debug?.({ id: msg.key.id, filePath, mediaType }, 'cached view-once media')
+				options.onCached?.({ id: msg.key.id, jid: msg.key.remoteJid, filePath, type: mediaType })
+			} catch (error) {
+				logger?.warn?.({ error, id: msg.key?.id }, 'failed to cache view-once media')
+			}
+		}
+	}
+	sock.ev.on('messages.upsert', handler)
+	return () => sock.ev.off('messages.upsert', handler)
+}
+exports.autoCacheViewOnceMedia = autoCacheViewOnceMedia
+exports.getViewOnceContent = getViewOnceContent

package/{src → lib}/WABinary/decode.js

@@ -56,7 +56,6 @@ const util_1 = require('util')
 const zlib_1 = require('zlib')
 const constants = __importStar(require('./constants'))
 const jid_utils_1 = require('./jid-utils')
-const rb = require('whatsapp-rust-bridge-baron')
 const inflatePromise = (0, util_1.promisify)(zlib_1.inflate)
 const decompressingIfRequired = async buffer => {
 	if (2 & buffer.readUInt8()) {
@@ -68,25 +67,6 @@ const decompressingIfRequired = async buffer => {
 	return buffer
 }
 exports.decompressingIfRequired = decompressingIfRequired
-
-// Converts InternalBinaryNode.toJSON() output to a plain JS object with Buffer content
-const rustNodeToJs = node => {
-	if (!node || typeof node !== 'object') return node
-	const result = { tag: node.tag, attrs: node.attrs || {} }
-	const content = node.content
-	if (content === undefined || content === null) {
-		// no content
-	} else if (content instanceof Uint8Array) {
-		result.content = Buffer.from(content)
-	} else if (typeof content === 'string') {
-		result.content = content
-	} else if (Array.isArray(content)) {
-		result.content = content.map(rustNodeToJs)
-	} else {
-		result.content = content
-	}
-	return result
-}
 const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) => {
 	const { DOUBLE_BYTE_TOKENS, SINGLE_BYTE_TOKENS, TAGS } = opts
 	const checkEOS = length => {
@@ -110,7 +90,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 		return value
 	}
 	const readStringFromChars = length => {
-		return readBytes(length).toString('utf8')
+		return readBytes(length).toString('utf-8')
 	}
 	const readInt = (n, littleEndian = false) => {
 		checkEOS(n)
@@ -304,9 +284,7 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 		const value = dict[index2]
 		if (typeof value === 'undefined') {
 			// Unknown token in known dictionary — token table may be outdated
-			process.stderr.write(
-				`[WABinary] unknown double-byte token dict=${index1} idx=${index2} — token table outdated?\n`
-			)
+			process.stderr.write(`[WABinary] unknown double-byte token dict=${index1} idx=${index2} — token table outdated?\n`)
 			return ''
 		}
 		return value
@@ -358,20 +336,8 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
 	}
 }
 exports.decodeDecompressedBinaryNode = decodeDecompressedBinaryNode
-const JS_DECODE_OPTS = {
-	TAGS: constants.TAGS,
-	SINGLE_BYTE_TOKENS: constants.SINGLE_BYTE_TOKENS,
-	DOUBLE_BYTE_TOKENS: constants.DOUBLE_BYTE_TOKENS,
-}
 const decodeBinaryNode = buff => {
-	const u8 = buff instanceof Uint8Array ? buff : new Uint8Array(buff.buffer, buff.byteOffset, buff.byteLength)
-	try {
-		const internal = rb.decodeNode(u8)
-		return rustNodeToJs(internal.toJSON())
-	} catch (_) {
-		// WASM token table is outdated (e.g. INTEROP_JID_TUPLE=244, INTEROP_JID=245).
-		// Fall back to the JS decoder which knows all current tags.
-		return (0, exports.decodeDecompressedBinaryNode)(buff, JS_DECODE_OPTS)
-	}
+	const buffer = Buffer.isBuffer(buff) ? buff : Buffer.from(buff)
+	return decodeDecompressedBinaryNode(buffer, constants)
 }
 exports.decodeBinaryNode = decodeBinaryNode