@nexustechpro/baileys 2.1.2 → 2.1.6

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

@@ -1,101 +1,119 @@
 import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+import { TC_TOKEN_INDEX_KEY, unixTimestampSeconds } from '../Utils/index.js';
+import { randomBytes } from 'crypto'
 // Same phone-number pattern as WABinary's isJidBot, applied against the user
 // part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
 const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+
+const generateTcToken = () => {
+    const bucket = Math.floor(unixTimestampSeconds() / 604800)
+    const bucketByte = (bucket - 2900) & 0xff
+    return Buffer.concat([
+        Buffer.from([0x04, 0x01, bucketByte]),
+        randomBytes(8)
+    ])
+}
+
+export const preSeedTcToken = async ({ authState, jid, getLIDForPN, logger }) => {
+    const tcTokenJid = await resolveTcTokenJid(jid, getLIDForPN)
+    const existing = await authState.keys.get('tctoken', [tcTokenJid])
+    if (existing[tcTokenJid]?.token?.length) return { token: existing[tcTokenJid].token, storageJid: tcTokenJid }
+    const token = generateTcToken()
+    const timestamp = String(unixTimestampSeconds())
+    const indexWrite = await buildMergedTcTokenIndexWrite(authState.keys, [tcTokenJid])
+    const existingEntry = existing[tcTokenJid] || {}
+    await authState.keys.set({ tctoken: { [tcTokenJid]: { ...existingEntry, token, timestamp }, ...indexWrite } })
+    logger?.debug({ jid, tcTokenJid }, 'pre-seeded locally generated tctoken')
+    return { token, storageJid: tcTokenJid }
+}
 /**
  * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
  * storage against malformed notifications — WA Web filters server-side but we
  * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
  * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
  */
-function isRegularUser(jid) {
-    if (!jid)
-        return false;
+export function isRegularUser(jid) {
+    if (!jid) return false;
     const user = jid.split('@')[0] ?? '';
-    if (user === '0')
-        return false; // PSA
-    if (BOT_PHONE_REGEX.test(user))
-        return false; // Bot by phone pattern
-    if (isJidMetaAI(jid))
-        return false; // MetaAI (@bot server)
+    if (user === '0') return false; // PSA
+    if (BOT_PHONE_REGEX.test(user)) return false; // Bot by phone pattern
+    if (isJidMetaAI(jid)) return false; // MetaAI (@bot server)
     return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
 }
+
 const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
 const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
-/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
-export const TC_TOKEN_INDEX_KEY = '__index';
-/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+
 export async function readTcTokenIndex(keys) {
-    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
-    const entry = data[TC_TOKEN_INDEX_KEY];
-    if (!entry?.token?.length)
-        return [];
-    try {
-        const 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 [];
+    // Try new sentinel key first, fall back to old 'index' key
+    for (const key of [TC_TOKEN_INDEX_KEY, 'index']) {
+        const data = await keys.get('tctoken', [key])
+        const entry = data[key]
+        if (!entry?.token?.length) continue
+        try {
+            const parsed = JSON.parse(Buffer.from(entry.token).toString())
+            if (!Array.isArray(parsed)) continue
+            return parsed.filter(j => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY && j !== 'index')
+        } catch {
+            continue
+        }
     }
+    return []
 }
-/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+
 export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
-    const persisted = await readTcTokenIndex(keys);
-    const merged = new Set(persisted);
+    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);
+        if (jid && jid !== TC_TOKEN_INDEX_KEY && jid !== 'index') merged.add(jid)
     }
     return {
         [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
-    };
+    }
 }
 // WA Web has separate sender/receiver AB props for these but they're identical today
 export function isTcTokenExpired(timestamp) {
-    if (timestamp === null || timestamp === undefined)
-        return true;
+    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;
-    const lid = await getLIDForPN(jid);
-    return lid ?? jid;
+    if (isLidUser(jid)) return jid
+    const lid = await getLIDForPN(jid)
+    if (!lid) return null
+    return lid
 }
+
 /** 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 +132,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

@@ -2,17 +2,30 @@ import { Mutex } from 'async-mutex'
 import { mkdir, readFile, rename, stat, unlink, writeFile, readdir } from 'fs/promises'
 import { join } from 'path'
 import { createHash } from 'crypto'
+import { Keyv } from 'keyv'
 import { proto } from '../../WAProto/index.js'
 import { initAuthCreds } from './auth-utils.js'
 import { BufferJSON } from './generics.js'
+import { PROTOCOL_ADAPTERS } from '../WABinary/index.js'
 
-// ─── Constants ────────────────────────────────────────────────────────────────
 const CURRENT_VERSION = 1
 const DEFAULT_PREKEY_RETENTION = 150
 const DEFAULT_CLEANUP_THRESHOLD = 50
 const CLEANUP_INTERVAL_MS = 10 * 60 * 1000
 
-// ─── File Lock Registry ───────────────────────────────────────────────────────
+const bootstrapCreds = (raw) => {
+    const c = raw ?? initAuthCreds()
+    if (!c.__version || c.__version < CURRENT_VERSION) c.__version = CURRENT_VERSION
+    return c
+}
+
+const patchAppStateKey = (type, v) =>
+    type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
+
+const computeChecksum = (data) => createHash('sha256').update(data).digest('hex')
+
+// ─── File-based auth state ────────────────────────────────────────────────────
+
 const fileLocks = new Map()
 const getFileLock = (path) => {
     if (!fileLocks.has(path)) fileLocks.set(path, new Mutex())
@@ -22,31 +35,13 @@ const releaseFileLock = (path) => {
     if (fileLocks.has(path) && !fileLocks.get(path).isLocked()) fileLocks.delete(path)
 }
 
-// ─── Checksum ─────────────────────────────────────────────────────────────────
-const computeChecksum = (data) => createHash('sha256').update(data).digest('hex')
-
-/**
- * Production-grade multi-file auth state for Baileys.
- * Atomic writes, checksum integrity, and smart prekey cleanup.
- * Compatible with standard Baileys auth folder format.
- *
- * @param {string} folder - Directory to store auth files
- * @param {object} [options] - Configuration options
- * @param {number} [options.preKeyRetention=150] - How many recent prekeys to keep
- * @param {number} [options.cleanupThreshold=50] - How many new prekeys trigger a cleanup
- * @param {object} [options.logger] - Optional logger with .info/.warn methods
- */
 export const useMultiFileAuthState = async (folder, options = {}) => {
-    const {
-        preKeyRetention = DEFAULT_PREKEY_RETENTION,
-        cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD,
-        logger,
-    } = options
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger } = options
+
     const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-')
     const filePath = (file) => join(folder, fixFileName(file))
     const tmpPath = (file) => filePath(file) + '.tmp'
 
-    // ─── Folder Bootstrap ───────────────────────────────────────────────────────
     const folderInfo = await stat(folder).catch(() => null)
     if (folderInfo) {
         if (!folderInfo.isDirectory()) throw new Error(`Path exists but is not a directory: ${folder}`)
@@ -54,16 +49,13 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
         await mkdir(folder, { recursive: true })
     }
 
-    // ─── Atomic Write ────────────────────────────────────────────────────────────
     const writeData = async (data, file) => {
         const fp = filePath(file)
         const tp = tmpPath(file)
-        const mutex = getFileLock(fp)
-        const release = await mutex.acquire()
+        const release = await getFileLock(fp).acquire()
         try {
             const serialized = JSON.stringify(data, BufferJSON.replacer)
-            const checksum = computeChecksum(serialized)
-            const payload = JSON.stringify({ data: JSON.parse(serialized), __checksum: checksum })
+            const payload = JSON.stringify({ data: JSON.parse(serialized), __checksum: computeChecksum(serialized) })
             await writeFile(tp, payload)
             try {
                 await rename(tp, fp)
@@ -77,11 +69,9 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
         }
     }
 
-    // ─── Read with Checksum Verification ─────────────────────────────────────────
     const readData = async (file) => {
         const fp = filePath(file)
-        const mutex = getFileLock(fp)
-        const release = await mutex.acquire()
+        const release = await getFileLock(fp).acquire()
         try {
             const raw = await readFile(fp, { encoding: 'utf-8' }).catch(() => null)
             if (!raw) return null
@@ -92,28 +82,26 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
                     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 — 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(() => { })
+                await writeFile(fp, JSON.stringify({ data: JSON.parse(reserialized), __checksum: computeChecksum(reserialized) })).catch(() => { })
                 return JSON.parse(raw, BufferJSON.reviver)
             } catch (err) {
                 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 ────────────────────────────────────────────────────────────
     const removeData = async (file) => {
         const fp = filePath(file)
-        const mutex = getFileLock(fp)
-        const release = await mutex.acquire()
+        const release = await getFileLock(fp).acquire()
         try {
             await unlink(fp).catch(() => { })
         } finally {
@@ -122,34 +110,23 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
         }
     }
 
-    // ─── Credentials Bootstrap ──────────────────────────────────────────────────
-    let creds = (await readData('creds.json')) || initAuthCreds()
-    if (!creds.__version) {
-        creds.__version = CURRENT_VERSION
-    } else if (creds.__version < CURRENT_VERSION) {
-        creds.__version = CURRENT_VERSION
-    }
-
-    // ─── Prekey Cleanup ─────────────────────────────────────────────────────────
+    let creds = bootstrapCreds(await readData('creds.json'))
     let cleanupRunning = false
     let lastCleanupAt = 0
     let lastCleanedPreKeyId = creds.nextPreKeyId
 
     const cleanOldPreKeys = async () => {
         const now = Date.now()
-        if (cleanupRunning) return
-        if (now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        if (cleanupRunning || now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
         cleanupRunning = true
         try {
             const minId = creds.nextPreKeyId - preKeyRetention
             if (minId <= 0) return
             const files = await readdir(folder)
-            const targets = []
-            for (const file of files) {
-                const match = file.match(/^pre-key-(\d+)\.json(\.tmp)?$/)
-                if (!match) continue
-                if (parseInt(match[1], 10) < minId) targets.push(join(folder, file))
-            }
+            const targets = files
+                .map(f => f.match(/^pre-key-(\d+)\.json(\.tmp)?$/))
+                .filter(m => m && parseInt(m[1], 10) < minId)
+                .map(m => join(folder, m[0]))
             if (!targets.length) return
             await Promise.all(targets.map(f => unlink(f).catch(() => { })))
             lastCleanupAt = Date.now()
@@ -164,7 +141,6 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
 
     cleanOldPreKeys().catch(() => { })
 
-    // ─── Stats ──────────────────────────────────────────────────────────────────
     const getStats = async () => {
         const files = await readdir(folder).catch(() => [])
         const preKeyFiles = files.filter(f => /^pre-key-\d+\.json$/.test(f))
@@ -184,9 +160,7 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
                     const data = {}
                     await Promise.all(ids.map(async (id) => {
                         let value = await readData(`${type}-${id}.json`)
-                        if (type === 'app-state-sync-key' && value) {
-                            value = proto.Message.AppStateSyncKeyData.fromObject(value)
-                        }
+                        if (type === 'app-state-sync-key' && value) value = proto.Message.AppStateSyncKeyData.fromObject(value)
                         data[id] = value
                     }))
                     return data
@@ -204,11 +178,185 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
             },
         },
         saveCreds: async () => {
-            if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) {
-                cleanOldPreKeys().catch(() => { })
-            }
+            if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
             return writeData(creds, 'creds.json')
         },
         getStats,
     }
-}
+}
+
+// ─── Keyv-backed auth state ───────────────────────────────────────────────────
+
+const ser = (v) => {
+    if (v == null) return null
+    const serialized = JSON.stringify(v, BufferJSON.replacer)
+    return { data: JSON.parse(serialized), __checksum: computeChecksum(serialized) }
+}
+
+const unwrapNestedValue = (obj) => {
+    let cur = obj
+    while (cur && typeof cur === 'object' && !Array.isArray(cur) && Object.keys(cur).length === 1 && 'value' in cur) cur = cur.value
+    return cur
+}
+
+const deser = (raw, logger, onRewrite) => {
+    if (raw == null) return null
+    let parsed
+    if (typeof raw === 'string') {
+        try { parsed = JSON.parse(raw) } catch (err) {
+            logger?.warn?.({ err: err.message }, '[Auth] failed to parse stored value — treating as missing')
+            return null
+        }
+    } else {
+        parsed = raw
+    }
+    parsed = unwrapNestedValue(parsed)
+    if (parsed == null) return null
+    if (typeof parsed === 'object' && '__checksum' in parsed) {
+        const innerData = unwrapNestedValue(parsed.data)
+        const serializedInner = JSON.stringify(innerData)
+        const expected = computeChecksum(serializedInner)
+        if (expected !== parsed.__checksum) {
+            logger?.warn?.('[Auth] checksum mismatch or legacy-wrapped value — reinitializing')
+            onRewrite?.(JSON.stringify({ data: innerData, __checksum: expected }))
+        }
+        return JSON.parse(serializedInner, BufferJSON.reviver)
+    }
+    return JSON.parse(JSON.stringify(parsed), BufferJSON.reviver)
+}
+
+// Maps our unified collectionName option to each adapter's actual constructor key
+const COLLECTION_OPTION_KEY = {
+    '@keyv/mongo': 'collection',
+    '@keyv/postgres': 'table',
+    '@keyv/mysql': 'table',
+    '@keyv/sqlite': 'table',
+}
+
+const _adapterCache = new Map()
+export const clearAdapterCache = () => _adapterCache.clear()
+
+const resolveAdapter = async (connectionString, collectionName) => {
+    const cacheKey = collectionName ? `${connectionString}::${collectionName}` : connectionString
+    if (_adapterCache.has(cacheKey)) return _adapterCache.get(cacheKey)
+    let protocol
+    try { protocol = new URL(connectionString).protocol } catch { throw new Error(`[Auth] Invalid connection string: "${connectionString}"`) }
+    const pkg = PROTOCOL_ADAPTERS[protocol]
+    if (!pkg) throw new Error(`[Auth] Unsupported protocol "${protocol}" — supported: redis, mongodb, postgresql, mysql, sqlite, etcd, memcache. Pass a pre-built KeyvStoreAdapter instance for anything else.`)
+    let mod
+    try { mod = await import(pkg) } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') throw new Error(`[Auth] "${pkg}" is required for this backend — install it: npm i ${pkg}`)
+        throw e
+    }
+    const Adapter = mod.default ?? mod[Object.keys(mod)[0]]
+    const optionKey = COLLECTION_OPTION_KEY[pkg]
+    // Pass one merged options object — Postgres/MySQL silently ignore a second positional argument
+    const adapter = (collectionName && optionKey)
+        ? new Adapter({ url: connectionString, uri: connectionString, [optionKey]: collectionName })
+        : new Adapter(connectionString)
+    adapter.setMaxListeners?.(0)
+    _adapterCache.set(cacheKey, adapter)
+    return adapter
+}
+
+const isAdapterLike = (v) => v && typeof v === 'object' && typeof v.get === 'function' && typeof v.set === 'function' && typeof v.delete === 'function' && typeof v.clear === 'function'
+
+const resolveStore = async (backend, collectionName) => {
+    if (backend == null) return null
+    if (typeof backend === 'string') return resolveAdapter(backend, collectionName)
+    if (backend instanceof Keyv) return backend.opts?.store ?? backend.store ?? null
+    if (isAdapterLike(backend)) return backend
+    throw new Error('[Auth] backend must be a connection string, Keyv instance, or KeyvStoreAdapter')
+}
+
+export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger, collectionName } = opts
+
+    const store = await resolveStore(backend, collectionName)
+    const keyv = store ? new Keyv({ store, namespace: sessionId }) : new Keyv({ namespace: sessionId })
+    keyv.on('error', (err) => logger?.warn?.({ err: err?.message }, '[Auth] store error'))
+
+    const keyName = (type, id) => `${type}-${id}`
+
+    let creds = bootstrapCreds(deser(await keyv.get('creds'), logger, (fixed) => keyv.set('creds', fixed)))
+    let cleanupRunning = false
+    let lastCleanupAt = 0
+    let lastCleanedPreKeyId = creds.nextPreKeyId
+
+    const cleanOldPreKeys = async () => {
+        const now = Date.now()
+        if (cleanupRunning || now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        cleanupRunning = true
+        try {
+            const minId = creds.nextPreKeyId - preKeyRetention
+            if (minId <= 0) return
+            const ids = []
+            for (let id = Math.max(0, lastCleanedPreKeyId - preKeyRetention); id < minId; id++) ids.push(keyName('pre-key', id))
+            if (!ids.length) return
+            await Promise.all(ids.map((k) => keyv.delete(k).catch(() => { })))
+            lastCleanupAt = Date.now()
+            lastCleanedPreKeyId = creds.nextPreKeyId
+            logger?.info?.({ deleted: ids.length, minId }, '[Auth] prekey cleanup done')
+        } catch (e) {
+            logger?.warn?.({ err: e.message }, '[Auth] prekey cleanup failed')
+        } finally {
+            cleanupRunning = false
+        }
+    }
+
+    cleanOldPreKeys().catch(() => { })
+
+    const keys = {
+        get: async (type, ids) => {
+            const data = {}
+            if (!ids.length) return data
+            const rawKeys = ids.map((id) => keyName(type, id))
+            const rawValues = await keyv.getMany(rawKeys)
+            const rewrites = []
+            ids.forEach((id, i) => {
+                data[id] = patchAppStateKey(type, deser(rawValues[i], logger, (fixed) => rewrites.push(keyv.set(rawKeys[i], fixed))))
+            })
+            if (rewrites.length) await Promise.all(rewrites).catch(() => { })
+            return data
+        },
+        set: async (data) => {
+            const setEntries = []
+            const delKeys = []
+            for (const type in data) {
+                for (const id in data[type]) {
+                    const value = data[type][id]
+                    const key = keyName(type, id)
+                    if (value != null) setEntries.push({ key, value: ser(value) })
+                    else delKeys.push(key)
+                }
+            }
+            await Promise.all([
+                setEntries.length ? keyv.setMany(setEntries) : null,
+                delKeys.length ? keyv.deleteMany(delKeys) : null,
+            ])
+        },
+    }
+
+    const saveCreds = async () => {
+        if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
+        await keyv.set('creds', ser(creds))
+    }
+
+    const clearSession = async () => {
+        const store = keyv.opts?.store ?? keyv.store
+        if (store && typeof store.deleteMany === 'function' && typeof store.iterator === 'function') {
+            const toDelete = []
+            for await (const [key] of store.iterator(sessionId)) toDelete.push(key)
+            if (toDelete.length) await store.deleteMany(toDelete)
+        } else {
+            await keyv.clear()
+        }
+        await close()
+    }
+
+    const close = async () => { keyv.removeAllListeners?.() }
+
+    return { state: { creds, keys }, saveCreds, clearSession }
+}
+
+export { Keyv }

package/lib/Utils/validate-connection.js

@@ -13,7 +13,9 @@ const getUserAgent = (config) => {
             secondary: config.version[1],
             tertiary: config.version[2]
         },
-        platform: proto.ClientPayload.UserAgent.Platform.WEB,
+        platform: config.browser[1].toLocaleLowerCase().includes('android')
+            ? proto.ClientPayload.UserAgent.Platform.MACOS
+            : proto.ClientPayload.UserAgent.Platform.WEB,
         releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         osVersion: '0.1',
         device: 'Desktop',
@@ -43,7 +45,9 @@ const getClientPayload = (config) => {
         connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config)
     };
-    payload.webInfo = getWebInfo(config);
+    if (!config.browser[1].toLowerCase().includes('android')) {
+        payload.webInfo = getWebInfo(config)
+    }
     return payload;
 };
 export const generateLoginNode = (userJid, config) => {
@@ -61,6 +65,9 @@ export const generateLoginNode = (userJid, config) => {
 };
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase();
+    if (platformType === 'ANDROID') {
+        return proto.DeviceProps.PlatformType.ANDROID_PHONE;
+    }
     return (proto.DeviceProps.PlatformType[platformType] ||
         proto.DeviceProps.PlatformType.CHROME);
 };
@@ -77,6 +84,7 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
         historySyncConfig: {
             storageQuotaMb: 569150,
             inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
             supportCallLogHistory: false,
             supportBotUserAgentChatHistory: true,
             supportCagReactionsAndPolls: true,
@@ -84,7 +92,11 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
             supportRecentSyncChunkMessageCountTuning: true,
             supportHostedGroupMsg: true,
             supportFbidBotChatHistory: true,
-            supportMessageAssociation: true
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
         },
         version: {
             primary: 10,