@nexustechpro/baileys 2.1.2 → 2.1.3

package/lib/Socket/messages-recv.js

@@ -527,7 +527,7 @@ export const makeMessagesRecvSocket = (config) => {
 
   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') }
+    try { const jids = await readTcTokenIndex(authState.keys); for (const jid of jids) tcTokenKnownJids.add(jid); if (tcTokenKnownJids.size > 0) logger.debug({ count: tcTokenKnownJids.size }, 'loaded tctoken index') }
     catch (err) { logger.warn({ err: err?.message }, 'failed to load tctoken index') }
   })()
 
@@ -942,7 +942,8 @@ export const makeMessagesRecvSocket = (config) => {
         else survivors.add(jid)
       }
       if (mutated === 0) return
-      await authState.keys.set({ tctoken: { ...writes, [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...survivors])) } } })
+      const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [...survivors])
+      await authState.keys.set({ tctoken: { ...writes, ...indexWrite } })
       tcTokenKnownJids.clear()
       for (const jid of survivors) tcTokenKnownJids.add(jid)
       logger.debug({ mutated, remaining: survivors.size }, 'pruned expired tctokens')
@@ -962,5 +963,5 @@ export const makeMessagesRecvSocket = (config) => {
     sendActiveReceipts = false
   })
 
-  return { ...sock, sendMessageAck, sendRetryRequest, rejectCall, offerCall, fetchMessageHistory, requestPlaceholderResend, messageRetryManager }
+  return { ...sock, sendMessageAck, sendRetryRequest, rejectCall, offerCall, fetchMessageHistory, requestPlaceholderResend, messageRetryManager, tcTokenIndexLoaded }
 }

package/lib/Socket/messages-send.js

@@ -367,13 +367,6 @@ export const makeMessagesSocket = (config) => {
         const isStatus = jid === 'status@broadcast'
         let isLid = server === 'lid'
         const isNewsletter = server === 'newsletter'
-        if (isLid && !isGroup && !isStatus) {
-            const pn = await signalRepository.lidMapping.getPNForLID(jid)
-            if (pn) {
-                const resolvedJid = pn.replace(/:\d+(?=@)/, ''); logger.debug({ from: jid, to: resolvedJid }, 'relayMessage: resolved 1:1 LID to PN for wire protocol')
-                jid = resolvedJid; const decoded = jidDecode(jid); user = decoded.user; server = decoded.server; isLid = false
-            }
-        }
         let activeSender = meId
         let groupAddressingMode = 'pn'
         if (isGroup && !isStatus) {
@@ -542,6 +535,14 @@ export const makeMessagesSocket = (config) => {
                 if (isLid && meLid) { ownId = meLid; logger.debug({ to: jid, ownId }, 'Using LID identity') }
 
                 const { user: ownUser } = jidDecode(ownId)
+                const targetUserServer = isLid ? 'lid' : 's.whatsapp.net'
+                devices.push({ user, device: 0, jid: jidEncode(user, targetUserServer, 0) })
+
+                if (user !== ownUser) {
+                    const ownUserServer = isLid ? 'lid' : 's.whatsapp.net'
+                    const ownUserForAddressing = isLid && meLid ? jidDecode(meLid).user : jidDecode(meId).user
+                    devices.push({ user: ownUserForAddressing, device: 0, jid: jidEncode(ownUserForAddressing, ownUserServer, 0) })
+                }
 
                 if (!participant) {
                     const targetUserServer = isLid ? 'lid' : 's.whatsapp.net'
@@ -570,22 +571,16 @@ export const makeMessagesSocket = (config) => {
                         }
                     }
                 }
-
                 const allRecipients = [], meRecipients = [], otherRecipients = []
                 const { user: mePnUser } = jidDecode(meId)
                 const { user: meLidUser } = meLid ? jidDecode(meLid) : { user: null }
-
-                for (const { user, jid } of devices) {
-                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid)
-                    if (isExactSenderDevice) continue
-                    const isMe = user === mePnUser || user === meLidUser
-                    if (isMe) meRecipients.push(jid)
-                    else otherRecipients.push(jid)
-                    allRecipients.push(jid)
+                for (const { user: devUser, jid: devJid } of devices) {
+                    const isOwnUser = devUser === mePnUser || devUser === meLidUser
+                    if (isOwnUser) meRecipients.push(devJid)
+                    else otherRecipients.push(devJid)
+                    allRecipients.push(devJid)
                 }
-
                 await assertSessions(allRecipients)
-
                 const [{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 }, { nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }] = await Promise.all([
                     createParticipantNodes(meRecipients, meMsg || message, extraAttrs),
                     createParticipantNodes(otherRecipients, message, extraAttrs, meMsg)
@@ -613,7 +608,7 @@ export const makeMessagesSocket = (config) => {
                     id: finalMsgId,
                     to: destinationJid,
                     type: getMessageType(message),
-                    ...(isLid || (isGroup && groupAddressingMode === 'lid') ? { addressing_mode: 'lid' } : {}),
+                    ...((isGroup && groupAddressingMode === 'lid') ? { addressing_mode: 'lid' } : {}),
                     ...(hasDeviceFanoutFalse ? { device_fanout: 'false' } : {}),
                     ...(additionalAttributes || {})
                 },

package/lib/Utils/chat-utils.js

@@ -53,7 +53,7 @@ export const makeLtHashGenerator = ({ indexValueMap, hash }) => {
             }
             if (prevOp) subBuffs.push(prevOp.valueMac)
         },
-        finish: () => {
+        finish: async () => {
             const result = LT_HASH_ANTI_TAMPERING.subtractThenAdd(hash, subBuffs, addBuffs)
             return { hash: Buffer.from(result), indexValueMap }
         }
@@ -99,7 +99,7 @@ export const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, op
     const indexMac = hmacSign(indexBuffer, keyValue.indexKey)
     const generator = makeLtHashGenerator(state)
     generator.mix({ indexMac, valueMac, operation })
-    Object.assign(state, generator.finish())
+    Object.assign(state, await generator.finish())
     state.version += 1
     const snapshotMac = generateSnapshotMac(state.hash, state.version, type, keyValue.snapshotMacKey)
     const patch = {

package/lib/Utils/key-store.js

@@ -2,16 +2,21 @@
 // Single source of truth for blob key names — change here, changes everywhere
 export const SESSION_INDEX_KEY = 'index'
 export const DEVICE_LIST_INDEX_KEY = 'index'
+export const TC_TOKEN_INDEX_KEY = 'index'
 
 // Migrates old _index blob to new index key in-place, returns the batch data
 export const migrateIndexKey = async (keys, type) => {
-    const oldKey = '_index'
+    const oldKeys = ['_index', '__index']
     const newKey = 'index'
-    const oldData = await keys.get(type, [oldKey])
-    if (oldData?.[oldKey] !== null && oldData?.[oldKey] !== undefined && typeof oldData[oldKey] === 'object') { // only migrate if old blob actually exists and has data
-        await keys.set({ [type]: { [newKey]: oldData[oldKey], [oldKey]: null } })
-        return oldData[oldKey]
+
+    for (const oldKey of oldKeys) {
+        const oldData = await keys.get(type, [oldKey])
+        if (oldData?.[oldKey] !== null && oldData?.[oldKey] !== undefined && typeof oldData[oldKey] === 'object') {
+            await keys.set({ [type]: { [newKey]: oldData[oldKey], [oldKey]: null } })
+            return oldData[oldKey]
+        }
     }
+
     const newData = await keys.get(type, [newKey])
     return newData?.[newKey] || {}
 }

package/lib/Utils/lt-hash.js

@@ -1,48 +1,7 @@
-import { hkdf } from './crypto.js';
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
 /**
  * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
  * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
  * if the same series of mutations was made sequentially.
  */
-const o = 128;
-class LTHash {
-    constructor(e) {
-        this.salt = e;
-    }
-    async add(e, t) {
-        for (const item of t) {
-            e = await this._addSingle(e, item);
-        }
-        return e;
-    }
-    async subtract(e, t) {
-        for (const item of t) {
-            e = await this._subtractSingle(e, item);
-        }
-        return e;
-    }
-    async subtractThenAdd(e, addList, subtractList) {
-        const subtracted = await this.subtract(e, subtractList);
-        return this.add(subtracted, addList);
-    }
-    async _addSingle(e, t) {
-        const derived = new Uint8Array(hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
-    }
-    async _subtractSingle(e, t) {
-        const derived = new Uint8Array(hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
-    }
-    performPointwiseWithOverflow(e, t, op) {
-        const n = new DataView(e);
-        const i = new DataView(t);
-        const out = new ArrayBuffer(n.byteLength);
-        const s = new DataView(out);
-        for (let offset = 0; offset < n.byteLength; offset += 2) {
-            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
-        }
-        return out;
-    }
-}
-export const LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity');
-//# sourceMappingURL=lt-hash.js.map
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();

package/lib/Utils/process-message.js

@@ -1,179 +1,200 @@
 import { proto } from '../../WAProto/index.js';
-import { Boom } from '@hapi/boom'
+import { Boom } from '@hapi/boom';
 import { WAMessageStubType } from '../Types/index.js';
 import { getContentType, normalizeMessageContent } from '../Utils/messages.js';
-import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJidStatusBroadcast, jidDecode, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
+import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJidStatusBroadcast, isLidUser, jidDecode, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
 import { aesDecryptGCM, hmacSign } from './crypto.js';
-import { resolveTcTokenJid, buildMergedTcTokenIndexWrite } from './tc-token-utils.js'
-import { toNumber } from './generics.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,
     WAMessageStubType.CALL_MISSED_VIDEO,
-    WAMessageStubType.CALL_MISSED_VOICE
+    WAMessageStubType.CALL_MISSED_VOICE,
 ]);
+
 const REAL_MSG_REQ_ME_STUB_TYPES = new Set([WAMessageStubType.GROUP_PARTICIPANT_ADD]);
-/** Cleans a received message to further processing */
+
+// Protocol message types that can only legitimately arrive from our own device.
+// If they arrive from any other sender we drop them to prevent local-state spoofing.
+// Cross-user types (REVOKE, MESSAGE_EDIT, EPHEMERAL_SETTING, GROUP_MEMBER_LABEL_CHANGE)
+// must NOT be listed here — they legitimately arrive from other participants.
+// Reference: https://github.com/tulir/whatsmeow/blob/8d3700152a/message.go#L842-L845
+const SELF_ONLY_PROTOCOL_TYPES = new Set([
+    proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION,
+    proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE,
+    proto.Message.ProtocolMessage.Type.LID_MIGRATION_MAPPING_SYNC,
+    proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE,
+]);
+
+/** Persist tc-tokens discovered inside a history-sync payload, skipping stale entries. */
+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) continue;
+        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 existing = await keyStore.get('tctoken', candidates.map(c => c.storageJid));
+    const entries = {};
+    for (const c of candidates) {
+        const existingTs = existing[c.storageJid]?.timestamp ? Number(existing[c.storageJid].timestamp) : 0;
+        if (existingTs > 0 && existingTs >= c.ts) continue;
+        entries[c.storageJid] = { ...existing[c.storageJid], token: c.token, timestamp: String(c.ts), ...(c.senderTs !== undefined ? { senderTimestamp: c.senderTs } : {}) };
+    }
+    if (!Object.keys(entries).length) return;
+
+    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 for further processing — strips device/agent from JIDs and corrects key perspective for reactions/polls. */
 export const cleanMessage = (message, meId, meLid) => {
-    // ensure remoteJid and participant doesn't have device or agent in it
     if (isHostedPnUser(message.key.remoteJid) || isHostedLidUser(message.key.remoteJid)) {
         message.key.remoteJid = jidEncode(jidDecode(message.key?.remoteJid)?.user, isHostedPnUser(message.key.remoteJid) ? 's.whatsapp.net' : 'lid');
-    }
-    else {
+    } else {
         message.key.remoteJid = jidNormalizedUser(message.key.remoteJid);
     }
     if (isHostedPnUser(message.key.participant) || isHostedLidUser(message.key.participant)) {
         message.key.participant = jidEncode(jidDecode(message.key.participant)?.user, isHostedPnUser(message.key.participant) ? 's.whatsapp.net' : 'lid');
-    }
-    else {
+    } else {
         message.key.participant = jidNormalizedUser(message.key.participant);
     }
+
     const content = normalizeMessageContent(message.message);
-    // if the message has a reaction, ensure fromMe & remoteJid are from our perspective
-    if (content?.reactionMessage) {
-        normaliseKey(content.reactionMessage.key);
-    }
-    if (content?.pollUpdateMessage) {
-        normaliseKey(content.pollUpdateMessage.pollCreationMessageKey);
-    }
+    if (content?.reactionMessage) normaliseKey(content.reactionMessage.key);
+    if (content?.pollUpdateMessage) normaliseKey(content.pollUpdateMessage.pollCreationMessageKey);
+
     function normaliseKey(msgKey) {
-        // if the reaction is from another user
-        // we've to correctly map the key to this user's perspective
-        if (!message.key.fromMe) {
-            // if the sender believed the message being reacted to is not from them
-            // we've to correct the key to be from them, or some other participant
-            msgKey.fromMe = !msgKey.fromMe
-                ? areJidsSameUser(msgKey.participant || msgKey.remoteJid, meId) ||
-                areJidsSameUser(msgKey.participant || msgKey.remoteJid, meLid)
-                : // if the message being reacted to, was from them
-                // fromMe automatically becomes false
-                false;
-            // set the remoteJid to being the same as the chat the message came from
-            // TODO: investigate inconsistencies
-            msgKey.remoteJid = message.key.remoteJid;
-            // set participant of the message
-            msgKey.participant = msgKey.participant || message.key.participant;
-        }
+        if (message.key.fromMe) return;
+        msgKey.fromMe = !msgKey.fromMe
+            ? areJidsSameUser(msgKey.participant || msgKey.remoteJid, meId) || areJidsSameUser(msgKey.participant || msgKey.remoteJid, meLid)
+            : false; // message was from them — fromMe is definitively false from our perspective
+        msgKey.remoteJid = message.key.remoteJid; // TODO: investigate inconsistencies
+        msgKey.participant = msgKey.participant || message.key.participant;
     }
 };
+
 // TODO: target:audit AUDIT THIS FUNCTION AGAIN
 export const isRealMessage = (message) => {
     const normalizedContent = normalizeMessageContent(message.message);
     const hasSomeContent = !!getContentType(normalizedContent);
-    return ((!!normalizedContent ||
-        REAL_MSG_STUB_TYPES.has(message.messageStubType) ||
-        REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType)) &&
+    return (
+        (!!normalizedContent || REAL_MSG_STUB_TYPES.has(message.messageStubType) || REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType)) &&
         hasSomeContent &&
         !normalizedContent?.protocolMessage &&
         !normalizedContent?.reactionMessage &&
-        !normalizedContent?.pollUpdateMessage);
+        !normalizedContent?.pollUpdateMessage
+    );
 };
+
 export const shouldIncrementChatUnread = (message) => !message.key.fromMe && !message.messageStubType;
+
 /**
- * Get the ID of the chat from the given key.
- * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
+ * Derive the chat ID from a message key.
+ * For non-status broadcasts the chat is the participant (DM from that sender),
+ * for everything else it's the remoteJid.
  */
 export const getChatId = ({ remoteJid, participant, fromMe }) => {
-    if (!remoteJid) throw new Boom('Cannot derive chat id: message key is missing remoteJid', { data: { remoteJid, participant, fromMe } })
-    if (isJidBroadcast(remoteJid) && !isJidStatusBroadcast(remoteJid) && !fromMe) return participant
-    return remoteJid
+    if (!remoteJid) throw new Boom('Cannot derive chat id: message key is missing remoteJid', { data: { remoteJid, participant, fromMe } });
+    if (isJidBroadcast(remoteJid) && !isJidStatusBroadcast(remoteJid) && !fromMe) {
+        if (!participant) throw new Boom('Cannot derive chat id: broadcast message key is missing participant', { data: { remoteJid, fromMe } });
+        return participant;
+    }
+    return remoteJid;
 };
+
 /**
- * Decrypt a poll vote
- * @param vote encrypted vote
- * @param ctx additional info about the poll required for decryption
- * @returns list of SHA256 options
+ * Decrypt a poll vote.
+ * @returns Decoded PollVoteMessage containing the SHA256 option hashes the voter selected.
  */
 export function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pollEncKey, voterJid }) {
-    const sign = Buffer.concat([
-        toBinary(pollMsgId),
-        toBinary(pollCreatorJid),
-        toBinary(voterJid),
-        toBinary('Poll Vote'),
-        new Uint8Array([1])
-    ]);
+    const toBinary = (txt) => Buffer.from(txt);
+    const sign = Buffer.concat([toBinary(pollMsgId), toBinary(pollCreatorJid), toBinary(voterJid), toBinary('Poll Vote'), new Uint8Array([1])]);
     const key0 = hmacSign(pollEncKey, new Uint8Array(32), 'sha256');
     const decKey = hmacSign(sign, key0, 'sha256');
     const aad = toBinary(`${pollMsgId}\u0000${voterJid}`);
-    const decrypted = aesDecryptGCM(encPayload, decKey, encIv, aad);
-    return proto.Message.PollVoteMessage.decode(decrypted);
-    function toBinary(txt) {
-        return Buffer.from(txt);
-    }
+    return proto.Message.PollVoteMessage.decode(aesDecryptGCM(encPayload, decKey, encIv, aad));
 }
 
-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 { 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') }
-    }
+/**
+ * Decrypt an event RSVP response.
+ * Mirrors decryptPollVote but for EventResponseMessage — uses 'Event Response' as the domain separator.
+ * @returns Decoded EventResponseMessage with the responder's RSVP choice.
+ */
+export function decryptEventResponse({ encPayload, encIv }, { eventCreatorJid, eventMsgId, eventEncKey, responderJid }) {
+    const toBinary = (txt) => Buffer.from(txt);
+    const sign = Buffer.concat([toBinary(eventMsgId), toBinary(eventCreatorJid), toBinary(responderJid), toBinary('Event Response'), new Uint8Array([1])]);
+    const key0 = hmacSign(eventEncKey, new Uint8Array(32), 'sha256');
+    const decKey = hmacSign(sign, key0, 'sha256');
+    const aad = toBinary(`${eventMsgId}\u0000${responderJid}`);
+    return proto.Message.EventResponseMessage.decode(aesDecryptGCM(encPayload, decKey, encIv, aad));
 }
 
-const SELF_ONLY_TYPES = new Set([proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION, proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE, proto.Message.ProtocolMessage.Type.LID_MIGRATION_MAPPING_SYNC, proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE])
 
 const processMessage = async (message, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, signalRepository, keyStore, logger, options, getMessage }) => {
     const meId = creds.me.id;
     const { accountSettings } = creds;
     const chat = { id: jidNormalizedUser(getChatId(message.key)) };
     const isRealMsg = isRealMessage(message);
+
     if (isRealMsg) {
         chat.messages = [{ message }];
         chat.conversationTimestamp = toNumber(message.messageTimestamp);
-        // only increment unread count if not CIPHERTEXT and from another person
-        if (shouldIncrementChatUnread(message)) {
-            chat.unreadCount = (chat.unreadCount || 0) + 1;
-        }
+        if (shouldIncrementChatUnread(message)) chat.unreadCount = (chat.unreadCount || 0) + 1;
     }
+
     const content = normalizeMessageContent(message.message);
-    // unarchive chat if it's a real message, or someone reacted to our message
-    // and we've the unarchive chats setting on
+
+    // Unarchive if real message or someone reacted to our message and the setting is on
     if ((isRealMsg || content?.reactionMessage?.key?.fromMe) && accountSettings?.unarchiveChats) {
         chat.archived = false;
         chat.readOnly = false;
     }
+
     const protocolMsg = content?.protocolMessage;
     if (protocolMsg) {
-        if (protocolMsg.type !== null && protocolMsg.type !== undefined && SELF_ONLY_TYPES.has(protocolMsg.type) && !message.key.fromMe) { logger?.warn({ msgId: message.key.id, type: protocolMsg.type, from: message.key.participant || message.key.remoteJid }, 'dropping spoofed self-only protocolMessage from non-self origin'); return }
+        // Drop self-only protocol messages that didn't come from our own device —
+        // an attacker could otherwise spoof history syncs, key shares, etc. to manipulate local state.
+        if (protocolMsg.type !== null && protocolMsg.type !== undefined && SELF_ONLY_PROTOCOL_TYPES.has(protocolMsg.type) && !message.key.fromMe) {
+            logger?.warn({ msgId: message.key.id, type: protocolMsg.type, from: message.key.participant || message.key.remoteJid }, 'dropping spoofed self-only protocolMessage from non-self origin');
+            return;
+        }
+
         switch (protocolMsg.type) {
-            case proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION:
+            case proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION: {
                 const histNotification = protocolMsg.historySyncNotification;
-                const process = shouldProcessHistoryMsg;
                 const isLatest = !creds.processedHistoryMessages?.length;
-                logger?.info({
-                    histNotification,
-                    process,
-                    id: message.key.id,
-                    isLatest
-                }, 'got history notification');
-                if (process) {
+                logger?.info({ histNotification, process: shouldProcessHistoryMsg, id: message.key.id, isLatest }, 'got history notification');
+                if (shouldProcessHistoryMsg) {
                     if (histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND) {
                         ev.emit('creds.update', { processedHistoryMessages: [...(creds.processedHistoryMessages || []), { key: message.key, messageTimestamp: message.messageTimestamp }] });
                     }
-                    const data = await downloadAndProcessHistorySyncNotification(histNotification, options);
-                    if (data.lidPnMappings?.length) { logger?.debug({ count: data.lidPnMappings.length }, 'processing LID-PN mappings from history sync'); await signalRepository.lidMapping.storeLIDPNMappings(data.lidPnMappings).catch(err => logger?.warn({ err }, 'failed to store LID-PN mappings from history sync')) }
-                    await storeTcTokensFromHistorySync(data.chats, signalRepository, keyStore, logger)
+                    const data = await downloadAndProcessHistorySyncNotification(histNotification, options, logger);
+                    if (data.lidPnMappings?.length) {
+                        logger?.debug({ count: data.lidPnMappings.length }, 'processing LID-PN mappings from history sync');
+                        await signalRepository.lidMapping.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 });
                 }
                 break;
-            case proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE:
+            }
+
+            case proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE: {
                 const keys = protocolMsg.appStateSyncKeyShare.keys;
                 if (keys?.length) {
                     let newAppStateSyncKeyId = '';
@@ -188,68 +209,75 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                         logger?.info({ newAppStateSyncKeyId, newKeys }, 'injecting new app state sync keys');
                     }, meId);
                     ev.emit('creds.update', { myAppStateKeyId: newAppStateSyncKeyId });
-                }
-                else {
+                } else {
                     logger?.info({ protocolMsg }, 'recv app state sync with 0 keys');
                 }
                 break;
-            case proto.Message.ProtocolMessage.Type.REVOKE:
-                ev.emit('messages.update', [
-                    {
-                        key: {
-                            ...message.key,
-                            id: protocolMsg.key.id
-                        },
-                        update: { message: null, messageStubType: WAMessageStubType.REVOKE, key: message.key }
-                    }
-                ]);
+            }
+
+            case proto.Message.ProtocolMessage.Type.REVOKE: {
+                ev.emit('messages.update', [{ key: { ...message.key, id: protocolMsg.key.id }, update: { message: null, messageStubType: WAMessageStubType.REVOKE, key: message.key } }]);
                 break;
-            case proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING:
-                Object.assign(chat, {
-                    ephemeralSettingTimestamp: toNumber(message.messageTimestamp),
-                    ephemeralExpiration: protocolMsg.ephemeralExpiration || null
-                });
+            }
+
+            case proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING: {
+                Object.assign(chat, { ephemeralSettingTimestamp: toNumber(message.messageTimestamp), ephemeralExpiration: protocolMsg.ephemeralExpiration || null });
                 break;
-            case proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE:
-                const response = protocolMsg.peerDataOperationRequestResponseMessage;
-                if (response) {
-                    const peerDataOperationResult = response.peerDataOperationResult || []
-                    for (const result of peerDataOperationResult) {
-                        const retryResponse = result?.placeholderMessageResendResponse
-                        if (!retryResponse?.webMessageInfoBytes) continue
-                        try {
-                            const webMessageInfo = proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes)
-                            const msgId = webMessageInfo.key?.id
-                            const cachedData = msgId ? await placeholderResendCache?.get(msgId) : undefined
-                            if (msgId) await placeholderResendCache?.del(msgId)
-                            let finalMsg
-                            if (cachedData && typeof cachedData === 'object') { cachedData.message = webMessageInfo.message; if (webMessageInfo.messageTimestamp) cachedData.messageTimestamp = webMessageInfo.messageTimestamp; finalMsg = cachedData }
-                            else finalMsg = webMessageInfo
-                            logger?.debug({ msgId, requestId: response.stanzaId }, 'received placeholder resend')
-                            ev.emit('messages.upsert', { messages: [finalMsg], type: 'notify', requestId: response.stanzaId })
-                        } catch (err) { logger?.warn({ err, stanzaId: response.stanzaId }, 'failed to decode placeholder resend response') }
-                    }
+            }
+
+            case proto.Message.ProtocolMessage.Type.MESSAGE_EDIT: {
+                ev.emit('messages.update', [{
+                    // Key is in sender's perspective — flip fromMe so it's in ours
+                    key: { ...message.key, id: protocolMsg.key?.id },
+                    update: {
+                        message: { editedMessage: { message: protocolMsg.editedMessage } },
+                        messageTimestamp: protocolMsg.timestampMs ? Math.floor(toNumber(protocolMsg.timestampMs) / 1000) : message.messageTimestamp,
+                    },
+                }]);
+                break;
+            }
+
+            case proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE: {
+                const labelAssociationMsg = protocolMsg.memberLabel;
+                if (labelAssociationMsg?.label) {
+                    ev.emit('group.member-tag.update', { groupId: chat.id, label: labelAssociationMsg.label, participant: message.key.participant, participantAlt: message.key.participantAlt, messageTimestamp: Number(message.messageTimestamp) });
                 }
                 break;
-            case proto.Message.ProtocolMessage.Type.MESSAGE_EDIT:
-                ev.emit('messages.update', [
-                    {
-                        // flip the sender / fromMe properties because they're in the perspective of the sender
-                        key: { ...message.key, id: protocolMsg.key?.id },
-                        update: {
-                            message: {
-                                editedMessage: {
-                                    message: protocolMsg.editedMessage
-                                }
-                            },
-                            messageTimestamp: protocolMsg.timestampMs
-                                ? Math.floor(toNumber(protocolMsg.timestampMs) / 1000)
-                                : message.messageTimestamp
+            }
+
+            case proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE: {
+                const response = protocolMsg.peerDataOperationRequestResponseMessage;
+                if (!response) break;
+                // TODO: IMPLEMENT HISTORY SYNC ETC (sticker uploads etc.)
+                for (const result of (response.peerDataOperationResult || [])) {
+                    const retryResponse = result?.placeholderMessageResendResponse;
+                    if (!retryResponse?.webMessageInfoBytes) continue;
+                    try {
+                        const webMessageInfo = proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes);
+                        const msgId = webMessageInfo.key?.id;
+                        // Retrieve cached original message data — preserves LID details,
+                        // timestamps, etc. that the phone may omit in its PDO response
+                        const cachedData = msgId ? await placeholderResendCache?.get(msgId) : undefined;
+                        if (msgId) await placeholderResendCache?.del(msgId);
+                        let finalMsg;
+                        if (cachedData && typeof cachedData === 'object') {
+                            // Apply decoded message content onto cached metadata (preserves LID etc.)
+                            cachedData.message = webMessageInfo.message;
+                            if (webMessageInfo.messageTimestamp) cachedData.messageTimestamp = webMessageInfo.messageTimestamp;
+                            finalMsg = cachedData;
+                        } else {
+                            finalMsg = webMessageInfo;
                         }
+                        logger?.debug({ msgId, requestId: response.stanzaId }, 'received placeholder resend');
+                        ev.emit('messages.upsert', { messages: [finalMsg], type: 'notify', requestId: response.stanzaId });
+                    } catch (err) {
+                        logger?.warn({ err, stanzaId: response.stanzaId }, 'failed to decode placeholder resend response');
                     }
-                ]);
+                }
                 break;
-            case proto.Message.ProtocolMessage.Type.LID_MIGRATION_MAPPING_SYNC:
+            }
+
+            case proto.Message.ProtocolMessage.Type.LID_MIGRATION_MAPPING_SYNC: {
                 const encodedPayload = protocolMsg.lidMigrationMappingSyncMessage?.encodedMappingPayload;
                 const { pnToLidMappings, chatDbMigrationTimestamp } = proto.LIDMigrationMappingSyncPayload.decode(encodedPayload);
                 logger?.debug({ pnToLidMappings, chatDbMigrationTimestamp }, 'got lid mappings and chat db migration timestamp');
@@ -259,82 +287,73 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                     pairs.push({ lid: `${lid}@lid`, pn: `${pn}@s.whatsapp.net` });
                 }
                 await signalRepository.lidMapping.storeLIDPNMappings(pairs);
-                if (pairs.length) {
-                    for (const { pn, lid } of pairs) {
-                        await signalRepository.migrateSession(pn, lid);
-                    }
-                }
+                for (const { pn, lid } of pairs) await signalRepository.migrateSession(pn, lid);
+                break;
+            }
         }
-    }
-    else if (content?.reactionMessage) {
-        const reaction = {
-            ...content.reactionMessage,
-            key: message.key
-        };
-        ev.emit('messages.reaction', [
-            {
-                reaction,
-                key: content.reactionMessage?.key
+    } else if (content?.reactionMessage) {
+        ev.emit('messages.reaction', [{ reaction: { ...content.reactionMessage, key: message.key }, key: content.reactionMessage?.key }]);
+    } else if (content?.encEventResponseMessage) {
+        // Decrypt and re-emit event RSVPs — mirrors the poll vote flow but for calendar events
+        const encEventResponse = content.encEventResponseMessage;
+        const creationMsgKey = encEventResponse.eventCreationMessageKey;
+        const eventMsg = await getMessage(creationMsgKey);
+        if (eventMsg) {
+            try {
+                const meIdNormalised = jidNormalizedUser(meId);
+                // Event creator JID must be a PN — resolve from LID if necessary
+                const eventCreatorKey = creationMsgKey.participant || creationMsgKey.remoteJid;
+                const eventCreatorPn = isLidUser(eventCreatorKey) ? await signalRepository.lidMapping.getPNForLID(eventCreatorKey) : eventCreatorKey;
+                const eventCreatorJid = getKeyAuthor({ remoteJid: jidNormalizedUser(eventCreatorPn), fromMe: meIdNormalised === eventCreatorPn }, meIdNormalised);
+                const responderJid = getKeyAuthor(message.key, meIdNormalised);
+                const eventEncKey = eventMsg?.messageContextInfo?.messageSecret;
+                if (!eventEncKey) {
+                    logger?.warn({ creationMsgKey }, 'event response: missing messageSecret for decryption');
+                } else {
+                    const responseMsg = decryptEventResponse(encEventResponse, { eventEncKey, eventCreatorJid, eventMsgId: creationMsgKey.id, responderJid });
+                    ev.emit('messages.update', [{ key: creationMsgKey, update: { eventResponses: [{ eventResponseMessageKey: message.key, senderTimestampMs: responseMsg.timestampMs, response: responseMsg }] } }]);
+                }
+            } catch (err) {
+                logger?.warn({ err, creationMsgKey }, 'failed to decrypt event response');
             }
-        ]);
-    }
-    else if (message.messageStubType) {
+        } else {
+            logger?.warn({ creationMsgKey }, 'event creation message not found, cannot decrypt response');
+        }
+    } else if (message.messageStubType) {
         const jid = message.key?.remoteJid;
-        //let actor = whatsappID (message.participant)
         let participants;
-        const emitParticipantsUpdate = (action) => ev.emit('group-participants.update', {
-            id: jid,
-            author: message.key.participant,
-            authorPn: message.key.participantAlt,
-            participants,
-            action
-        });
-        const emitGroupUpdate = (update) => {
-            ev.emit('groups.update', [
-                { id: jid, ...update, author: message.key.participant ?? undefined, authorPn: message.key.participantAlt }
-            ]);
-        };
-        const emitGroupRequestJoin = (participant, action, method) => {
-            ev.emit('group.join-request', {
-                id: jid,
-                author: message.key.participant,
-                authorPn: message.key.participantAlt,
-                participant: participant.lid,
-                participantPn: participant.pn,
-                action,
-                method: method
-            });
-        };
-        const participantsIncludesMe = () => participants.find(jid => areJidsSameUser(meId, jid.phoneNumber)); // ADD SUPPORT FOR LID
+
+        const emitParticipantsUpdate = (action) => ev.emit('group-participants.update', { 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, authorUsername: message.key.participantUsername }]);
+        const emitGroupRequestJoin = (participant, action, method) => ev.emit('group.join-request', { id: jid, author: message.key.participant, authorPn: message.key.participantAlt, authorUsername: message.key.participantUsername, participant: participant.lid, participantPn: participant.pn, action, method });
+
+        // TODO: ADD SUPPORT FOR LID in participantsIncludesMe
+        const participantsIncludesMe = () => participants.find(p => areJidsSameUser(meId, p.phoneNumber));
+
         switch (message.messageStubType) {
             case WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER:
-                participants = message.messageStubParameters.map(a => { try { return JSON.parse(a) } catch { return { id: a } } }) || []
-                emitParticipantsUpdate('modify')
-                break
+                participants = message.messageStubParameters.map(a => JSON.parse(a)) || [];
+                emitParticipantsUpdate('modify');
+                break;
             case WAMessageStubType.GROUP_PARTICIPANT_LEAVE:
             case WAMessageStubType.GROUP_PARTICIPANT_REMOVE:
-                participants = message.messageStubParameters.map((a) => JSON.parse(a)) || [];
+                participants = message.messageStubParameters.map(a => JSON.parse(a)) || [];
                 emitParticipantsUpdate('remove');
-                // mark the chat read only if you left the group
-                if (participantsIncludesMe()) {
-                    chat.readOnly = true;
-                }
+                if (participantsIncludesMe()) chat.readOnly = true;
                 break;
             case WAMessageStubType.GROUP_PARTICIPANT_ADD:
             case WAMessageStubType.GROUP_PARTICIPANT_INVITE:
             case WAMessageStubType.GROUP_PARTICIPANT_ADD_REQUEST_JOIN:
-                participants = message.messageStubParameters.map((a) => JSON.parse(a)) || [];
-                if (participantsIncludesMe()) {
-                    chat.readOnly = false;
-                }
+                participants = message.messageStubParameters.map(a => JSON.parse(a)) || [];
+                if (participantsIncludesMe()) chat.readOnly = false;
                 emitParticipantsUpdate('add');
                 break;
             case WAMessageStubType.GROUP_PARTICIPANT_DEMOTE:
-                participants = message.messageStubParameters.map((a) => JSON.parse(a)) || [];
+                participants = message.messageStubParameters.map(a => JSON.parse(a)) || [];
                 emitParticipantsUpdate('demote');
                 break;
             case WAMessageStubType.GROUP_PARTICIPANT_PROMOTE:
-                participants = message.messageStubParameters.map((a) => JSON.parse(a)) || [];
+                participants = message.messageStubParameters.map(a => JSON.parse(a)) || [];
                 emitParticipantsUpdate('promote');
                 break;
             case WAMessageStubType.GROUP_CHANGE_ANNOUNCE:
@@ -423,9 +442,9 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             )
         }
         } */
-    if (Object.keys(chat).length > 1) {
-        ev.emit('chats.update', [chat]);
-    }
+
+    if (Object.keys(chat).length > 1) ev.emit('chats.update', [chat]);
 };
+
 export default processMessage;
 //# sourceMappingURL=process-message.js.map

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

@@ -1,7 +1,10 @@
 import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+import { migrateIndexKey, TC_TOKEN_INDEX_KEY } from '../Utils/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
@@ -9,93 +12,73 @@ 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;
+    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)
+    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). */
+
+/** Read the persisted tctoken JID index and return its entries. */
 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 [];
-    }
+    const batch = await migrateIndexKey(keys, 'tctoken');
+    return Object.keys(batch).filter(j => j && j !== TC_TOKEN_INDEX_KEY);
 }
-/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the index 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])) }
-    };
+    const batch = await migrateIndexKey(keys, 'tctoken');
+    const merged = { ...batch };
+    for (const jid of addedJids) { if (jid && jid !== TC_TOKEN_INDEX_KEY) merged[jid] = merged[jid] || true; }
+    return { [TC_TOKEN_INDEX_KEY]: 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;
+    if (timestamp === null || timestamp === undefined) return true;
     const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
-    if (isNaN(ts))
-        return true;
+    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;
+    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;
+    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;
+        if (isLidUser(jid)) return jid;
         const lid = await getLIDForPN(jid);
         return lid ?? jid;
     }
-    if (!isLidUser(jid))
-        return 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);
@@ -114,49 +97,31 @@ export async function buildTcTokenFromJid({ authState, jid, baseContent = [], ge
             }
             return baseContent.length > 0 ? baseContent : undefined;
         }
-        baseContent.push({
-            tag: 'tctoken',
-            attrs: {},
-            content: tcTokenBuffer
-        });
+        baseContent.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer });
         return baseContent;
-    }
-    catch (error) {
+    } 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;
+    if (!tokensNode) return;
     const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
     for (const tokenNode of tokenNodes) {
-        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
-            continue;
-        }
+        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;
+        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
-                }
-            }
-        });
+        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);
     }
 }

package/lib/index.js

@@ -31,7 +31,7 @@ const banner = `
 const info = `
 ┌───────────────────────────────────────────────────────────────────────┐
 │  📦 Package: @nexustechpro/baileys                                   │
-│  🔖 Version: 2.1.2                                                  │
+│  🔖 Version: 2.1.3                                                  │
 │  ⚡ Status:  Production Ready                                        │
 ├───────────────────────────────────────────────────────────────────────┤
 │  🚀 Advanced WhatsApp Web API Client                                  │

package/package.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nexustechpro/baileys",
   "type": "module",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "Advanced WhatsApp Web API built on Baileys — interactive messages, buttons, carousels, products, events, payments, polls, albums, sticker packs and more.",
   "keywords": [
     "whatsapp",