@itsliaaa/baileys 0.1.32 → 0.2.0

package/lib/Utils/decode-wa-message.js

@@ -33,6 +33,7 @@ export const DECRYPTION_RETRY_CONFIG = {
     baseDelayMs: 100,
     sessionRecordErrors: ['No session record', 'SessionError: No session record']
 };
+/** NACK reason codes we send to the server (client → server) */
 export const NACK_REASONS = {
     ParsingError: 487,
     UnrecognizedStanza: 488,
@@ -48,6 +49,17 @@ export const NACK_REASONS = {
     UnsupportedLIDGroup: 551,
     DBOperationFailed: 552
 };
+/**
+ * Server-side error codes returned in ack stanzas (server → client) that we
+ * currently have dedicated handlers for. Extend as more handlers are added.
+ * Distinct from the client-side NackReason enum (WAWebCreateNackFromStanza).
+ */
+export const SERVER_ERROR_CODES = {
+    /** 1:1 message missing privacy token (tctoken) */
+    MissingTcToken: '463',
+    /** Stanza validation failure (SMAX_INVALID) — likely stale device session */
+    SmaxInvalid: '479'
+};
 export const extractAddressingContext = (stanza) => {
     let senderAlt;
     let recipientAlt;
@@ -148,10 +160,12 @@ export function decodeMessageNode(stanza, meId, meLid) {
     const key = {
         remoteJid: chatId,
         remoteJidAlt: !isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+        remoteJidUsername: !isJidGroup(chatId) ? stanza.attrs.peer_recipient_username || stanza.attrs.recipient_username : undefined,
         fromMe,
         id: msgId,
         participant,
         participantAlt: isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+        participantUsername: stanza.attrs.participant ? stanza.attrs.participant_username : undefined,
         addressingMode: addressingContext.addressingMode,
         ...(msgType === 'newsletter' && stanza.attrs.server_id ? { server_id: stanza.attrs.server_id } : {})
     };

package/lib/Utils/event-buffer.js

@@ -252,6 +252,7 @@ eventData, logger) {
             data.historySets.empty = false;
             data.historySets.syncType = eventData.syncType;
             data.historySets.progress = eventData.progress;
+            data.historySets.chunkOrder = eventData.chunkOrder;
             data.historySets.peerDataRequestSessionId = eventData.peerDataRequestSessionId;
             data.historySets.isLatest = eventData.isLatest || data.historySets.isLatest;
             break;
@@ -519,6 +520,7 @@ function consolidateEvents(data) {
             syncType: data.historySets.syncType,
             progress: data.historySets.progress,
             isLatest: data.historySets.isLatest,
+            chunkOrder: data.historySets.chunkOrder,
             peerDataRequestSessionId: data.historySets.peerDataRequestSessionId
         };
     }

package/lib/Utils/generics.js

@@ -316,6 +316,15 @@ export const getCallStatusFromNode = ({ tag, attrs }) => {
                 status = 'terminate';
             }
             break;
+        case 'preaccept':
+            status = 'preaccept';
+            break;
+        case 'transport':
+            status = 'transport';
+            break;
+        case 'relaylatency':
+            status = 'relaylatency';
+            break;
         case 'reject':
             status = 'reject';
             break;

package/lib/Utils/history.js

@@ -1,5 +1,6 @@
+import { pipeline } from 'stream/promises';
 import { promisify } from 'util';
-import { inflate } from 'zlib';
+import { createInflate, inflate } from 'zlib';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageStubType } from '../Types/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
@@ -24,13 +25,13 @@ const extractPnFromMessages = (messages) => {
 };
 export const downloadHistory = async (msg, options) => {
     const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
-    const bufferArray = [];
-    for await (const chunk of stream) {
-        bufferArray.push(chunk);
-    }
-    let buffer = Buffer.concat(bufferArray);
-    // decompress buffer
-    buffer = await inflatePromise(buffer);
+    // Pipe decrypted stream directly through zlib inflate
+    // This avoids allocating an intermediate buffer for the compressed data
+    const inflater = createInflate();
+    const chunks = [];
+    inflater.on('data', (chunk) => chunks.push(chunk));
+    await pipeline(stream, inflater);
+    const buffer = Buffer.concat(chunks);
     const syncData = proto.HistorySync.decode(buffer);
     return syncData;
 };
@@ -55,6 +56,7 @@ export const processHistoryMessage = (item, logger) => {
                 contacts.push({
                     id: chat.id,
                     name: chat.displayName || chat.name || chat.username || undefined,
+                    username: chat.username || undefined,
                     lid: chat.lidJid || chat.accountLid || undefined,
                     phoneNumber: chat.pnJid || undefined
                 });
@@ -95,7 +97,7 @@ export const processHistoryMessage = (item, logger) => {
                         });
                     }
                 }
-                chats.push({ ...chat });
+                chats.push(chat);
             }
             break;
         case proto.HistorySync.HistorySyncType.PUSH_NAME:

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

@@ -37,6 +37,7 @@ export async function handleIdentityChange(node, ctx) {
         ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
         return { action: 'skipped_offline' };
     }
+    ctx.onBeforeSessionRefresh?.(from);
     try {
         await ctx.assertSessions([from], true);
         return { action: 'session_refreshed' };

package/lib/Utils/messages-media.js

@@ -516,7 +516,7 @@ export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, {
     };
     const output = new Transform({
         transform(chunk, _, callback) {
-            let data = Buffer.concat([remainingBytes, chunk]);
+            let data = remainingBytes.length ? Buffer.concat([remainingBytes, chunk]) : chunk;
             const decryptLength = toSmallestChunkSize(data.length);
             remainingBytes = data.slice(decryptLength);
             data = data.slice(0, decryptLength);

package/lib/Utils/messages.js

@@ -657,6 +657,7 @@ export const generateWAMessageContent = async (message, options) => {
     else if (hasNonNullishProperty(message, 'code') ||
         hasNonNullishProperty(message, 'expressions') ||
         hasNonNullishProperty(message, 'items') ||
+        hasNonNullishProperty(message, 'links') ||
         hasNonNullishProperty(message, 'table') ||
         hasNonNullishProperty(message, 'richResponse')) {
         m = prepareRichResponseMessage(message);
@@ -673,6 +674,7 @@ export const generateWAMessageContent = async (message, options) => {
             extContent.description = urlInfo.description;
             extContent.title = urlInfo.title;
             extContent.previewType = urlInfo.previewType ?? 0;
+            extContent.linkPreviewMetadata = urlInfo.linkPreviewMetadata;
             const img = urlInfo.highQualityThumbnail;
             if (img) {
                 extContent.thumbnailDirectPath = img.directPath;
@@ -684,6 +686,19 @@ export const generateWAMessageContent = async (message, options) => {
                 extContent.thumbnailEncSha256 = img.fileEncSha256;
             }
         }
+        let faviconInfo = message.favicon;
+        if (faviconInfo) {
+            faviconInfo = await generateWAMessageMedia(faviconInfo, options);
+            extContent.faviconMMSMetadata = {
+                thumbnailDirectPath: faviconInfo.directPath,
+                mediaKey: faviconInfo.mediaKey,
+                mediaKeyTimestamp: faviconInfo.mediaKeyTimestamp,
+                thumbnailWidth: 32,
+                thumbnailHeight: 32,
+                thumbnailSha256: faviconInfo.fileSha256,
+                thumbnailEncSha256: faviconInfo.fileEncSha256
+            };
+        }
         if (options.backgroundColor) {
             extContent.backgroundArgb = await assertColor(options.backgroundColor);
         }
@@ -1270,12 +1285,6 @@ export const generateWAMessageContent = async (message, options) => {
         }
         m = { invoiceMessage };
     }
-    if (shouldIncludeReportingToken(m)) {
-        m.messageContextInfo = m.messageContextInfo || {};
-        if (!m.messageContextInfo.messageSecret) {
-            m.messageContextInfo.messageSecret = randomBytes(32);
-        }
-    }
     // Lia@Changes 31-01-26 --- Add direct externalAdReply access (no need to create contextInfo first)
     if (hasOptionalProperty(message, 'externalAdReply') && !!message.externalAdReply) {
         const messageType = Object.keys(m)[0];
@@ -1391,6 +1400,12 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
+    if (shouldIncludeReportingToken(m)) {
+        m.messageContextInfo = m.messageContextInfo || {};
+        if (!m.messageContextInfo.messageSecret) {
+            m.messageContextInfo.messageSecret = randomBytes(32);
+        }
+    }
     return proto.Message.create(m);
 };
 export const generateWAMessageFromContent = (jid, message, options) => {

package/lib/Utils/process-message.js

@@ -5,6 +5,7 @@ import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJid
 import { aesDecryptGCM, hmacSign } from './crypto.js';
 import { getKeyAuthor, toNumber } from './generics.js';
 import { downloadAndProcessHistorySyncNotification } from './history.js';
+import { buildMergedTcTokenIndexWrite, resolveTcTokenJid } from './tc-token-utils.js';
 const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_GROUP_VIDEO,
     WAMessageStubType.CALL_MISSED_GROUP_VOICE,
@@ -12,6 +13,53 @@ const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_VOICE
 ]);
 const REAL_MSG_REQ_ME_STUB_TYPES = new Set([WAMessageStubType.GROUP_PARTICIPANT_ADD]);
+async function storeTcTokensFromHistorySync(chats, signalRepository, keyStore, logger) {
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
+    const candidates = [];
+    for (const chat of chats) {
+        const ts = chat.tcTokenTimestamp ? toNumber(chat.tcTokenTimestamp) : 0;
+        if (chat.tcToken?.length && ts > 0) {
+            const jid = jidNormalizedUser(chat.id);
+            const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+            candidates.push({
+                storageJid,
+                token: Buffer.from(chat.tcToken),
+                ts,
+                senderTs: chat.tcTokenSenderTimestamp ? toNumber(chat.tcTokenSenderTimestamp) : undefined
+            });
+        }
+    }
+    if (!candidates.length) {
+        return;
+    }
+    const jids = candidates.map(c => c.storageJid);
+    const existing = await keyStore.get('tctoken', jids);
+    const entries = {};
+    for (const c of candidates) {
+        const existingEntry = existing[c.storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        if (existingTs > 0 && existingTs >= c.ts) {
+            continue;
+        }
+        entries[c.storageJid] = {
+            ...existingEntry,
+            token: c.token,
+            timestamp: String(c.ts),
+            ...(c.senderTs !== undefined ? { senderTimestamp: c.senderTs } : {})
+        };
+    }
+    if (Object.keys(entries).length) {
+        logger?.debug({ count: Object.keys(entries).length }, 'storing tctokens from history sync');
+        try {
+            // Include updated __index so cross-session pruning picks these JIDs up.
+            const indexWrite = await buildMergedTcTokenIndexWrite(keyStore, Object.keys(entries));
+            await keyStore.set({ tctoken: { ...entries, ...indexWrite } });
+        }
+        catch (err) {
+            logger?.warn({ err }, 'failed to store tctokens from history sync');
+        }
+    }
+};
 /** Cleans a received message to further processing */
 export const cleanMessage = (message, meId, meLid) => {
     // ensure remoteJid and participant doesn't have device or agent in it
@@ -174,9 +222,11 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                             .storeLIDPNMappings(data.lidPnMappings)
                             .catch(err => logger?.warn({ err }, 'failed to store LID-PN mappings from history sync'));
                     }
+                    await storeTcTokensFromHistorySync(data.chats, signalRepository, keyStore, logger);
                     ev.emit('messaging-history.set', {
                         ...data,
                         isLatest: histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND ? isLatest : undefined,
+                        chunkOrder: histNotification.chunkOrder,
                         peerDataRequestSessionId: histNotification.peerDataRequestSessionId
                     });
                 }
@@ -383,12 +433,13 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             id: jid,
             author: message.key.participant,
             authorPn: message.key.participantAlt,
+            authorUsername: message.key.participantUsername,
             participants,
             action
         });
         const emitGroupUpdate = (update) => {
             ev.emit('groups.update', [
-                { id: jid, ...update, author: message.key.participant ?? undefined, authorPn: message.key.participantAlt }
+                { id: jid, ...update, author: message.key.participant ?? undefined, authorPn: message.key.participantAlt, authorUsername: message.key.participantUsername }
             ]);
         };
         const emitGroupRequestJoin = (participant, action, method) => {
@@ -396,6 +447,7 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                 id: jid,
                 author: message.key.participant,
                 authorPn: message.key.participantAlt,
+                authorUsername: message.key.participantUsername,
                 participant: participant.lid,
                 participantPn: participant.pn,
                 action,

package/lib/Utils/rich-message-utils.js

@@ -11,7 +11,6 @@ import { LANGUAGE_KEYWORDS } from '../WABinary/constants.js';
 import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
 import { proto } from '../../WAProto/index.js';
 import { unixTimestampSeconds } from './generics.js';
-const textEncoder = new TextEncoder();
 const NOOP = new Set([]);
 export const tokenizeCode = (code, language = 'javascript') => {
     const keywords = LANGUAGE_KEYWORDS[language] || NOOP;
@@ -121,33 +120,11 @@ export const toUnified = (submessages) =>
                         }
                     };
                 case RichSubMessageType.TEXT:
-                    const shouldAddInlineEntity = index == 0;
-                    const inlineEntity = [{
-                        key: 'Starseed',
-                        metadata: {
-                            reference_id: 1,
-                            reference_url: DONATE_URL,
-                            reference_title: 'For Donation via Saweria',
-                            reference_display_name: 'Donate',
-                            sources: [{
-                                source_type: 'THIRD_PARTY',
-                                source_display_name: 'Donate',
-                                source_subtitle: '',
-                                source_url: DONATE_URL
-                            }],
-                            __typename: 'GenAISearchCitationItem'
-                        }
-                    }];
-                    const textEntity = shouldAddInlineEntity ?
-                        '{{Starseed}}¹{{/Starseed}}' :
-                        '';
                     return {
                         view_model: {
                             primitive: {
-                                text: submessage.messageText + textEntity,
-                                inline_entities: shouldAddInlineEntity ?
-                                    inlineEntity :
-                                    [],
+                                text: submessage.messageText,
+                                inline_entities: submessage.inlineEntities || [],
                                 __typename: 'GenAIMarkdownTextUXPrimitive'
                             },
                             __typename: 'GenAISingleLayoutViewModel'
@@ -212,14 +189,15 @@ export const buildAdditionalBotMetadataContext = (submessages) => {
     return { sources, mediaDetailsMetadataList };
 }
 export const prepareRichResponseMessage = (content) => {
-    const { code, contentText, expressions, footerText, headerText, items, language, richResponse, table, text, title } = content;
+    const { code, contentText, expressions, footerText, headerText, items, language, links, noHeading, richResponse, table, text, title } = content;
     let submessages = [];
     if (Array.isArray(richResponse)) {
         submessages = richResponse.map((submessage) => {
             if (submessage.text) {
                 return {
                     messageType: RichSubMessageType.TEXT,
-                    messageText: submessage.text
+                    messageText: submessage.text,
+                    inlineEntities: submessage.inlineEntities
                 };
             }
             else if (submessage.code) {
@@ -301,16 +279,42 @@ export const prepareRichResponseMessage = (content) => {
                 }
             });
         }
+        else if (links) {
+            links.forEach((linkField, index) => {
+                const prefix = 'SS_' + index;
+                const url = linkField.url || DONATE_URL;
+                const sources = linkField.sources?.map((sourceField) => ({
+                    source_type: 'THIRD_PARTY',
+                    source_display_name: sourceField.displayName || 'Donate',
+                    source_subtitle: sourceField.subtitle || 'Saweria',
+                    source_url: sourceField.url || url
+                }));
+                submessages.push({
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: linkField.text + ` {{${prefix}}}¹{{/${prefix}}} `,
+                    inlineEntities: [{
+                        key: prefix,
+                        metadata: {
+                            reference_id: index + 1,
+                            reference_url: url,
+                            reference_title: linkField.title || 'For Donation via Saweria',
+                            reference_display_name: linkField.displayName || 'Donation',
+                            sources: sources || [],
+                            __typename: 'GenAISearchCitationItem'
+                        }
+                    }]
+                });
+            });
+        }
         else if (table) {
-            const tableRows = table.map((items, index) => ({
-                isHeading: index == 0,
-                items
-            }));
             submessages.push({
                 messageType: RichSubMessageType.TABLE,
                 tableMetadata: {
                     title,
-                    rows: tableRows
+                    rows: table.map((items, index) => ({
+                        isHeading: !noHeading && index == 0,
+                        items
+                    }))
                 }
             });
         }
@@ -323,16 +327,17 @@ export const prepareRichResponseMessage = (content) => {
     }
     const unified = toUnified(submessages);
     const message = wrapToBotForwardedMessage({
-        submessages,
+        submessages: [],
         messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
         unifiedResponse: {
-            data: textEncoder.encode(JSON.stringify(unified))
+            data: Buffer.from(JSON.stringify(unified), 'utf-8') // Lia@Note 25-04-26 --- Expects "ArrayBufferLike"
         },
         contextInfo: {
             isForwarded: true,
             forwardingScore: 1,
             forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
-            forwardOrigin: 4
+            forwardOrigin: 4,
+            botMessageSharingInfo: { forwardScore: 1 }
         }
     });
     // Lia@Note 17-04-26 --- TODO: Fill mediaDetailsMetadataList and sources field

package/lib/Utils/sync-action-utils.js

@@ -21,6 +21,7 @@ export const processContactAction = (action, id, logger) => {
             {
                 id,
                 name: action.fullName || action.firstName || action.username || undefined,
+                username: action.username || undefined,
                 lid: lidJid || undefined,
                 phoneNumber
             }

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

@@ -1,9 +1,119 @@
-export async function buildTcTokenFromJid({ authState, jid, baseContent = [] }) {
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+// 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}$/;
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * 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'));
+}
+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';
+/** 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 tcTokenData = await authState.keys.get('tctoken', [jid]);
-        const tcTokenBuffer = tcTokenData?.[jid]?.token;
-        if (!tcTokenBuffer)
+        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 [];
+    }
+}
+/** 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])) }
+    };
+}
+// 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;
+}
+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;
+}
+/** 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;
+}
+/** 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;
+}
+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: {},
@@ -14,4 +124,40 @@ export async function buildTcTokenFromJid({ authState, jid, 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);
+    }
+}
+//# sourceMappingURL=tc-token-utils.js.map