@nexustechpro/baileys 2.1.0 → 2.1.3

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/Utils/use-multi-file-auth-state.js

@@ -65,7 +65,12 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
             const checksum = computeChecksum(serialized)
             const payload = JSON.stringify({ data: JSON.parse(serialized), __checksum: checksum })
             await writeFile(tp, payload)
-            await rename(tp, fp)
+            try {
+                await rename(tp, fp)
+            } catch {
+                await writeFile(fp, payload)
+                await unlink(tp).catch(() => { })
+            }
         } finally {
             release()
             releaseFileLock(fp)
@@ -84,19 +89,24 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
                 const parsed = JSON.parse(raw)
                 if (parsed.__checksum) {
                     const expected = computeChecksum(JSON.stringify(parsed.data))
-                    if (expected !== parsed.__checksum) throw new Error('checksum mismatch')
+                    if (expected !== parsed.__checksum) {
+                        logger?.warn({ file }, 'checksum mismatch — reinitializing file')
+                        await writeFile(fp, JSON.stringify({ data: parsed.data, __checksum: computeChecksum(JSON.stringify(parsed.data)) })).catch(() => { })
+                        return JSON.parse(JSON.stringify(parsed.data), BufferJSON.reviver)
+                    }
                     return JSON.parse(JSON.stringify(parsed.data), BufferJSON.reviver)
                 }
-                // legacy file without checksum — read as-is for compatibility
+                // legacy file — rewrite with checksum
+                const reserialized = JSON.stringify(JSON.parse(raw, BufferJSON.reviver), BufferJSON.replacer)
+                const checksum = computeChecksum(reserialized)
+                await writeFile(fp, JSON.stringify({ data: JSON.parse(reserialized), __checksum: checksum })).catch(() => { })
                 return JSON.parse(raw, BufferJSON.reviver)
             } catch (err) {
-                logger?.warn({ file, err: err.message }, 'failed to read auth file')
+                logger?.warn({ file, err: err.message }, 'failed to read auth file — reinitializing')
+                await unlink(fp).catch(() => { })
                 return null
             }
-        } finally {
-            release()
-            releaseFileLock(fp)
-        }
+        } finally { release(); releaseFileLock(fp) }
     }
 
     // ─── Remove File ────────────────────────────────────────────────────────────

package/lib/index.js

@@ -31,7 +31,7 @@ const banner = `
 const info = `
 ┌───────────────────────────────────────────────────────────────────────┐
 │  📦 Package: @nexustechpro/baileys                                   │
-│  🔖 Version: 2.1.0                                                  │
+│  🔖 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.0",
+  "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",
@@ -100,8 +100,8 @@
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "^1.4.0",
-    "@microlink/mql": "^0.16.1",
     "@hapi/boom": "^9.1.3",
+    "@microlink/mql": "^0.16.1",
     "async-mutex": "^0.5.0",
     "axios": "^1.6.0",
     "cache-manager": "latest",