@badzz88/baileys 8.4.7 → 8.5.0

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/lib/Utils/sync-action-utils.js

@@ -1,49 +1,54 @@
-import { proto } from '../../WAProto/index.js';
-import { isLidUser, isPnUser } from '../WABinary/index.js';
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.emitSyncActionResults = exports.processContactAction = void 0
+const WABinary_1 = require('../WABinary')
 /**
  * Process contactAction and return events to emit.
  * Pure function - no side effects.
  */
-export const processContactAction = (action, id, logger) => {
-    const results = [];
-    if (!id) {
-        logger?.warn({ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid }, 'contactAction sync: missing id in index');
-        return results;
-    }
-    const lidJid = action.lidJid;
-    const idIsPn = isPnUser(id);
-    // PN is in index[1], not in contactAction.pnJid which is usually null
-    const phoneNumber = idIsPn ? id : action.pnJid || undefined;
-    // Always emit contacts.upsert
-    results.push({
-        event: 'contacts.upsert',
-        data: [
-            {
-                id,
-                name: action.fullName || action.firstName || action.username || undefined,
-                username: action.username || undefined,
-                lid: lidJid || undefined,
-                phoneNumber
-            }
-        ]
-    });
-    // Emit lid-mapping.update if we have valid LID-PN pair
-    if (lidJid && isLidUser(lidJid) && idIsPn) {
-        results.push({
-            event: 'lid-mapping.update',
-            data: { lid: lidJid, pn: id }
-        });
-    }
-    return results;
-};
-export const emitSyncActionResults = (ev, results) => {
-    for (const result of results) {
-        if (result.event === 'contacts.upsert') {
-            ev.emit('contacts.upsert', result.data);
-        }
-        else {
-            ev.emit('lid-mapping.update', result.data);
-        }
-    }
-};
-//# sourceMappingURL=sync-action-utils.js.map
+const processContactAction = (action, id, logger) => {
+	const results = []
+	if (!id) {
+		logger?.warn(
+			{ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid },
+			'contactAction sync: missing id in index'
+		)
+		return results
+	}
+	const lidJid = action.lidJid
+	const idIsPn = (0, WABinary_1.isPnUser)(id)
+	// PN is in index[1], not in contactAction.pnJid which is usually null
+	const phoneNumber = idIsPn ? id : action.pnJid || undefined
+	// Always emit contacts.upsert
+	results.push({
+		event: 'contacts.upsert',
+		data: [
+			{
+				id,
+				name: action.fullName || action.firstName || action.username || undefined,
+				username: action.username || undefined,
+				lid: lidJid || undefined,
+				phoneNumber
+			}
+		]
+	})
+	// Emit lid-mapping.update if we have valid LID-PN pair
+	if (lidJid && (0, WABinary_1.isLidUser)(lidJid) && idIsPn) {
+		results.push({
+			event: 'lid-mapping.update',
+			data: { lid: lidJid, pn: id }
+		})
+	}
+	return results
+}
+exports.processContactAction = processContactAction
+const emitSyncActionResults = (ev, results) => {
+	for (const result of results) {
+		if (result.event === 'contacts.upsert') {
+			ev.emit('contacts.upsert', result.data)
+		} else {
+			ev.emit('lid-mapping.update', result.data)
+		}
+	}
+}
+exports.emitSyncActionResults = emitSyncActionResults

package/lib/Utils/tc-token-utils.js

@@ -1,7 +1,18 @@
-import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.TC_TOKEN_INDEX_KEY = void 0
+exports.readTcTokenIndex = readTcTokenIndex
+exports.buildMergedTcTokenIndexWrite = buildMergedTcTokenIndexWrite
+exports.isTcTokenExpired = isTcTokenExpired
+exports.shouldSendNewTcToken = shouldSendNewTcToken
+exports.resolveTcTokenJid = resolveTcTokenJid
+exports.resolveIssuanceJid = resolveIssuanceJid
+exports.buildTcTokenFromJid = buildTcTokenFromJid
+exports.storeTcTokensFromIqResult = storeTcTokensFromIqResult
+const WABinary_1 = require('../WABinary')
 // Same phone-number pattern as WABinary's isJidBot, applied against the user
 // part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
-const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/
 /**
  * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
  * storage against malformed notifications — WA Web filters server-side but we
@@ -9,155 +20,142 @@ const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
  * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
  */
 function isRegularUser(jid) {
-    if (!jid)
-        return false;
-    const user = jid.split('@')[0] ?? '';
-    if (user === '0')
-        return false; // PSA
-    if (BOT_PHONE_REGEX.test(user))
-        return false; // Bot by phone pattern
-    if (isJidMetaAI(jid))
-        return false; // MetaAI (@bot server)
-    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+	if (!jid) return false
+	const user = jid.split('@')[0] ?? ''
+	if (user === '0') return false // PSA
+	if (BOT_PHONE_REGEX.test(user)) return false // Bot by phone pattern
+	if ((0, WABinary_1.isJidMetaAI)(jid)) return false // MetaAI (@bot server)
+	return !!(
+		(0, WABinary_1.isPnUser)(jid) ||
+		(0, WABinary_1.isLidUser)(jid) ||
+		(0, WABinary_1.isHostedPnUser)(jid) ||
+		(0, WABinary_1.isHostedLidUser)(jid) ||
+		jid.endsWith('@c.us')
+	)
 }
-const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
-const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+const TC_TOKEN_BUCKET_DURATION = 604800 // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4 // ~28-day rolling window
 /** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
-export const TC_TOKEN_INDEX_KEY = '__index';
+exports.TC_TOKEN_INDEX_KEY = '__index'
 /** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
-export async function readTcTokenIndex(keys) {
-    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
-    const entry = data[TC_TOKEN_INDEX_KEY];
-    if (!entry?.token?.length)
-        return [];
-    try {
-        const parsed = JSON.parse(Buffer.from(entry.token).toString());
-        if (!Array.isArray(parsed))
-            return [];
-        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
-    }
-    catch {
-        return [];
-    }
+async function readTcTokenIndex(keys) {
+	const data = await keys.get('tctoken', [exports.TC_TOKEN_INDEX_KEY])
+	const entry = data[exports.TC_TOKEN_INDEX_KEY]
+	if (!entry?.token?.length) return []
+	try {
+		const parsed = JSON.parse(Buffer.from(entry.token).toString())
+		if (!Array.isArray(parsed)) return []
+		return parsed.filter(j => typeof j === 'string' && j.length > 0 && j !== exports.TC_TOKEN_INDEX_KEY)
+	} catch {
+		return []
+	}
 }
 /** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
-export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
-    const persisted = await readTcTokenIndex(keys);
-    const merged = new Set(persisted);
-    for (const jid of addedJids) {
-        if (jid && jid !== TC_TOKEN_INDEX_KEY)
-            merged.add(jid);
-    }
-    return {
-        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
-    };
+async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+	const persisted = await readTcTokenIndex(keys)
+	const merged = new Set(persisted)
+	for (const jid of addedJids) {
+		if (jid && jid !== exports.TC_TOKEN_INDEX_KEY) merged.add(jid)
+	}
+	return {
+		[exports.TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+	}
 }
 // WA Web has separate sender/receiver AB props for these but they're identical today
-export function isTcTokenExpired(timestamp) {
-    if (timestamp === null || timestamp === undefined)
-        return true;
-    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);
-    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
-    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
-    return ts < cutoffTimestamp;
+function isTcTokenExpired(timestamp) {
+	if (timestamp === null || timestamp === undefined) return true
+	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)
+	const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1)
+	const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION
+	return ts < cutoffTimestamp
 }
-export function shouldSendNewTcToken(senderTimestamp) {
-    if (senderTimestamp === undefined)
-        return true;
-    const now = Math.floor(Date.now() / 1000);
-    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
-    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
-    return currentBucket > senderBucket;
+function shouldSendNewTcToken(senderTimestamp) {
+	if (senderTimestamp === undefined) return true
+	const now = Math.floor(Date.now() / 1000)
+	const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)
+	const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION)
+	return currentBucket > senderBucket
 }
 /** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
-export async function resolveTcTokenJid(jid, getLIDForPN) {
-    if (isLidUser(jid))
-        return jid;
-    const lid = await getLIDForPN(jid);
-    return lid ?? jid;
+async function resolveTcTokenJid(jid, getLIDForPN) {
+	if ((0, WABinary_1.isLidUser)(jid)) return jid
+	const lid = await getLIDForPN(jid)
+	return lid ?? jid
 }
 /** Resolve target JID for issuing privacy token based on AB prop 14303 */
-export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
-    if (issueToLid) {
-        if (isLidUser(jid))
-            return jid;
-        const lid = await getLIDForPN(jid);
-        return lid ?? jid;
-    }
-    if (!isLidUser(jid))
-        return jid;
-    if (getPNForLID) {
-        const pn = await getPNForLID(jid);
-        return pn ?? jid;
-    }
-    return jid;
+async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+	if (issueToLid) {
+		if ((0, WABinary_1.isLidUser)(jid)) return jid
+		const lid = await getLIDForPN(jid)
+		return lid ?? jid
+	}
+	if (!(0, WABinary_1.isLidUser)(jid)) return jid
+	if (getPNForLID) {
+		const pn = await getPNForLID(jid)
+		return pn ?? jid
+	}
+	return jid
 }
-export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
-    try {
-        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
-        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
-        const entry = tcTokenData?.[storageJid];
-        const tcTokenBuffer = entry?.token;
-        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
-            if (tcTokenBuffer) {
-                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
-                // after we drop the unusable peer token. Only wipe the record entirely when
-                // there's nothing worth keeping.
-                const cleared = entry?.senderTimestamp !== undefined
-                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
-                    : null;
-                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
-            }
-            return baseContent.length > 0 ? baseContent : undefined;
-        }
-        baseContent.push({
-            tag: 'tctoken',
-            attrs: {},
-            content: tcTokenBuffer
-        });
-        return baseContent;
-    }
-    catch (error) {
-        return baseContent.length > 0 ? baseContent : undefined;
-    }
+async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+	try {
+		const storageJid = await resolveTcTokenJid(jid, getLIDForPN)
+		const tcTokenData = await authState.keys.get('tctoken', [storageJid])
+		const entry = tcTokenData?.[storageJid]
+		const tcTokenBuffer = entry?.token
+		if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+			if (tcTokenBuffer) {
+				// Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+				// after we drop the unusable peer token. Only wipe the record entirely when
+				// there's nothing worth keeping.
+				const cleared =
+					entry?.senderTimestamp !== undefined
+						? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+						: null
+				await authState.keys.set({ tctoken: { [storageJid]: cleared } })
+			}
+			return baseContent.length > 0 ? baseContent : undefined
+		}
+		baseContent.push({
+			tag: 'tctoken',
+			attrs: {},
+			content: tcTokenBuffer
+		})
+		return baseContent
+	} catch (error) {
+		return baseContent.length > 0 ? baseContent : undefined
+	}
 }
-export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
-    const tokensNode = getBinaryNodeChild(result, 'tokens');
-    if (!tokensNode)
-        return;
-    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
-    for (const tokenNode of tokenNodes) {
-        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
-            continue;
-        }
-        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
-        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
-        if (!isRegularUser(rawJid))
-            continue;
-        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
-        const existingTcData = await keys.get('tctoken', [storageJid]);
-        const existingEntry = existingTcData[storageJid];
-        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
-        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
-        // timestamp-less tokens would be immediately expired
-        if (!incomingTs)
-            continue;
-        if (existingTs > 0 && existingTs > incomingTs)
-            continue;
-        await keys.set({
-            tctoken: {
-                [storageJid]: {
-                    ...existingEntry,
-                    token: Buffer.from(tokenNode.content),
-                    timestamp: tokenNode.attrs.t
-                }
-            }
-        });
-        onNewJidStored?.(storageJid);
-    }
+async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+	const tokensNode = (0, WABinary_1.getBinaryNodeChild)(result, 'tokens')
+	if (!tokensNode) return
+	const tokenNodes = (0, WABinary_1.getBinaryNodeChildren)(tokensNode, 'token')
+	for (const tokenNode of tokenNodes) {
+		if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+			continue
+		}
+		// In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+		const rawJid = (0, WABinary_1.jidNormalizedUser)(fallbackJid || tokenNode.attrs.jid)
+		if (!isRegularUser(rawJid)) continue
+		const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN)
+		const existingTcData = await keys.get('tctoken', [storageJid])
+		const existingEntry = existingTcData[storageJid]
+		const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0
+		const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0
+		// timestamp-less tokens would be immediately expired
+		if (!incomingTs) continue
+		if (existingTs > 0 && existingTs > incomingTs) continue
+		await keys.set({
+			tctoken: {
+				[storageJid]: {
+					...existingEntry,
+					token: Buffer.from(tokenNode.content),
+					timestamp: tokenNode.attrs.t
+				}
+			}
+		})
+		onNewJidStored?.(storageJid)
+	}
 }
-//# sourceMappingURL=tc-token-utils.js.map