@japofc/baileys 2.1.0

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

@@ -0,0 +1,162 @@
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false; // PSA
+    if (BOT_PHONE_REGEX.test(user))
+        return false; // Bot by phone pattern
+    if (isJidMetaAI(jid))
+        return false; // MetaAI (@bot server)
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY = '__index';
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
+    const entry = data[TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length)
+        return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+export function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined)
+        return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts))
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+export function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined)
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared = entry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode)
+        return;
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}

package/lib/Utils/templates.d.ts

@@ -0,0 +1,76 @@
+export interface TemplateVariable {
+    name: string;
+    defaultValue?: string;
+    required: boolean;
+}
+export interface MessageTemplate {
+    id: string;
+    name: string;
+    content: string;
+    description?: string;
+    category?: string;
+    variables: TemplateVariable[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type TemplateData = Record<string, string | number | undefined | null>;
+export declare class TemplateManager {
+    private templates;
+    private generateId;
+    private extractVariables;
+    create(options: {
+        id?: string;
+        name: string;
+        content: string;
+        description?: string;
+        category?: string;
+    }): MessageTemplate;
+    get(id: string): MessageTemplate | undefined;
+    getByName(name: string): MessageTemplate | undefined;
+    getAll(): MessageTemplate[];
+    getByCategory(category: string): MessageTemplate[];
+    update(id: string, updates: Partial<MessageTemplate>): MessageTemplate | undefined;
+    delete(id: string): boolean;
+    renderContent(content: string, data?: TemplateData): string;
+    render(id: string, data?: TemplateData): string;
+    validate(id: string, data: TemplateData): {
+        valid: boolean;
+        missing: string[];
+    };
+    export(): string;
+    import(json: string, overwrite?: boolean): number;
+}
+export declare const PRESET_TEMPLATES: {
+    ORDER_CONFIRMATION: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    WELCOME: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    REMINDER: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    SUPPORT_TICKET: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    BIRTHDAY: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    INVOICE: {
+        name: string;
+        category: string;
+        content: string;
+    };
+};
+export declare const createTemplateManager: (includePresets?: boolean) => TemplateManager;
+export declare const renderTemplate: (content: string, data?: TemplateData) => string;

package/lib/Utils/templates.js

@@ -0,0 +1,150 @@
+// JAP@Add --- part of the @japofc/baileys utils (templates.ts) (type-only
+// annotations dropped; behavior unchanged).
+export class TemplateManager {
+    templates = new Map();
+    generateId() {
+        return `tpl_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    extractVariables(content) {
+        const regex = /\{\{(\w+)(?::([^}]*))?\}\}/g;
+        const variables = [];
+        const seen = new Set();
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const name = match[1];
+            if (!name || seen.has(name))
+                continue;
+            seen.add(name);
+            variables.push({ name, defaultValue: match[2], required: !match[2] });
+        }
+        return variables;
+    }
+    create(options) {
+        const template = {
+            id: options.id ?? this.generateId(),
+            name: options.name,
+            content: options.content,
+            description: options.description,
+            category: options.category,
+            variables: this.extractVariables(options.content),
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        this.templates.set(template.id, template);
+        return template;
+    }
+    get(id) {
+        return this.templates.get(id);
+    }
+    getByName(name) {
+        return Array.from(this.templates.values()).find((t) => t.name === name);
+    }
+    getAll() {
+        return Array.from(this.templates.values());
+    }
+    getByCategory(category) {
+        return Array.from(this.templates.values()).filter((t) => t.category === category);
+    }
+    update(id, updates) {
+        const template = this.templates.get(id);
+        if (!template)
+            return undefined;
+        if (updates.content)
+            updates.variables = this.extractVariables(updates.content);
+        const updated = { ...template, ...updates, updatedAt: new Date() };
+        this.templates.set(id, updated);
+        return updated;
+    }
+    delete(id) {
+        return this.templates.delete(id);
+    }
+    renderContent(content, data = {}) {
+        return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+            const value = data[name];
+            if (value !== undefined && value !== null)
+                return String(value);
+            if (defaultValue !== undefined)
+                return defaultValue;
+            return match;
+        });
+    }
+    render(id, data = {}) {
+        const template = this.templates.get(id);
+        if (!template)
+            throw new Error(`Template not found: ${id}`);
+        return this.renderContent(template.content, data);
+    }
+    validate(id, data) {
+        const template = this.templates.get(id);
+        if (!template)
+            throw new Error(`Template not found: ${id}`);
+        const missing = template.variables.filter((v) => v.required && !(v.name in data)).map((v) => v.name);
+        return { valid: missing.length === 0, missing };
+    }
+    export() {
+        return JSON.stringify(Array.from(this.templates.values()), null, 2);
+    }
+    import(json, overwrite = false) {
+        const templates = JSON.parse(json);
+        let imported = 0;
+        for (const t of templates) {
+            if (!overwrite && this.templates.has(t.id))
+                continue;
+            this.templates.set(t.id, { ...t, createdAt: new Date(t.createdAt), updatedAt: new Date(t.updatedAt) });
+            imported++;
+        }
+        return imported;
+    }
+}
+/** Ready-made templates covering common bot scenarios (order, welcome, reminder, etc). */
+export const PRESET_TEMPLATES = {
+    ORDER_CONFIRMATION: {
+        name: 'Order Confirmation',
+        category: 'order',
+        content: `✅ *Order Confirmed!*\n\nOrder ID: #{{orderId}}\nCustomer: {{customerName}}\nDate: {{orderDate}}\n\n📦 *Items:*\n{{items}}\n\n💰 *Total: {{total}}*\n\nThank you! 🙏`
+    },
+    WELCOME: {
+        name: 'Welcome Message',
+        category: 'greeting',
+        content: `👋 *Welcome, {{name}}!*\n\nThank you for joining {{companyName:us}}!\nNeed help? Reply to this message!`
+    },
+    REMINDER: {
+        name: 'Reminder',
+        category: 'notification',
+        content: `⏰ *Reminder*\n\nHi {{name}},\n\n📋 {{subject}}\n📅 Date: {{date}}\n🕐 Time: {{time}}\n📍 Location: {{location:TBD}}`
+    },
+    SUPPORT_TICKET: {
+        name: 'Support Ticket',
+        category: 'support',
+        content: `🎫 *Support Ticket Created*\n\nTicket #: {{ticketId}}\nSubject: {{subject}}\n\nHi {{name}},\n\nWe received your request! Response time: {{responseTime:24 hours}} 🙏`
+    },
+    BIRTHDAY: {
+        name: 'Birthday Wishes',
+        category: 'greeting',
+        content: `🎂 *Happy Birthday, {{name}}!* 🎉\n\nWishing you a wonderful day!\n\n🎁 Use code: {{code}} for {{discount:10}}% off! 🥳`
+    },
+    INVOICE: {
+        name: 'Invoice',
+        category: 'invoice',
+        content: `🧾 *Invoice {{invoiceNumber}}*\n\nBilled to: {{customerName}}\nInvoice date: {{invoiceDate}}\nDue date: {{dueDate:on receipt}}\n\n📋 *Items:*\n{{items}}\n\nSubtotal: {{subtotal}}\n💰 *Total: {{total}}*\n\nThank you for your business! 🙏`
+    }
+};
+export const createTemplateManager = (includePresets = true) => {
+    const manager = new TemplateManager();
+    if (includePresets) {
+        for (const [key, template] of Object.entries(PRESET_TEMPLATES)) {
+            manager.create({ ...template, id: key.toLowerCase() });
+        }
+    }
+    return manager;
+};
+export const renderTemplate = (content, data = {}) => {
+    return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+        const value = data[name];
+        if (value !== undefined && value !== null)
+            return String(value);
+        if (defaultValue !== undefined)
+            return defaultValue;
+        return match;
+    });
+};

package/lib/Utils/transcribe.d.ts

@@ -0,0 +1,12 @@
+export type TranscriptionProvider = (audio: Buffer, meta?: { mimetype?: string }) => Promise<{ text: string }>;
+export declare const customProvider: (fn: (audio: Buffer, meta?: any) => Promise<{ text: string } | string> | { text: string } | string) => TranscriptionProvider;
+export interface WhisperProviderOptions {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    language?: string;
+    fileName?: string;
+}
+export declare const openAIWhisperProvider: (opts: WhisperProviderOptions) => TranscriptionProvider;
+export declare const transcribeAudio: (audio: Buffer, opts?: { provider?: TranscriptionProvider; mimetype?: string }) => Promise<{ text: string }>;
+export declare const transcribeMessage: (sock: any, webMessage: any, opts?: { provider?: TranscriptionProvider; download?: (keys: any) => Promise<any> }) => Promise<{ text: string; seconds: number | null; ptt: boolean }>;

package/lib/Utils/transcribe.js

@@ -0,0 +1,107 @@
+/**
+ * JAP@Add --- voice-note transcription with pluggable providers.
+ *
+ * WhatsApp generates transcripts on-device only — there is no transcript API
+ * on the wire. So this module downloads the voice note and hands it to a
+ * *provider function* you choose: any `(audioBuffer, { mimetype }) => { text }`.
+ * Ships with an OpenAI-compatible Whisper provider; bring your own for local
+ * models (faster-whisper sidecar, etc).
+ *
+ * ```js
+ * import { transcribeMessage, openAIWhisperProvider } from '@japofc/baileys'
+ * const provider = openAIWhisperProvider({ apiKey: process.env.OPENAI_API_KEY })
+ * sock.ev.on('messages.upsert', async ({ messages }) => {
+ *   for (const m of messages) {
+ *     if (m.message?.audioMessage?.ptt) console.log(await transcribeMessage(sock, m, { provider }))
+ *   }
+ * })
+ * ```
+ */
+import { Boom } from '@hapi/boom';
+import { downloadContentFromMessage } from './messages-media.js';
+
+const streamToBuffer = async (stream) => {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+};
+
+const needProvider = (provider) => {
+    if (typeof provider !== 'function') {
+        throw new Boom('transcription needs { provider } — see customProvider() / openAIWhisperProvider()', { statusCode: 400 });
+    }
+};
+
+/** Wrap any async `(audioBuffer, meta) => { text } | string` fn into a provider. */
+export const customProvider = (fn) => {
+    if (typeof fn !== 'function') {
+        throw new Boom('customProvider(fn) needs a function', { statusCode: 400 });
+    }
+    return async (audio, meta = {}) => {
+        const res = await fn(audio, meta);
+        const text = typeof res === 'string' ? res : res?.text;
+        if (!text || typeof text !== 'string') {
+            throw new Boom('transcription provider returned no text', { statusCode: 502 });
+        }
+        return { text };
+    };
+};
+
+/** OpenAI-compatible `/v1/audio/transcriptions` endpoint (cloud or local clone). */
+export const openAIWhisperProvider = ({ apiKey, model = 'whisper-1', baseUrl = 'https://api.openai.com/v1', language, fileName = 'voice.ogg' } = {}) => {
+    if (!apiKey || typeof apiKey !== 'string') {
+        throw new Boom('openAIWhisperProvider needs { apiKey }', { statusCode: 400 });
+    }
+    return async (audio, { mimetype = 'audio/ogg' } = {}) => {
+        const form = new FormData();
+        form.append('model', model);
+        form.append('file', new Blob([audio], { type: mimetype }), fileName);
+        if (language) {
+            form.append('language', language);
+        }
+        const res = await fetch(`${baseUrl}/audio/transcriptions`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: form
+        });
+        if (!res.ok) {
+            throw new Boom(`transcription failed: HTTP ${res.status}`, { statusCode: 502 });
+        }
+        const { text } = await res.json();
+        if (!text || typeof text !== 'string') {
+            throw new Boom('transcription endpoint returned no text', { statusCode: 502 });
+        }
+        return { text };
+    };
+};
+
+/** Transcribe a raw audio buffer with any provider. */
+export const transcribeAudio = async (audio, { provider, mimetype } = {}) => {
+    if (!Buffer.isBuffer(audio) || !audio.length) {
+        throw new Boom('transcribeAudio(audio) needs a non-empty audio Buffer', { statusCode: 400 });
+    }
+    needProvider(provider);
+    return provider(audio, { mimetype });
+};
+
+/**
+ * Download + transcribe a voice-note/audio WAMessage.
+ * `download` override exists for tests (default hits the WA media CDN).
+ */
+export const transcribeMessage = async (sock, webMessage, { provider, download } = {}) => {
+    const audio = webMessage?.message?.audioMessage;
+    if (!audio?.mediaKey) {
+        throw new Boom('transcribeMessage needs a voice-note/audio WAMessage', { statusCode: 400 });
+    }
+    needProvider(provider);
+    const dl = download || ((keys) => downloadContentFromMessage(keys, 'audio', {}));
+    const stream = await dl({ mediaKey: audio.mediaKey, directPath: audio.directPath, url: audio.url });
+    const buf = await streamToBuffer(stream);
+    const { text } = await provider(buf, { mimetype: audio.mimetype });
+    if (!text || typeof text !== 'string') {
+        throw new Boom('transcription provider returned no text', { statusCode: 502 });
+    }
+    return { text, seconds: audio.seconds ?? null, ptt: audio.ptt ?? false };
+};

package/lib/Utils/use-cache-manager-auth-state.d.ts

@@ -0,0 +1,13 @@
+import type { AuthenticationState } from '../Types/index.js';
+/** Minimal interface compatible with any cache-manager v5 store (Redis, Memcached, keyv, @cacheable/node-cache, etc). */
+export type CacheManagerStore = {
+    set(key: string, value: string, ttl?: number): Promise<void>;
+    get(key: string): Promise<string | undefined | null>;
+    del(key: string): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+};
+export declare const useCacheManagerAuthState: (store: CacheManagerStore, sessionKey: string) => Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+    clearState: () => Promise<void>;
+}>;

package/lib/Utils/use-cache-manager-auth-state.js

@@ -0,0 +1,81 @@
+// JAP@Utils --- cache-manager auth-state backend (any cache-manager store).
+// Adjustments for @japofc/baileys: import paths rewired to this fork's
+// Utils layout (auth-utils.js / generics.js), otherwise logic-for-logic
+// identical to the original — including the 2-year TTL on `creds` and the
+// `sessionKey*` wildcard sweep in `clearState()`.
+//
+// Store interface required (matches any cache-manager v5-compatible store,
+// e.g. Redis/Memcached/keyv, or this fork's own @cacheable/node-cache dep):
+//   store.get(key)              -> string | undefined | null
+//   store.set(key, value, ttl?) -> void
+//   store.del(key)              -> void
+//   store.keys(pattern?)        -> string[]   (used by clearState() for the wildcard sweep)
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+
+export const useCacheManagerAuthState = async (store, sessionKey) => {
+    const defaultKey = (file) => `${sessionKey}:${file}`;
+    const writeData = async (file, data) => {
+        const ttl = file === 'creds' ? 63115200 : undefined; // 2 years for creds
+        await store.set(defaultKey(file), JSON.stringify(data, BufferJSON.replacer), ttl);
+    };
+    const readData = async (file) => {
+        try {
+            const data = await store.get(defaultKey(file));
+            return data !== null && data !== undefined ? JSON.parse(data, BufferJSON.reviver) : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            await store.del(defaultKey(file));
+        }
+        catch {
+            console.error(`[useCacheManagerAuthState] Error removing ${file} from session ${sessionKey}`);
+        }
+    };
+    const clearState = async () => {
+        try {
+            const keys = await store.keys(`${sessionKey}*`);
+            await Promise.all(keys.map((key) => store.del(key)));
+        }
+        catch {
+            // best-effort — not every store backend supports pattern listing
+        }
+    };
+    const creds = (await readData('creds')) || initAuthCreds();
+    return {
+        clearState,
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? writeData(key, value) : removeData(key));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: () => writeData('creds', creds)
+    };
+};

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,10 @@
+export function useMultiFileAuthState(folder: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<any>;
+}>;