@itsliaaa/baileys 0.1.32 → 0.2.0

package/lib/Socket/messages-recv.js

@@ -5,17 +5,19 @@ import Long from 'long';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT, PLACEHOLDER_MAX_AGE_SECONDS, STATUS_EXPIRY_SECONDS } from '../Defaults/index.js';
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
-import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, handleIdentityChange, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, toNumber, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, handleIdentityChange, hkdf, MISSING_KEYS_ERROR_TEXT, SERVER_ERROR_CODES, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, toNumber, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import { makeOfflineNodeProcessor } from '../Utils/offline-node-processor.js';
 import { buildAckStanza } from '../Utils/stanza-ack.js';
+import { buildMergedTcTokenIndexWrite, isTcTokenExpired, readTcTokenIndex, resolveIssuanceJid, resolveTcTokenJid, storeTcTokensFromIqResult, TC_TOKEN_INDEX_KEY } from '../Utils/tc-token-utils.js';
 import { areJidsSameUser, binaryNodeToString, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
 import { makeMessagesSocket } from './messages-send.js';
 export const makeMessagesRecvSocket = (config) => {
     const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid, enableAutoSessionRecreation } = config;
     const sock = makeMessagesSocket(config);
-    const { ev, authState, ws, messageMutex, notificationMutex, receiptMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, generateMessageTag, messageRetryManager, registerSocketEndHandler } = sock;
+    const { ev, authState, ws, messageMutex, notificationMutex, receiptMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, generateMessageTag, messageRetryManager, issuePrivacyTokens, registerSocketEndHandler } = sock;
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     const devicesMutex = makeMutex();
@@ -473,6 +475,40 @@ export const makeMessagesRecvSocket = (config) => {
             logger.info({ msgAttrs: node.attrs, retryCount }, 'sent retry receipt');
         }, authState?.creds?.me?.id || 'sendRetryRequest');
     };
+    /**
+     * Fire-and-forget tctoken re-issuance after a peer's device identity changed.
+     * Mirrors WAWebSendTcTokenWhenDeviceIdentityChange — runs in parallel with
+     * the session refresh (not after it).
+     */
+    const reissueTcTokenAfterIdentityChange = (from) => {
+        void (async () => {
+            const normalizedJid = jidNormalizedUser(from);
+            const tcJid = await resolveTcTokenJid(normalizedJid, getLIDForPN);
+            const tcTokenData = await authState.keys.get('tctoken', [tcJid]);
+            const senderTs = tcTokenData?.[tcJid]?.senderTimestamp;
+            if (senderTs === null || senderTs === undefined || isTcTokenExpired(senderTs)) {
+                return;
+            }
+            logger.debug({ jid: normalizedJid, senderTimestamp: senderTs }, 'identity changed, re-issuing tctoken');
+            const getPNForLID = signalRepository.lidMapping.getPNForLID.bind(signalRepository.lidMapping);
+            const issueJid = await resolveIssuanceJid(
+                normalizedJid,
+                sock.serverProps.lidTrustedTokenIssueToLid,
+                getLIDForPN,
+                getPNForLID
+            );
+            const result = await issuePrivacyTokens([issueJid], senderTs);
+            await storeTcTokensFromIqResult({
+                result,
+                fallbackJid: tcJid,
+                keys: authState.keys,
+                getLIDForPN,
+                onNewJidStored: trackTcTokenJid
+            });
+        })().catch(err => {
+            logger.debug({ jid: from, err: err?.message }, 'failed to re-issue tctoken after identity change');
+        });
+    };
     const handleEncryptNotification = async (node) => {
         const from = node.attrs.from;
         if (from === S_WHATSAPP_NET) {
@@ -491,7 +527,8 @@ export const makeMessagesRecvSocket = (config) => {
                 validateSession: signalRepository.validateSession,
                 assertSessions,
                 debounceCache: identityAssertDebounce,
-                logger
+                logger,
+                onBeforeSessionRefresh: reissueTcTokenAfterIdentityChange
             });
             if (result.action === 'no_identity_node') {
                 logger.info({ node }, 'unknown encrypt notification');
@@ -502,6 +539,7 @@ export const makeMessagesRecvSocket = (config) => {
         // TODO: Support PN/LID (Here is only LID now)
         const actingParticipantLid = fullNode.attrs.participant;
         const actingParticipantPn = fullNode.attrs.participant_pn;
+        const actingParticipantUsername = fullNode.attrs.participant_username;
         const affectedParticipantLid = getBinaryNodeChild(child, 'participant')?.attrs?.jid || actingParticipantLid;
         const affectedParticipantPn = getBinaryNodeChild(child, 'participant')?.attrs?.phone_number || actingParticipantPn;
         switch (child?.tag) {
@@ -521,7 +559,8 @@ export const makeMessagesRecvSocket = (config) => {
                     {
                         ...metadata,
                         author: actingParticipantLid,
-                        authorPn: actingParticipantPn
+                        authorPn: actingParticipantPn,
+                        authorUsername: actingParticipantUsername
                     }
                 ]);
                 break;
@@ -552,6 +591,7 @@ export const makeMessagesRecvSocket = (config) => {
                         id: attrs.jid,
                         phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
                         lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+                        username: attrs.participant_username || attrs.username || undefined,
                         admin: (attrs.type || null)
                     };
                 });
@@ -834,27 +874,70 @@ export const makeMessagesRecvSocket = (config) => {
             return result;
         }
     };
+    /**
+     * In-memory cache of storage JIDs with stored tctokens, seeded from the persisted index.
+     * Used to coalesce writes during a session; pruning always re-reads the persisted index
+     * to cover writes made by other layers (e.g. history sync).
+     */
+    const tcTokenKnownJids = new Set();
+    const tcTokenIndexLoaded = (async () => {
+        try {
+            const jids = await readTcTokenIndex(authState.keys);
+            for (const jid of jids) {
+                tcTokenKnownJids.add(jid);
+            }
+            logger.debug({ count: tcTokenKnownJids.size }, 'loaded tctoken index');
+        }
+        catch (err) {
+            logger.warn({ err: err?.message }, 'failed to load tctoken index');
+        }
+    })();
+    let tcTokenIndexTimer;
+    async function flushTcTokenIndex() {
+        if (tcTokenIndexTimer) {
+            clearTimeout(tcTokenIndexTimer);
+            tcTokenIndexTimer = undefined;
+        }
+        // Merge with whatever is already persisted so we don't clobber writes from other
+        // paths (history sync, concurrent sessions on the same store).
+        const write = await buildMergedTcTokenIndexWrite(authState.keys, tcTokenKnownJids);
+        return authState.keys.set({ tctoken: write });
+    };
+    function scheduleTcTokenIndexSave() {
+        if (tcTokenIndexTimer) {
+            clearTimeout(tcTokenIndexTimer);
+        }
+        tcTokenIndexTimer = setTimeout(() => {
+            tcTokenIndexTimer = undefined;
+            flushTcTokenIndex().catch(err => {
+                logger.warn({ err: err?.message }, 'failed to save tctoken index');
+            });
+        }, 5000);
+    };
+    function trackTcTokenJid(jid) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY && !tcTokenKnownJids.has(jid)) {
+            tcTokenKnownJids.add(jid);
+            scheduleTcTokenIndexSave();
+        }
+    }
     const handlePrivacyTokenNotification = async (node) => {
         const tokensNode = getBinaryNodeChild(node, 'tokens');
+        if (!tokensNode) return;
         const from = jidNormalizedUser(node.attrs.from);
-        if (!tokensNode)
-            return;
-        const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
-        for (const tokenNode of tokenNodes) {
-            const { attrs, content } = tokenNode;
-            const type = attrs.type;
-            const timestamp = attrs.t;
-            if (type === 'trusted_contact' && content instanceof Buffer) {
-                logger.debug({
-                    from,
-                    timestamp,
-                    tcToken: content
-                }, 'received trusted contact token');
-                await authState.keys.set({
-                    tctoken: { [from]: { token: content, timestamp } }
-                });
-            }
-        }
+        // WA Web uses: senderLid ?? toLid(from) for the storage key
+        // The sender_lid attribute provides the LID directly when available
+        const senderLid = node.attrs.sender_lid && isLidUser(jidNormalizedUser(node.attrs.sender_lid))
+            ? jidNormalizedUser(node.attrs.sender_lid)
+				: undefined;
+        const fallbackJid = senderLid ?? (await resolveTcTokenJid(from, getLIDForPN));
+        logger.debug({ from, storageJid: fallbackJid }, 'processing privacy token notification');
+        await storeTcTokensFromIqResult({
+            result: node,
+            fallbackJid,
+            keys: authState.keys,
+            getLIDForPN,
+            onNewJidStored: trackTcTokenJid
+        });
     };
     async function decipherLinkPublicKey(data) {
         const buffer = toRequiredBuffer(data);
@@ -973,11 +1056,6 @@ export const makeMessagesRecvSocket = (config) => {
             fromMe,
             participant: attrs.participant
         };
-        if (shouldIgnoreJid(remoteJid) && remoteJid !== S_WHATSAPP_NET) {
-            logger.debug({ remoteJid }, 'ignoring receipt from jid');
-            await sendMessageAck(node);
-            return;
-        }
         const ids = [attrs.id];
         if (Array.isArray(content)) {
             const items = getBinaryNodeChildren(content[0], 'item');
@@ -1042,11 +1120,6 @@ export const makeMessagesRecvSocket = (config) => {
     };
     const handleNotification = async (node) => {
         const remoteJid = node.attrs.from;
-        if (shouldIgnoreJid(remoteJid) && remoteJid !== S_WHATSAPP_NET) {
-            logger.debug({ remoteJid, id: node.attrs.id }, 'ignored notification');
-            await sendMessageAck(node);
-            return;
-        }
         try {
             await Promise.all([
                 notificationMutex.mutex(async () => {
@@ -1059,6 +1132,7 @@ export const makeMessagesRecvSocket = (config) => {
                             fromMe,
                             participant: node.attrs.participant,
                             participantAlt,
+                            username: attrs.participant_username || attrs.username || undefined,
                             addressingMode,
                             id: node.attrs.id,
                             ...(msg.key || {})
@@ -1076,11 +1150,6 @@ export const makeMessagesRecvSocket = (config) => {
         }
     };
     const handleMessage = async (node) => {
-        if (shouldIgnoreJid(node.attrs.from) && node.attrs.from !== S_WHATSAPP_NET) {
-            logger.debug({ key: node.attrs.key }, 'ignored message');
-            await sendMessageAck(node, NACK_REASONS.UnhandledError);
-            return;
-        }
         const encNode = getBinaryNodeChild(node, 'enc');
         // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
         if (encNode?.attrs.type === 'msmsg') {
@@ -1298,6 +1367,13 @@ export const makeMessagesRecvSocket = (config) => {
                 offline: !!attrs.offline,
                 status
             };
+            if (status === 'relaylatency') {
+                const latencyValue = infoChild.attrs.latency || infoChild.attrs['latency_ms'] || infoChild.attrs['latency-ms'];
+                const latencyMs = latencyValue ? Number(latencyValue) : undefined;
+                if (Number.isFinite(latencyMs)) {
+                    call.latencyMs = latencyMs;
+                }
+            }
             if (status === 'offer') {
                 call.isVideo = !!getBinaryNodeChild(infoChild, 'video');
                 call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid'];
@@ -1342,7 +1418,19 @@ export const makeMessagesRecvSocket = (config) => {
         // error in acknowledgement,
         // device could not display the message
         if (attrs.error) {
-            logger.warn({ attrs }, 'received error in ack');
+            if (attrs.error === SERVER_ERROR_CODES.MissingTcToken) {
+                // 463 = account restricted + no tctoken for this contact.
+                // WA Web prevents this client-side (disables compose bar).
+                // No retry — retrying worsens the restriction by counting
+                // as another "reach out" to an unknown contact.
+                logger.warn({ msgId: attrs.id, from: attrs.from }, 'error 463: account restricted or missing tctoken for contact');
+            }
+            else if (attrs.error === SERVER_ERROR_CODES.SmaxInvalid) {
+                logger.warn({ msgId: attrs.id, from: attrs.from }, 'smax-invalid (479): stanza rejected by server — likely stale device session or malformed addressing');
+            }
+            else {
+                logger.warn({ attrs }, 'received error in ack');
+            }
             ev.emit('messages.update', [
                 {
                     key,
@@ -1352,19 +1440,6 @@ export const makeMessagesRecvSocket = (config) => {
                     }
                 }
             ]);
-            // resend the message with device_fanout=false, use at your own risk
-            // if (attrs.error === '475') {
-            // 	const msg = await getMessage(key)
-            // 	if (msg) {
-            // 		await relayMessage(key.remoteJid!, msg, {
-            // 			messageId: key.id!,
-            // 			useUserDevicesCache: false,
-            // 			additionalAttributes: {
-            // 				device_fanout: 'false'
-            // 			}
-            // 		})
-            // 	}
-            // }
         }
     };
     /// processes a node with the given function
@@ -1388,6 +1463,22 @@ export const makeMessagesRecvSocket = (config) => {
         yieldToEventLoop: () => new Promise(resolve => setImmediate(resolve))
     });
     const processNode = async (type, node, identifier, exec) => {
+        // Fast path: ack and drop ignored JIDs before entering the buffer/queue
+        const from = node.attrs.from;
+        let ignoreJid = from;
+        if (type === 'receipt' && from) {
+            const attrs = node.attrs;
+            const isLid = attrs.from.includes('lid');
+            const isNodeFromMe = areJidsSameUser(
+                 attrs.participant || attrs.from,
+                 isLid ? authState.creds.me?.lid : authState.creds.me?.id
+             );
+             ignoreJid = !isNodeFromMe || isJidGroup(attrs.from) ? attrs.from : attrs.recipient;
+        }
+        if (ignoreJid && ignoreJid !== S_WHATSAPP_NET && shouldIgnoreJid(ignoreJid)) {
+            await sendMessageAck(node, type === 'message' ? NACK_REASONS.UnhandledError : undefined);
+            return;
+        }
         const isOffline = !!node.attrs.offline;
         if (isOffline) {
             offlineNodeProcessor.enqueue(type, node);
@@ -1443,12 +1534,98 @@ export const makeMessagesRecvSocket = (config) => {
             await upsertMessage(protoMsg, call.offline ? 'append' : 'notify');
         }
     });
-    ev.on('connection.update', ({ isOnline }) => {
+    /** timestamp of last tctoken prune run — throttles to once per 24h */
+    let lastTcTokenPruneTs = 0;
+    ev.on('connection.update', ({ isOnline, connection }) => {
         if (typeof isOnline !== 'undefined') {
             sendActiveReceipts = isOnline;
             logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`);
         }
-    });
+        // Flush pending tctoken index save on disconnect to avoid writing after close
+        if (connection === 'close' && tcTokenIndexTimer) {
+            clearTimeout(tcTokenIndexTimer);
+            tcTokenIndexTimer = undefined;
+            // Best-effort flush — may fail if store is already closed
+            try {
+                void Promise.resolve(flushTcTokenIndex()).catch(() => {});
+            }
+            catch {
+                /* ignore sync errors */
+            }
+        }
+        // Prune expired tctokens when coming online, at most once per 24 hours
+        // Matches WA Web's CLEAN_TC_TOKENS task
+        // Note: don't gate on tcTokenKnownJids.size — the index may still be loading
+        if (isOnline) {
+            const now = Date.now();
+            const DAY_MS = 24 * 60 * 60 * 1000;
+            if (now - lastTcTokenPruneTs >= DAY_MS) {
+                lastTcTokenPruneTs = now;
+                void pruneExpiredTcTokens();
+            }
+        }
+    })
+    async function pruneExpiredTcTokens() {
+        try {
+            await tcTokenIndexLoaded;
+            // Union with the persisted index picks up JIDs added by other layers
+            // (history sync) without needing inter-module wiring.
+            const persisted = await readTcTokenIndex(authState.keys);
+            const allJids = new Set(tcTokenKnownJids);
+            for (const jid of persisted) {
+                allJids.add(jid);
+            }
+            if (!allJids.size) return;
+            const jids = [...allJids];
+            const allTokens = await authState.keys.get('tctoken', jids);
+            const writes = {};
+            const survivors = new Set();
+            let mutated = 0;
+            for (const jid of jids) {
+                const entry = allTokens[jid];
+                if (!entry) {
+                    // Tracked but nothing in store — drop from index.
+                    mutated++;
+                    continue;
+                }
+                const hasPeerToken = !!entry.token?.length;
+                const peerTokenExpired = hasPeerToken && isTcTokenExpired(entry.timestamp);
+                const hasSenderTs = entry.senderTimestamp !== undefined;
+                const senderTsExpired = hasSenderTs && isTcTokenExpired(entry.senderTimestamp);
+                const keepPeerToken = hasPeerToken && !peerTokenExpired;
+                const keepSenderTs = hasSenderTs && !senderTsExpired;
+                if (!keepPeerToken && !keepSenderTs) {
+                    writes[jid] = null;
+                    mutated++;
+                }
+                else if (peerTokenExpired && keepSenderTs) {
+                    writes[jid] = { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp };
+                    survivors.add(jid);
+                    mutated++;
+                }
+                else {
+                    survivors.add(jid);
+                }
+            }
+            if (mutated === 0) return;
+            await authState.keys.set({
+                tctoken: {
+                    ...writes,
+                    [TC_TOKEN_INDEX_KEY]: {
+                        token: Buffer.from(JSON.stringify([...survivors]))
+                    }
+                }
+            });
+            tcTokenKnownJids.clear();
+            for (const jid of survivors) {
+                tcTokenKnownJids.add(jid);
+            }
+            logger.debug({ mutated, remaining: survivors.size }, 'pruned expired tctokens');
+        }
+        catch (err) {
+            logger.warn({ err: err?.message }, 'failed to prune expired tctokens');
+        }
+    };
     registerSocketEndHandler(() => {
         if (!config.msgRetryCounterCache && msgRetryCache.close) {
             msgRetryCache.close();

package/lib/Socket/messages-send.js

@@ -8,13 +8,21 @@ import { AssociationType } from '../Types/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex } from '../Utils/make-mutex.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
-import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isHostedLidUser, isHostedPnUser, isJidGroup, isJidNewsletter, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, resolveTcTokenJid, shouldSendNewTcToken, storeTcTokensFromIqResult } from '../Utils/tc-token-utils.js';
+import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isJidNewsletter, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, PSA_WID, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
+    /**
+     * Set of tctoken storage JIDs with a fire-and-forget `issuePrivacyTokens` IQ in flight.
+     * Prevents duplicate IQs from rapid back-to-back sends before `senderTimestamp` persists.
+     * Entries are always removed in `.finally()`, so the set is bounded by concurrency.
+     */
+    const inFlightTcTokenIssuance = new Set();
     const userDevicesCache = config.userDevicesCache ??=
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
@@ -801,9 +809,30 @@ export const makeMessagesSocket = (config) => {
                     logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
                 }
             }
-            const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
-            const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
-            if (tcTokenBuffer) {
+            // WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
+            const isPeerMessage = additionalAttributes?.['category'] === 'peer';
+            const is1on1Send = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage;
+            // Resolve destination to LID for tctoken storage — matches Signal session key pattern
+            const tcTokenJid = is1on1Send ? await resolveTcTokenJid(destinationJid, getLIDForPN) : destinationJid;
+            const contactTcTokenData = is1on1Send ? await authState.keys.get('tctoken', [tcTokenJid]) : {};
+            const existingTokenEntry = contactTcTokenData[tcTokenJid];
+            let tcTokenBuffer = existingTokenEntry?.token;
+            // Treat expired tokens the same as missing — clear from cache
+            if (tcTokenBuffer?.length && isTcTokenExpired(existingTokenEntry?.timestamp)) {
+                logger.debug({ jid: destinationJid, timestamp: existingTokenEntry?.timestamp }, 'tctoken expired, clearing');
+                tcTokenBuffer = undefined;
+                // Preserve senderTimestamp so the fire-and-forget issuance dedupe survives cleanup.
+                const cleared = existingTokenEntry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: existingTokenEntry.senderTimestamp }
+                    : null;
+                try {
+                    await authState.keys.set({ tctoken: { [tcTokenJid]: cleared } });
+                }
+                catch (err) {
+                    logger.debug({ jid: destinationJid, err: err?.message }, 'failed to persist tctoken expiry cleanup');
+                }
+            }
+            if (tcTokenBuffer?.length && sock.serverProps.privacyTokenOn1to1) {
                 ;
                 stanza.content.push({
                     tag: 'tctoken',
@@ -825,6 +854,48 @@ export const makeMessagesSocket = (config) => {
             }
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
             await sendNode(stanza);
+            // Fire-and-forget: issue our token to the contact AFTER message send.
+            // WA Web skips protocol messages and PSA/bot contacts (TcTokenChatAction: isRegularUser)
+            const isProtocolMsg = !!normalizeMessageContent(message)?.protocolMessage;
+            const isBotOrPSA = destinationJid === PSA_WID || isJidBot(destinationJid) || isJidMetaAI(destinationJid);
+            if (is1on1Send &&
+                !isProtocolMsg &&
+                !isBotOrPSA &&
+                shouldSendNewTcToken(existingTokenEntry?.senderTimestamp) &&
+                !inFlightTcTokenIssuance.has(tcTokenJid)) {
+                inFlightTcTokenIssuance.add(tcTokenJid);
+                const issueTimestamp = unixTimestampSeconds();
+                const getPNForLID = signalRepository.lidMapping.getPNForLID.bind(signalRepository.lidMapping);
+                resolveIssuanceJid(destinationJid, sock.serverProps.lidTrustedTokenIssueToLid, getLIDForPN, getPNForLID)
+                    .then(issueJid => issuePrivacyTokens([issueJid], issueTimestamp))
+                    .then(async result => {
+                    await storeTcTokensFromIqResult({
+                        result,
+                        fallbackJid: tcTokenJid,
+                        keys: authState.keys,
+                        getLIDForPN
+                    });
+                    const currentData = await authState.keys.get('tctoken', [tcTokenJid]);
+                    const currentEntry = currentData[tcTokenJid];
+                    const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [tcTokenJid]);
+                    await authState.keys.set({
+                        tctoken: {
+                            [tcTokenJid]: {
+                                token: Buffer.alloc(0),
+                                ...currentEntry,
+                                senderTimestamp: issueTimestamp
+                            },
+                            ...indexWrite
+                        }
+                    });
+                    })
+                    .catch(err => {
+                        logger.debug({ jid: destinationJid, err: err?.message }, 'fire-and-forget tctoken issuance failed');
+                    })
+                    .finally(() => {
+                        inFlightTcTokenIssuance.delete(tcTokenJid);
+                    });
+            }
             // Add message to retry cache if enabled
             if (messageRetryManager && !participant) {
                 messageRetryManager.addRecentMessage(destinationJid, msgId, message);
@@ -915,8 +986,8 @@ export const makeMessagesSocket = (config) => {
         }
         return ''
     };
-    const getPrivacyTokens = async (jids) => {
-        const t = unixTimestampSeconds().toString();
+    const issuePrivacyTokens = async (jids, timestamp) => {
+        const t = (timestamp ?? unixTimestampSeconds()).toString();
         const result = await query({
             tag: 'iq',
             attrs: {
@@ -957,7 +1028,7 @@ export const makeMessagesSocket = (config) => {
     });
     return {
         ...sock,
-        getPrivacyTokens,
+        issuePrivacyTokens,
         assertSessions,
         relayMessage,
         sendReceipt,

package/lib/Utils/chat-utils.js

@@ -38,7 +38,7 @@ const to64BitNetworkOrder = (e) => {
     buff.writeUint32BE(e, 4);
     return buff;
 };
-const makeLtHashGenerator = ({ indexValueMap, hash }) => {
+export const makeLtHashGenerator = ({ indexValueMap, hash }) => {
     indexValueMap = { ...indexValueMap };
     const addBuffs = [];
     const subBuffs = [];
@@ -48,7 +48,10 @@ const makeLtHashGenerator = ({ indexValueMap, hash }) => {
             const prevOp = indexValueMap[indexMacBase64];
             if (operation === proto.SyncdMutation.SyncdOperation.REMOVE) {
                 if (!prevOp) {
-                    throw new Boom('tried remove, but no previous op', { data: { indexMac, valueMac } });
+                    // WA Web does not throw here — it logs a warning and skips the subtract.
+                    // The missing REMOVE will cause an LTHash mismatch, which is handled
+                    // by the MAC validation layer (snapshot recovery or retry).
+                    return;
                 }
                 // remove from index value mac, since this mutation is erased
                 delete indexValueMap[indexMacBase64];
@@ -83,7 +86,7 @@ export const newLTHashState = () => ({ version: 0, hash: Buffer.alloc(128), inde
 export const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, operation }, myAppStateKeyId, state, getAppStateSyncKey) => {
     const key = !!myAppStateKeyId ? await getAppStateSyncKey(myAppStateKeyId) : undefined;
     if (!key) {
-        throw new Boom(`myAppStateKey ("${myAppStateKeyId}") not present`, { statusCode: 404 });
+        throw new Boom(`myAppStateKey ("${myAppStateKeyId}") not present`, { data: { isMissingKey: true } });
     }
     const encKeyId = Buffer.from(myAppStateKeyId, 'base64');
     state = { ...state, indexValueMap: { ...state.indexValueMap } };
@@ -176,7 +179,7 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
         if (!keyEnc) {
             throw new Boom(`failed to find key "${base64Key}" to decode mutation`, {
                 statusCode: 404,
-                data: { msgMutations }
+                data: { isMissingKey: true, msgMutations }
             });
         }
         const keys = mutationKeys(keyEnc.keyData);
@@ -184,12 +187,35 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
         return keys;
     }
 };
+export const ensureLTHashStateVersion = (state) => {
+    if (typeof state.version !== 'number' || isNaN(state.version)) {
+        state.version = 0;
+    }
+    return state;
+};
+export const MAX_SYNC_ATTEMPTS = 2;
+/**
+ * Check if an error is a missing app state sync key.
+ * WA Web treats these as "Blocked" (waits for key arrival), not fatal.
+ * In Baileys we retry with a snapshot which may use a different key.
+ */
+export const isMissingKeyError = (error) => {
+    return error?.data?.isMissingKey === true;
+};
+/**
+ * Determines if an app state sync error is unrecoverable.
+ * TypeError indicates a WASM crash; otherwise we give up after MAX_SYNC_ATTEMPTS.
+ * Missing keys are NOT checked here — they are handled separately as "Blocked".
+ */
+export const isAppStateSyncIrrecoverable = (error, attempts) => {
+    return attempts >= MAX_SYNC_ATTEMPTS || error?.name === 'TypeError';
+};
 export const decodeSyncdPatch = async (msg, name, initialState, getAppStateSyncKey, onMutation, validateMacs) => {
     if (validateMacs) {
         const base64Key = Buffer.from(msg.keyId.id).toString('base64');
         const mainKeyObj = await getAppStateSyncKey(base64Key);
         if (!mainKeyObj) {
-            throw new Boom(`failed to find key "${base64Key}" to decode patch`, { statusCode: 404, data: { msg } });
+            throw new Boom(`failed to find key "${base64Key}" to decode patch`, { data: { isMissingKey: true, msg } });
         }
         const mainKey = mutationKeys(mainKeyObj.keyData);
         const mutationmacs = msg.mutations.map(mutation => mutation.record.value.blob.slice(-32));
@@ -267,7 +293,7 @@ export const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, mi
         const base64Key = Buffer.from(snapshot.keyId.id).toString('base64');
         const keyEnc = await getAppStateSyncKey(base64Key);
         if (!keyEnc) {
-            throw new Boom(`failed to find key "${base64Key}" to decode mutation`);
+            throw new Boom(`failed to find key "${base64Key}" to decode mutation`, { data: { isMissingKey: true } });
         }
         const result = mutationKeys(keyEnc.keyData);
         const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
@@ -309,7 +335,7 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
             const base64Key = Buffer.from(keyId.id).toString('base64');
             const keyEnc = await getAppStateSyncKey(base64Key);
             if (!keyEnc) {
-                throw new Boom(`failed to find key "${base64Key}" to decode mutation`);
+                throw new Boom(`failed to find key "${base64Key}" to decode mutation`, { data: { isMissingKey: true } });
             }
             const result = mutationKeys(keyEnc.keyData);
             const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
@@ -779,6 +805,7 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
                     action.lidContactAction.firstName ||
                     action.lidContactAction.username ||
                     undefined,
+                username: action.lidContactAction.username || undefined,
                 lid: id,
                 phoneNumber: undefined
             }