@ryuu-reinzz/haruka-lib 3.3.4 → 3.4.0-beta.1

package/main/index.js

@@ -1,6 +1,7 @@
 import addProperty from "./socket.js";
-import useSQLiteAuthState from "./sqliteAuth.js";
+import useSQLiteAuthState from "./sqlite3-auth/auth.js";
 import Sticker from './sticker-engine/index.js';
+import downloader from './downloader.js';
 import {
     stickerVid
 } from './sticker-engine/video-to-webp.js';
@@ -13,7 +14,8 @@ import {
 
 const haruka = {
     addProperty,
-    useSQLiteAuthState
+    useSQLiteAuthState,
+    downloader
 };
 
 export default haruka;

package/main/sqlite3-auth/auth.js

@@ -0,0 +1,342 @@
+/**
+ * @file SQLite-based authentication state management for Baileys
+ * @module auth/sqlite-auth
+ * @description Production-grade authentication state persistence with transaction support,
+ * connection pooling, and robust error handling for WhatsApp Web sessions.
+ * @author RyuuReinzz
+ */
+
+import {
+    AsyncLocalStorage
+} from "async_hooks";
+import {
+    Mutex
+} from "async-mutex";
+import PQueue from "p-queue";
+import getAuthDatabase from "./core.js";
+import {
+    makeKey,
+    validateKey,
+    validateValue
+} from "./config.js";
+
+const DEFAULT_TRANSACTION_OPTIONS = {
+    maxCommitRetries: 5,
+    delayBetweenTriesMs: 200,
+    transactionTimeout: 30000,
+};
+
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function exponentialBackoff(attempt, baseDelay) {
+    const exponentialDelay = baseDelay * Math.pow(2, attempt);
+    const jitter = Math.random() * baseDelay;
+    return Math.min(exponentialDelay + jitter, 10000);
+}
+
+export default function useSQLiteAuthState(_dbPath, options = {}) {
+    const txOptions = {
+        ...DEFAULT_TRANSACTION_OPTIONS,
+        ...options
+    };
+    const {
+        initAuthCreds
+    } = options;
+
+    let creds;
+    const db = getAuthDatabase(_dbPath, options);
+
+    try {
+        const row = db.get("creds");
+        if (row?.value) {
+            creds = row.value;
+            if (!creds || typeof creds !== "object") {
+                creds = initAuthCreds();
+            }
+        } else {
+            creds = initAuthCreds();
+        }
+    } catch {
+        creds = initAuthCreds();
+    }
+
+    const txStorage = new AsyncLocalStorage();
+    const keyQueues = new Map();
+    const txMutexes = new Map();
+
+    function getQueue(key) {
+        if (!keyQueues.has(key)) {
+            keyQueues.set(key, new PQueue({
+                concurrency: 1
+            }));
+        }
+        return keyQueues.get(key);
+    }
+
+    function getTxMutex(key) {
+        if (!txMutexes.has(key)) {
+            txMutexes.set(key, new Mutex());
+        }
+        return txMutexes.get(key);
+    }
+
+    function isInTransaction() {
+        return !!txStorage.getStore();
+    }
+
+    async function commitWithRetry(mutations) {
+        if (Object.keys(mutations).length === 0) {
+            return;
+        }
+
+        for (let attempt = 0; attempt < txOptions.maxCommitRetries; attempt++) {
+            try {
+                for (const type in mutations) {
+                    const bucket = mutations[type];
+                    for (const id in bucket) {
+                        const k = makeKey(type, id);
+                        const v = bucket[id];
+
+                        if (!validateKey(k)) continue;
+
+                        if (v === null || v === undefined) {
+                            db.del(k);
+                        } else {
+                            db.set(k, v);
+                        }
+                    }
+                }
+
+                return;
+            } catch (error) {
+                const retriesLeft = txOptions.maxCommitRetries - attempt - 1;
+
+                if (retriesLeft === 0) {
+                    throw error;
+                }
+
+                await delay(exponentialBackoff(attempt, txOptions.delayBetweenTriesMs));
+            }
+        }
+    }
+
+    async function keysGet(type, ids) {
+        if (!type || !Array.isArray(ids)) {
+            return {};
+        }
+
+        const ctx = txStorage.getStore();
+
+        if (!ctx) {
+            const result = {};
+
+            for (const id of ids) {
+                const k = makeKey(type, id);
+                if (!validateKey(k)) continue;
+
+                try {
+                    const row = db.get(k);
+                    if (row?.value) {
+                        result[id] = row.value;
+                    }
+                } catch {
+                    // Silent fail, continue processing
+                }
+            }
+
+            return result;
+        }
+
+        const cached = ctx.cache[type] || {};
+        const missing = ids.filter((id) => !(id in cached));
+
+        if (missing.length > 0) {
+            ctx.dbQueries++;
+
+            const fetched = await getTxMutex(type).runExclusive(async () => {
+                const result = {};
+
+                for (const id of missing) {
+                    const k = makeKey(type, id);
+                    if (!validateKey(k)) continue;
+
+                    try {
+                        const row = db.get(k);
+                        if (row?.value) {
+                            result[id] = row.value;
+                        }
+                    } catch {
+                        // Silent fail
+                    }
+                }
+
+                return result;
+            });
+
+            ctx.cache[type] = ctx.cache[type] || {};
+            Object.assign(ctx.cache[type], fetched);
+        }
+
+        const result = {};
+        for (const id of ids) {
+            const value = ctx.cache[type]?.[id];
+            if (value !== undefined && value !== null) {
+                result[id] = value;
+            }
+        }
+
+        return result;
+    }
+
+    async function keysSet(data) {
+        if (!data || typeof data !== "object") {
+            return;
+        }
+
+        const ctx = txStorage.getStore();
+
+        if (!ctx) {
+            const types = Object.keys(data);
+
+            await Promise.all(
+                types.map((type) =>
+                    getQueue(type).add(async () => {
+                        const bucket = data[type];
+
+                        for (const id in bucket) {
+                            try {
+                                const k = makeKey(type, id);
+                                const v = bucket[id];
+
+                                if (!validateKey(k)) continue;
+                                if (!validateValue(v)) continue;
+
+                                if (v === null || v === undefined) {
+                                    db.del(k);
+                                } else {
+                                    db.set(k, v);
+                                }
+                            } catch {
+                                // Silent fail
+                            }
+                        }
+                    })
+                )
+            );
+
+            return;
+        }
+
+        for (const type in data) {
+            const bucket = data[type];
+
+            ctx.cache[type] = ctx.cache[type] || {};
+            ctx.mutations[type] = ctx.mutations[type] || {};
+
+            Object.assign(ctx.cache[type], bucket);
+            Object.assign(ctx.mutations[type], bucket);
+        }
+    }
+
+    async function keysClear() {
+        try {
+            db.db.exec("DELETE FROM baileys_state WHERE key LIKE '%-%'");
+            db.db.exec("PRAGMA wal_checkpoint(PASSIVE)");
+            db.cache.clear();
+        } catch {
+            // Silent fail
+        }
+    }
+
+    async function transaction(work, key = "default") {
+        if (typeof work !== "function") {
+            return null;
+        }
+
+        const existing = txStorage.getStore();
+
+        if (existing) {
+            return work();
+        }
+
+        const timeoutPromise = new Promise((_, reject) =>
+            setTimeout(() => reject(new Error("Transaction timeout")), txOptions.transactionTimeout)
+        );
+
+        const txPromise = getTxMutex(key).runExclusive(async () => {
+            const ctx = {
+                cache: {},
+                mutations: {},
+                dbQueries: 0,
+            };
+
+            const result = await txStorage.run(ctx, work);
+            await commitWithRetry(ctx.mutations);
+            return result;
+        });
+
+        try {
+            return await Promise.race([txPromise, timeoutPromise]);
+        } catch {
+            return null;
+        }
+    }
+
+    function saveCreds() {
+        try {
+            if (!creds || typeof creds !== "object") {
+                return false;
+            }
+
+            db.set("creds", creds);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    const keys = {
+        get: keysGet,
+        set: keysSet,
+        clear: keysClear,
+    };
+
+    return {
+        state: {
+            creds,
+            keys
+        },
+        saveCreds,
+        transaction,
+        isInTransaction,
+        _flushNow: async () => {
+            try {
+                await db.flush();
+            } catch {
+                // Silent fail
+            }
+        },
+        _forceVacuum: async () => {
+            try {
+                await db.forceVacuum();
+            } catch {
+                // Silent fail
+            }
+        },
+        _dispose: async () => {
+            try {
+                await db.flush();
+                keyQueues.clear();
+                txMutexes.clear();
+            } catch {
+                // Silent fail
+            }
+        },
+        db: db.db,
+        get closed() {
+            return db.disposed;
+        },
+    };
+}

package/main/sqlite3-auth/config.js

@@ -0,0 +1,83 @@
+/**
+ * @file Signal handler and database utilities for Liora bot
+ * @module core/utils
+ * @description Provides signal/process management, database configuration,
+ * and validation utilities for graceful shutdown and resource management.
+ * @author RyuuReinzz
+ */
+
+import path from "path";
+
+export const DEFAULT_DB = path.join(process.cwd(), "session", "auth.db");
+
+export const makeKey = (type, id) => `${type}-${id}`;
+
+export function validateKey(key) {
+    return typeof key === "string" && key.length > 0 && key.length < 512;
+}
+
+export function validateValue(value) {
+    return value !== undefined;
+}
+
+const signalHandlers = new Map();
+let signalHandlersInitialized = false;
+let isExiting = false;
+let exitTimeout = null;
+
+function exitHandler() {
+    if (isExiting) return;
+    isExiting = true;
+
+    for (const [, handler] of signalHandlers) {
+        try {
+            handler();
+        } catch {
+            // Silent fail
+        }
+    }
+}
+
+function fullExitHandler(signal) {
+    exitHandler();
+    const code = signal === "SIGINT" ? 130 : 143;
+    
+    if (exitTimeout) {
+        clearTimeout(exitTimeout);
+    }
+    
+    exitTimeout = setTimeout(() => process.exit(code), 500);
+    exitTimeout.unref?.();
+}
+
+export function initializeSignalHandlers() {
+    if (signalHandlersInitialized) return;
+    signalHandlersInitialized = true;
+
+    try {
+        process.once("exit", () => exitHandler());
+        process.once("SIGINT", () => fullExitHandler("SIGINT"));
+        process.once("SIGTERM", () => fullExitHandler("SIGTERM"));
+        process.on("uncaughtException", () => {
+            // Silent fail in production
+        });
+
+        process.on("unhandledRejection", () => {
+            // Silent fail in production
+        });
+    } catch {
+        // Silent fail
+    }
+}
+
+export function registerSignalHandler(id, handler) {
+    if (typeof handler !== "function" || !id) {
+        return false;
+    }
+    signalHandlers.set(id, handler);
+    return true;
+}
+
+export function unregisterSignalHandler(id) {
+    return signalHandlers.delete(id);
+}

package/main/sqlite3-auth/core.js

@@ -0,0 +1,393 @@
+/**
+ * @file Baileys authentication database with caching and write buffering
+ * @module database/auth
+ * @description SQLite-based storage system for Baileys session management
+ * with memory caching, write buffering, and automatic vacuuming.
+ * @author RyuuReinzz
+ */
+
+import {
+    Database
+} from "better-sqlite3";
+import {
+    Mutex
+} from "async-mutex";
+import {
+    randomUUID
+} from "node:crypto";
+import {
+    DEFAULT_DB,
+    validateKey,
+    validateValue,
+    initializeSignalHandlers,
+    registerSignalHandler,
+} from "./config.js";
+
+class LRUCache {
+    constructor(maxSize = 10000, BufferJSON) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+        this.BufferJSON = BufferJSON;
+    }
+
+    get(key) {
+        if (!this.cache.has(key)) return undefined;
+        const value = this.cache.get(key);
+        this.cache.delete(key);
+        this.cache.set(key, value);
+        return value;
+    }
+
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        } else if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            this.cache.delete(firstKey);
+        }
+        this.cache.set(key, value);
+    }
+
+    delete(key) {
+        return this.cache.delete(key);
+    }
+
+    has(key) {
+        return this.cache.has(key);
+    }
+
+    clear() {
+        this.cache.clear();
+    }
+
+    get size() {
+        return this.cache.size;
+    }
+}
+
+class WriteBuffer {
+    constructor() {
+        this.upserts = new Map();
+        this.deletes = new Set();
+    }
+
+    addUpsert(k, v) {
+        if (!validateKey(k)) return false;
+        this.upserts.set(k, v);
+        this.deletes.delete(k);
+        return true;
+    }
+
+    addDelete(k) {
+        if (!validateKey(k)) return false;
+        this.deletes.add(k);
+        this.upserts.delete(k);
+        return true;
+    }
+
+    clear() {
+        this.upserts.clear();
+        this.deletes.clear();
+    }
+
+    hasChanges() {
+        return this.upserts.size > 0 || this.deletes.size > 0;
+    }
+
+    toArrays() {
+        return {
+            upserts: Array.from(this.upserts.entries()),
+            deletes: Array.from(this.deletes.values()),
+        };
+    }
+}
+
+class AuthDatabase {
+    constructor(dbPath = DEFAULT_DB, options = {}, BufferJSON) {
+        this.dbPath = dbPath;
+        this.instanceId = `auth-${Date.now()}-${randomUUID()}`;
+        this.disposed = false;
+        this.isInitialized = false;
+        this.BufferJSON = BufferJSON;
+        this.cache = new LRUCache(options.cacheSize || 10000, BufferJSON);
+
+        this.db = this._initDatabase();
+        this._prepareStatements();
+        this._initWriteBuffer(options);
+        this._initVacuum(options);
+        this._registerCleanup();
+        this.isInitialized = true;
+    }
+
+    _initDatabase() {
+        const db = new Database(this.dbPath);
+
+        db.pragma("journal_mode = WAL");
+        db.pragma("synchronous = NORMAL");
+        db.pragma("temp_store = MEMORY");
+        db.pragma("cache_size = -131072");
+        db.pragma("mmap_size = 134217728");
+        db.pragma("page_size = 8192");
+        db.pragma("auto_vacuum = INCREMENTAL");
+        db.pragma("busy_timeout = 5000");
+
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS baileys_state (
+                key   TEXT PRIMARY KEY NOT NULL CHECK(length(key) > 0 AND length(key) < 512),
+                value TEXT NOT NULL,
+                last_access INTEGER DEFAULT (unixepoch())
+            ) WITHOUT ROWID;
+        `);
+
+        db.exec(`
+            CREATE INDEX IF NOT EXISTS idx_key_prefix ON baileys_state(key) 
+            WHERE key LIKE '%-%';
+        `);
+
+        db.exec(`
+            CREATE INDEX IF NOT EXISTS idx_last_access ON baileys_state(last_access);
+        `);
+
+        return db;
+    }
+
+    _prepareStatements() {
+        this.stmtGet = this.db.prepare("SELECT value FROM baileys_state WHERE key = ?");
+        this.stmtSet = this.db.prepare(
+            "INSERT OR REPLACE INTO baileys_state (key, value, last_access) VALUES (?, ?, unixepoch())"
+        );
+        this.stmtDel = this.db.prepare("DELETE FROM baileys_state WHERE key = ?");
+        this.stmtUpdateAccess = this.db.prepare(
+            "UPDATE baileys_state SET last_access = unixepoch() WHERE key = ?"
+        );
+        this.stmtGetOldKeys = this.db.prepare(
+            "SELECT key FROM baileys_state WHERE last_access < ? AND key LIKE '%-%' LIMIT ?"
+        );
+        this.stmtCountKeys = this.db.prepare(
+            "SELECT COUNT(*) as count FROM baileys_state WHERE key LIKE '%-%'"
+        );
+
+        this.txCommit = this.db.transaction((upsertsArr, deletesArr) => {
+            for (const [k, v] of upsertsArr) {
+                try {
+                    const jsonString = JSON.stringify(v, this.BufferJSON.replacer);
+                    this.stmtSet.run(k, jsonString);
+                } catch {}
+            }
+            for (const k of deletesArr) {
+                try {
+                    this.stmtDel.run(k);
+                } catch {}
+            }
+        });
+    }
+
+    _initWriteBuffer(options) {
+        this.writeBuffer = new WriteBuffer();
+        this.writeMutex = new Mutex();
+        this.flushIntervalMs = Number(options.flushIntervalMs ?? 200);
+        this.maxBatch = Number(options.maxBatch ?? 1000);
+        this.flushTimer = null;
+    }
+
+    _initVacuum(options) {
+        this.vacuumEnabled = options.vacuumEnabled !== false;
+        this.vacuumIntervalMs = Number(options.vacuumIntervalMs ?? 3600000);
+        this.vacuumMaxAge = Number(options.vacuumMaxAge ?? 604800);
+        this.vacuumBatchSize = Number(options.vacuumBatchSize ?? 500);
+        this.vacuumTimer = null;
+        this.lastVacuumTime = 0;
+
+        if (this.vacuumEnabled) {
+            this._scheduleVacuum();
+        }
+    }
+
+    _scheduleVacuum() {
+        if (!this.vacuumEnabled || this.disposed || !this.isInitialized) return;
+
+        if (this.vacuumTimer) clearTimeout(this.vacuumTimer);
+
+        this.vacuumTimer = setTimeout(() => {
+            this.vacuumTimer = null;
+            this._performVacuum().catch(() => this._scheduleVacuum());
+        }, this.vacuumIntervalMs);
+
+        this.vacuumTimer.unref?.();
+    }
+
+    async _performVacuum() {
+        if (this.disposed || !this.isInitialized) return;
+
+        const now = Date.now();
+        if (now - this.lastVacuumTime < this.vacuumIntervalMs) {
+            this._scheduleVacuum();
+            return;
+        }
+
+        await this.writeMutex.runExclusive(async () => {
+            try {
+                const cutoffTime = Math.floor(Date.now() / 1000) - this.vacuumMaxAge;
+                let totalDeleted = 0;
+
+                while (true) {
+                    const oldKeys = this.stmtGetOldKeys.all(cutoffTime, this.vacuumBatchSize);
+                    if (oldKeys.length === 0) break;
+
+                    const deleted = this.db.transaction(() => {
+                        let count = 0;
+                        for (const row of oldKeys) {
+                            this.stmtDel.run(row.key);
+                            this.cache.delete(row.key);
+                            count++;
+                        }
+                        return count;
+                    })();
+
+                    totalDeleted += deleted;
+                    await new Promise((resolve) => setImmediate(resolve));
+                }
+
+                if (totalDeleted > 0) {
+                    this.db.pragma("incremental_vacuum");
+                    this.db.pragma("wal_checkpoint(PASSIVE)");
+                }
+
+                this.lastVacuumTime = now;
+                this._scheduleVacuum();
+            } catch {
+                this._scheduleVacuum();
+            }
+        });
+    }
+
+    _registerCleanup() {
+        initializeSignalHandlers();
+        registerSignalHandler(this.instanceId, () => this._cleanup());
+    }
+
+    get(key) {
+        if (!validateKey(key)) return undefined;
+
+        if (this.cache.has(key)) {
+            return {
+                value: this.cache.get(key)
+            };
+        }
+
+        try {
+            const row = this.stmtGet.get(key);
+            if (!row || !row.value) return undefined;
+
+            const value = JSON.parse(row.value, this.BufferJSON.reviver);
+            this.cache.set(key, value);
+
+            setImmediate(() => {
+                try {
+                    this.stmtUpdateAccess.run(key);
+                } catch {}
+            });
+
+            return {
+                value
+            };
+        } catch {
+            return undefined;
+        }
+    }
+
+    set(key, value) {
+        if (!validateKey(key) || !validateValue(value)) return false;
+
+        this.cache.set(key, value);
+        this.writeBuffer.addUpsert(key, value);
+        this._scheduleFlush();
+        return true;
+    }
+
+    del(key) {
+        if (!validateKey(key)) return false;
+
+        this.cache.delete(key);
+        this.writeBuffer.addDelete(key);
+        this._scheduleFlush();
+        return true;
+    }
+
+    _scheduleFlush() {
+        if (!this.flushTimer && !this.disposed && this.isInitialized) {
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.flush().catch(() => {});
+            }, this.flushIntervalMs);
+
+            this.flushTimer.unref?.();
+        }
+    }
+
+    async flush() {
+        if (this.disposed || !this.isInitialized) return;
+
+        await this.writeMutex.runExclusive(async () => {
+            if (!this.writeBuffer.hasChanges()) return;
+
+            const {
+                upserts,
+                deletes
+            } = this.writeBuffer.toArrays();
+            this.writeBuffer.clear();
+
+            try {
+                this.txCommit(upserts, deletes);
+                this.db.pragma("wal_checkpoint(PASSIVE)");
+            } catch (e) {
+                for (const [k, v] of upserts) this.writeBuffer.addUpsert(k, v);
+                for (const k of deletes) this.writeBuffer.addDelete(k);
+                throw e;
+            }
+        });
+    }
+
+    async forceVacuum() {
+        if (!this.vacuumEnabled) return;
+        this.lastVacuumTime = 0;
+        await this._performVacuum();
+    }
+
+    _cleanup() {
+        if (this.disposed) return;
+        this.disposed = true;
+
+        try {
+            if (this.flushTimer) clearTimeout(this.flushTimer);
+            if (this.vacuumTimer) clearTimeout(this.vacuumTimer);
+
+            const {
+                upserts,
+                deletes
+            } = this.writeBuffer.toArrays();
+            if (upserts.length || deletes.length) {
+                this.txCommit(upserts, deletes);
+            }
+
+            this.db.pragma("wal_checkpoint(TRUNCATE)");
+            this.db.pragma("incremental_vacuum");
+            this.db.pragma("optimize");
+
+            this.db.close();
+            this.cache.clear();
+        } catch {}
+    }
+}
+
+let dbInstance = null;
+
+export default function getAuthDatabase(dbPath = DEFAULT_DB, options = {}) {
+    if (!dbInstance || dbInstance.disposed) {
+        const {
+            BufferJSON
+        } = options;
+        dbInstance = new AuthDatabase(dbPath, options, BufferJSON);
+    }
+    return dbInstance;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ryuu-reinzz/haruka-lib",
-    "version": "3.3.4",
+    "version": "3.4.0-beta.1",
     "description": "Library extra for bot WhatsApp",
     "main": "main/index.js",
     "type": "module",
@@ -16,6 +16,8 @@
     ],
     "dependencies": {
         "axios": "^1.12.1",
+        "async_hooks": "^1.0.0",
+        "async-mutex": "^0.5.0",
         "audio-decode": "2.2.3",
         "better-sqlite3": "^12.5.0",
         "file-type": "^16.5.3",
@@ -23,6 +25,7 @@
         "ffmpeg-static": "^5.3.0",
         "ffprobe-static": "^3.1.0",
         "fs-extra": "^11.2.0",
+        "p-queue": "^9.2.0",
         "path": "^0.12.7",
         "node-fetch": "^2.6.1",
         "node-webpmux": "^3.2.1",

package/main/sqliteAuth.js

@@ -1,114 +0,0 @@
-/**
- * Custom SQLite Auth Store untuk Baileys
- * by Ryuu
- */
-
-//import Database from "bun:sqlite"; 
-//jika menggunakan bun runtime
-import Database from "better-sqlite3";
-/**
- * Membuat atau mengambil auth state dari SQLite
- * @param {string} dbPath - Lokasi file SQLite (contoh: "./auth.db")
- */
-export default async function useSQLiteAuthState(dbPath = "./auth.db", baileys) {
-    const {
-        proto,
-        BufferJSON,
-        initAuthCreds
-    } = baileys;
-    const db = new Database(dbPath);
-    db.pragma("journal_mode = WAL");
-
-    db.prepare(`
-    CREATE TABLE IF NOT EXISTS baileys_state (
-      key TEXT PRIMARY KEY,
-      value BLOB
-    )
-  `).run();
-
-    const load = (key) => {
-        const row = db.prepare("SELECT value FROM baileys_state WHERE key = ?").get(key);
-        if (!row) return null;
-        try {
-            return JSON.parse(row.value.toString(), BufferJSON.reviver);
-        } catch {
-            return null;
-        }
-    };
-
-    const save = (key, data) => {
-        const json = JSON.stringify(data, BufferJSON.replacer);
-        const buf = Buffer.from(json, "utf8");
-        db.prepare("REPLACE INTO baileys_state (key, value) VALUES (?, ?)").run(key, buf);
-    };
-
-    const creds = load("creds") || initAuthCreds();
-
-    const keys = {};
-    const categories = [
-        "pre-key",
-        "session",
-        "sender-key",
-        "app-state-sync-key",
-        "app-state-sync-version"
-    ];
-
-    for (const category of categories) {
-        keys[category] = {};
-        const rows = db
-            .prepare("SELECT key, value FROM baileys_state WHERE key LIKE ?")
-            .all(`${category}:%`);
-        for (const row of rows) {
-            try {
-                keys[category][row.key.slice(category.length + 1)] = JSON.parse(row.value.toString());
-            } catch {}
-        }
-    }
-
-    async function saveCreds() {
-        save("creds", creds);
-    }
-
-    const set = (category, id, value) => {
-        const key = `${category}:${id}`;
-        save(key, value);
-    };
-
-    const get = (category, id) => {
-        const key = `${category}:${id}`;
-        return load(key);
-    };
-
-    const del = (category, id) => {
-        const key = `${category}:${id}`;
-        db.prepare("DELETE FROM baileys_state WHERE key = ?").run(key);
-    };
-
-    return {
-        state: {
-            creds,
-            keys: {
-                get: async (type, ids) => {
-                    const data = {};
-                    for (const id of ids) {
-                        const value = load(`${type}:${id}`);
-                        if (value) data[id] = value;
-                    }
-                    return data;
-                },
-                set: async (data) => {
-                    for (const category in data) {
-                        for (const id in data[category]) {
-                            const value = data[category][id];
-                            save(`${category}:${id}`, value);
-                        }
-                    }
-                }
-            }
-        },
-        saveCreds: async () => save("creds", creds)
-    };
-    setInterval(async () => {
-        await save("creds", creds);
-    }, 30_000);
-}