lordceaser-baileys 2.0.0 → 2.0.2

package/lib/Utils/signal.d.ts

@@ -1,7 +1,7 @@
-import type { SignalRepositoryWithLIDStore } from '../Types/index.js';
-import type { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth.js';
-import { type BinaryNode, type FullJid } from '../WABinary/index.js';
-import type { USyncQueryResultList } from '../WAUSync/index.js';
+import { SignalRepository } from '../Types';
+import { AuthenticationCreds, AuthenticationState, KeyPair, SignalIdentity, SignalKeyStore, SignedKeyPair } from '../Types/Auth';
+import { BinaryNode, JidWithDevice } from '../WABinary';
+import { USyncQueryResultList } from '../WAUSync';
 export declare const createSignalIdentity: (wid: string, accountSignatureKey: Uint8Array) => SignalIdentity;
 export declare const getPreKeys: ({ get }: SignalKeyStore, min: number, limit: number) => Promise<{
     [id: string]: KeyPair;
@@ -15,21 +15,8 @@ export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: n
 };
 export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode;
 export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode;
-export declare const extractE2ESessionFromRetryReceipt: (receipt: BinaryNode) => {
-    registrationId: number;
-    identityKey: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
-    signedPreKey: {
-        keyId: number;
-        publicKey: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
-        signature: Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
-    };
-    preKey: {
-        keyId: number;
-        publicKey: Uint8Array;
-    } | undefined;
-} | null;
-export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepositoryWithLIDStore) => Promise<void>;
-export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, myLid: string, excludeZeroDevices: boolean) => FullJid[];
+export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepository) => Promise<void>;
+export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, excludeZeroDevices: boolean) => JidWithDevice[];
 /**
  * get the next N keys for upload or processing
  * @param count number of pre-keys to get or generate
@@ -44,4 +31,3 @@ export declare const getNextPreKeysNode: (state: AuthenticationState, count: num
     update: Partial<AuthenticationCreds>;
     node: BinaryNode;
 }>;
-//# sourceMappingURL=signal.d.ts.map

package/lib/Utils/signal.js

@@ -1,113 +1,77 @@
-import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
-import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, getServerFromDomainType, jidDecode, S_WHATSAPP_NET, WAJIDDomains } from '../WABinary/index.js';
-import { Curve, generateSignalPubKey } from './crypto.js';
-import { encodeBigEndian } from './generics.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids = exports.parseAndInjectE2ESessions = exports.xmppPreKey = exports.xmppSignedPreKey = exports.generateOrGetPreKeys = exports.getPreKeys = exports.createSignalIdentity = void 0;
+const Defaults_1 = require("../Defaults");
+const WABinary_1 = require("../WABinary");
+const crypto_1 = require("./crypto");
+const generics_1 = require("./generics");
 function chunk(array, size) {
-    const chunks = [];
+    const result = [];
     for (let i = 0; i < array.length; i += size) {
-        chunks.push(array.slice(i, i + size));
+        result.push(array.slice(i, i + size));
     }
-    return chunks;
+    return result;
 }
-export const createSignalIdentity = (wid, accountSignatureKey) => {
+const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
         identifier: { name: wid, deviceId: 0 },
-        identifierKey: generateSignalPubKey(accountSignatureKey)
+        identifierKey: (0, crypto_1.generateSignalPubKey)(accountSignatureKey)
     };
 };
-export const getPreKeys = async ({ get }, min, limit) => {
+exports.createSignalIdentity = createSignalIdentity;
+const getPreKeys = async ({ get }, min, limit) => {
     const idList = [];
     for (let id = min; id < limit; id++) {
         idList.push(id.toString());
     }
     return get('pre-key', idList);
 };
-export const generateOrGetPreKeys = (creds, range) => {
+exports.getPreKeys = getPreKeys;
+const generateOrGetPreKeys = (creds, range) => {
     const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
     const remaining = range - avaliable;
     const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
     const newPreKeys = {};
     if (remaining > 0) {
         for (let i = creds.nextPreKeyId; i <= lastPreKeyId; i++) {
-            newPreKeys[i] = Curve.generateKeyPair();
+            newPreKeys[i] = crypto_1.Curve.generateKeyPair();
         }
     }
     return {
         newPreKeys,
         lastPreKeyId,
-        preKeysRange: [creds.firstUnuploadedPreKeyId, range]
+        preKeysRange: [creds.firstUnuploadedPreKeyId, range],
     };
 };
-export const xmppSignedPreKey = (key) => ({
+exports.generateOrGetPreKeys = generateOrGetPreKeys;
+const xmppSignedPreKey = (key) => ({
     tag: 'skey',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(key.keyId, 3) },
         { tag: 'value', attrs: {}, content: key.keyPair.public },
         { tag: 'signature', attrs: {}, content: key.signature }
     ]
 });
-export const xmppPreKey = (pair, id) => ({
+exports.xmppSignedPreKey = xmppSignedPreKey;
+const xmppPreKey = (pair, id) => ({
     tag: 'key',
     attrs: {},
     content: [
-        { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
+        { tag: 'id', attrs: {}, content: (0, generics_1.encodeBigEndian)(id, 3) },
         { tag: 'value', attrs: {}, content: pair.public }
     ]
 });
-const isValidUInt = (n) => typeof n === 'number' && Number.isInteger(n);
-export const extractE2ESessionFromRetryReceipt = (receipt) => {
-    const keysNode = getBinaryNodeChild(receipt, 'keys');
-    if (!keysNode)
-        return null;
-    const typeBuf = getBinaryNodeChildBuffer(keysNode, 'type');
-    if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== KEY_BUNDLE_TYPE[0])
-        return null;
-    const identity = getBinaryNodeChildBuffer(keysNode, 'identity');
-    const skey = getBinaryNodeChild(keysNode, 'skey');
-    if (!identity || identity.length !== 32 || !skey)
-        return null;
-    const registrationId = getBinaryNodeChildUInt(receipt, 'registration', 4);
-    if (!isValidUInt(registrationId))
-        return null;
-    const signedPubKey = getBinaryNodeChildBuffer(skey, 'value');
-    const signedSig = getBinaryNodeChildBuffer(skey, 'signature');
-    const signedKeyId = getBinaryNodeChildUInt(skey, 'id', 3);
-    if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !isValidUInt(signedKeyId)) {
-        return null;
-    }
-    const preKeyNode = getBinaryNodeChild(keysNode, 'key');
-    let preKey;
-    if (preKeyNode) {
-        const preKeyPub = getBinaryNodeChildBuffer(preKeyNode, 'value');
-        const preKeyId = getBinaryNodeChildUInt(preKeyNode, 'id', 3);
-        if (!preKeyPub || preKeyPub.length !== 32 || !isValidUInt(preKeyId)) {
-            return null;
-        }
-        preKey = { keyId: preKeyId, publicKey: generateSignalPubKey(preKeyPub) };
-    }
-    return {
-        registrationId,
-        identityKey: generateSignalPubKey(identity),
-        signedPreKey: {
-            keyId: signedKeyId,
-            publicKey: generateSignalPubKey(signedPubKey),
-            signature: signedSig
-        },
-        preKey
-    };
-};
-export const parseAndInjectE2ESessions = async (node, repository) => {
-    const extractKey = (key) => key
-        ? {
-            keyId: getBinaryNodeChildUInt(key, 'id', 3),
-            publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
-            signature: getBinaryNodeChildBuffer(key, 'signature')
-        }
-        : undefined;
-    const nodes = getBinaryNodeChildren(getBinaryNodeChild(node, 'list'), 'user');
+exports.xmppPreKey = xmppPreKey;
+const parseAndInjectE2ESessions = async (node, repository) => {
+    const extractKey = (key) => (key ? ({
+        keyId: (0, WABinary_1.getBinaryNodeChildUInt)(key, 'id', 3),
+        publicKey: (0, crypto_1.generateSignalPubKey)((0, WABinary_1.getBinaryNodeChildBuffer)(key, 'value')),
+        signature: (0, WABinary_1.getBinaryNodeChildBuffer)(key, 'signature'),
+    }) : undefined);
+    const nodes = (0, WABinary_1.getBinaryNodeChildren)((0, WABinary_1.getBinaryNodeChild)(node, 'list'), 'user');
     for (const node of nodes) {
-        assertNodeErrorFree(node);
+        (0, WABinary_1.assertNodeErrorFree)(node);
     }
     // Most of the work in repository.injectE2ESession is CPU intensive, not IO
     // So Promise.all doesn't really help here,
@@ -117,85 +81,79 @@ export const parseAndInjectE2ESessions = async (node, repository) => {
     const chunkSize = 100;
     const chunks = chunk(nodes, chunkSize);
     for (const nodesChunk of chunks) {
-        for (const node of nodesChunk) {
-            const signedKey = getBinaryNodeChild(node, 'skey');
-            const key = getBinaryNodeChild(node, 'key');
-            const identity = getBinaryNodeChildBuffer(node, 'identity');
+        await Promise.all(nodesChunk.map(async (node) => {
+            const signedKey = (0, WABinary_1.getBinaryNodeChild)(node, 'skey');
+            const key = (0, WABinary_1.getBinaryNodeChild)(node, 'key');
+            const identity = (0, WABinary_1.getBinaryNodeChildBuffer)(node, 'identity');
             const jid = node.attrs.jid;
-            const registrationId = getBinaryNodeChildUInt(node, 'registration', 4);
+            const registrationId = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
             await repository.injectE2ESession({
                 jid,
                 session: {
                     registrationId: registrationId,
-                    identityKey: generateSignalPubKey(identity),
+                    identityKey: (0, crypto_1.generateSignalPubKey)(identity),
                     signedPreKey: extractKey(signedKey),
                     preKey: extractKey(key)
                 }
             });
-        }
+        }));
     }
 };
-export const extractDeviceJids = (result, myJid, myLid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = jidDecode(myJid);
+exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
+const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
+    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
     const extracted = [];
     for (const userResult of result) {
         const { devices, id } = userResult;
-        const decoded = jidDecode(id), { user, server } = decoded;
-        let { domainType } = decoded;
-        const deviceList = devices?.deviceList;
-        if (!Array.isArray(deviceList))
-            continue;
-        for (const { id: device, keyIndex, isHosted } of deviceList) {
-            if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
-                ((myUser !== user && myLid !== user) || myDevice !== device) && // either different user or if me user, not this device
-                (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-            ) {
-                if (isHosted) {
-                    domainType = domainType === WAJIDDomains.LID ? WAJIDDomains.HOSTED_LID : WAJIDDomains.HOSTED;
+        const { user } = (0, WABinary_1.jidDecode)(id);
+        const deviceList = devices === null || devices === void 0 ? void 0 : devices.deviceList;
+        if (Array.isArray(deviceList)) {
+            for (const { id: device, keyIndex } of deviceList) {
+                if ((!excludeZeroDevices || device !== 0) && // if zero devices are not-excluded, or device is non zero
+                    (myUser !== user || myDevice !== device) && // either different user or if me user, not this device
+                    (device === 0 || !!keyIndex) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
+                ) {
+                    extracted.push({ user, device });
                 }
-                extracted.push({
-                    user,
-                    device,
-                    domainType,
-                    server: getServerFromDomainType(server, domainType)
-                });
             }
         }
     }
     return extracted;
 };
+exports.extractDeviceJids = extractDeviceJids;
 /**
  * get the next N keys for upload or processing
  * @param count number of pre-keys to get or generate
  */
-export const getNextPreKeys = async ({ creds, keys }, count) => {
-    const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count);
+const getNextPreKeys = async ({ creds, keys }, count) => {
+    const { newPreKeys, lastPreKeyId, preKeysRange } = (0, exports.generateOrGetPreKeys)(creds, count);
     const update = {
         nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
         firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
     };
     await keys.set({ 'pre-key': newPreKeys });
-    const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    const preKeys = await (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
     return { update, preKeys };
 };
-export const getNextPreKeysNode = async (state, count) => {
+exports.getNextPreKeys = getNextPreKeys;
+const getNextPreKeysNode = async (state, count) => {
     const { creds } = state;
-    const { update, preKeys } = await getNextPreKeys(state, count);
+    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
     const node = {
         tag: 'iq',
         attrs: {
             xmlns: 'encrypt',
             type: 'set',
-            to: S_WHATSAPP_NET
+            to: WABinary_1.S_WHATSAPP_NET,
         },
         content: [
-            { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
-            { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
+            { tag: 'registration', attrs: {}, content: (0, generics_1.encodeBigEndian)(creds.registrationId) },
+            { tag: 'type', attrs: {}, content: Defaults_1.KEY_BUNDLE_TYPE },
             { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
-            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
-            xmppSignedPreKey(creds.signedPreKey)
+            { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => (0, exports.xmppPreKey)(preKeys[+k], +k)) },
+            (0, exports.xmppSignedPreKey)(creds.signedPreKey)
         ]
     };
     return { update, node };
 };
-//# sourceMappingURL=signal.js.map
+exports.getNextPreKeysNode = getNextPreKeysNode;

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

@@ -1,4 +1,4 @@
-import type { AuthenticationState } from '../Types/index.js';
+import { AuthenticationState } from '../Types';
 /**
  * stores the full authentication state in a single folder.
  * Far more efficient than singlefileauthstate
@@ -10,4 +10,3 @@ export declare const useMultiFileAuthState: (folder: string) => Promise<{
     state: AuthenticationState;
     saveCreds: () => Promise<void>;
 }>;
-//# sourceMappingURL=use-multi-file-auth-state.d.ts.map

package/lib/Utils/use-multi-file-auth-state.js

@@ -1,23 +1,29 @@
-import { Mutex } from 'async-mutex';
-import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { proto } from '../../WAProto/index.js';
-import { initAuthCreds } from './auth-utils.js';
-import { BufferJSON } from './generics.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMultiFileAuthState = void 0;
+const async_lock_1 = __importDefault(require("async-lock"));
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const WAProto_1 = require("../../WAProto");
+const auth_utils_1 = require("./auth-utils");
+const generics_1 = require("./generics");
 // We need to lock files due to the fact that we are using async functions to read and write files
 // https://github.com/WhiskeySockets/Baileys/issues/794
 // https://github.com/nodejs/node/issues/26338
-// Use a Map to store mutexes for each file path
-const fileLocks = new Map();
-// Get or create a mutex for a specific file path
-const getFileLock = (path) => {
-    let mutex = fileLocks.get(path);
-    if (!mutex) {
-        mutex = new Mutex();
-        fileLocks.set(path, mutex);
+// Default pending is 1000, set it to infinity
+// https://github.com/rogierschouten/async-lock/issues/63
+const fileLock = new async_lock_1.default({ maxPending: Infinity });
+
+// Helper function to log debug information if authDebug is enabled
+const logDebug = (message, options) => {
+    if (options && typeof options === 'object' && options.authDebug === true) {
+        console.log(`[AUTH_DEBUG] ${message}`);
     }
-    return mutex;
 };
+
 /**
  * stores the full authentication state in a single folder.
  * Far more efficient than singlefileauthstate
@@ -25,97 +31,137 @@ const getFileLock = (path) => {
  * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
  * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
  * */
-export const useMultiFileAuthState = async (folder) => {
+const useMultiFileAuthState = async (folder, options) => {
+    logDebug(`Initializing auth state in folder: ${folder}`, options);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const writeData = async (data, file) => {
-        const filePath = join(folder, fixFileName(file));
-        const mutex = getFileLock(filePath);
-        return mutex.acquire().then(async (release) => {
-            try {
-                await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
-            }
-            finally {
-                release();
-            }
+    const writeData = (data, file) => {
+        const filePath = (0, path_1.join)(folder, fixFileName(file));
+        logDebug(`Writing data to file: ${filePath}`, options);
+        return fileLock.acquire(filePath, () => {
+            logDebug(`Lock acquired for writing: ${filePath}`, options);
+            return (0, promises_1.writeFile)((0, path_1.join)(filePath), JSON.stringify(data, generics_1.BufferJSON.replacer))
+                .then(() => {
+                    logDebug(`Successfully wrote data to: ${filePath}`, options);
+                })
+                .catch((error) => {
+                    logDebug(`Error writing to file ${filePath}: ${error.message}`, options);
+                    throw error;
+                });
         });
     };
+
     const readData = async (file) => {
         try {
-            const filePath = join(folder, fixFileName(file));
-            const mutex = getFileLock(filePath);
-            return await mutex.acquire().then(async (release) => {
-                try {
-                    const data = await readFile(filePath, { encoding: 'utf-8' });
-                    return JSON.parse(data, BufferJSON.reviver);
-                }
-                finally {
-                    release();
-                }
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            logDebug(`Attempting to read data from: ${filePath}`, options);
+            const data = await fileLock.acquire(filePath, () => {
+                logDebug(`Lock acquired for reading: ${filePath}`, options);
+                return (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
             });
+            logDebug(`Successfully read data from: ${filePath}`, options);
+            return JSON.parse(data, generics_1.BufferJSON.reviver);
         }
         catch (error) {
+            logDebug(`Could not read file ${file}: ${error.message}`, options);
             return null;
         }
     };
+
     const removeData = async (file) => {
         try {
-            const filePath = join(folder, fixFileName(file));
-            const mutex = getFileLock(filePath);
-            return mutex.acquire().then(async (release) => {
-                try {
-                    await unlink(filePath);
-                }
-                catch {
-                }
-                finally {
-                    release();
-                }
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            logDebug(`Attempting to remove file: ${filePath}`, options);
+            await fileLock.acquire(filePath, () => {
+                logDebug(`Lock acquired for removal: ${filePath}`, options);
+                return (0, promises_1.unlink)(filePath);
             });
+            logDebug(`Successfully removed file: ${filePath}`, options);
+        }
+        catch (error) {
+            logDebug(`Error removing file ${file}: ${error.message}`, options);
         }
-        catch { }
     };
-    const folderInfo = await stat(folder).catch(() => { });
+
+    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { 
+        logDebug(`Folder ${folder} does not exist yet`, options);
+    });
+    
     if (folderInfo) {
         if (!folderInfo.isDirectory()) {
+            logDebug(`Error: ${folder} is not a directory`, options);
             throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
         }
+        logDebug(`Using existing folder: ${folder}`, options);
     }
     else {
-        await mkdir(folder, { recursive: true });
+        logDebug(`Creating folder: ${folder}`, options);
+        await (0, promises_1.mkdir)(folder, { recursive: true });
+        logDebug(`Successfully created folder: ${folder}`, options);
     }
-    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
-    const creds = (await readData('creds.json')) || initAuthCreds();
+
+    const fixFileName = (file) => { 
+        var _a; 
+        const fixedName = (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.replace(/:/g, '-');
+        logDebug(`Original filename: ${file}, Fixed filename: ${fixedName}`, options);
+        return fixedName;
+    };
+
+    logDebug(`Reading credentials file`, options);
+    const creds = await readData('creds.json') || (0, auth_utils_1.initAuthCreds)();
+    if (!creds) {
+        logDebug(`No existing credentials found, initialized new auth credentials`, options);
+    } else {
+        logDebug(`Successfully loaded credentials`, options);
+    }
+
     return {
         state: {
             creds,
             keys: {
                 get: async (type, ids) => {
+                    logDebug(`Getting keys of type: ${type}, ids: ${JSON.stringify(ids)}`, options);
                     const data = {};
                     await Promise.all(ids.map(async (id) => {
+                        logDebug(`Fetching key: ${type}-${id}`, options);
                         let value = await readData(`${type}-${id}.json`);
                         if (type === 'app-state-sync-key' && value) {
-                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            logDebug(`Converting app-state-sync-key to protobuf for id: ${id}`, options);
+                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
                         }
                         data[id] = value;
+                        logDebug(`Key ${id} ${value ? 'found' : 'not found'}`, options);
                     }));
                     return data;
                 },
                 set: async (data) => {
+                    logDebug(`Setting keys: ${JSON.stringify(Object.keys(data))}`, options);
                     const tasks = [];
                     for (const category in data) {
+                        logDebug(`Processing category: ${category}`, options);
                         for (const id in data[category]) {
                             const value = data[category][id];
                             const file = `${category}-${id}.json`;
+                            logDebug(`${value ? 'Setting' : 'Removing'} key: ${file}`, options);
                             tasks.push(value ? writeData(value, file) : removeData(file));
                         }
                     }
                     await Promise.all(tasks);
+                    logDebug(`Successfully completed setting all keys`, options);
                 }
             }
         },
-        saveCreds: async () => {
-            return writeData(creds, 'creds.json');
-        }
+        saveCreds: () => {
+            logDebug(`Saving credentials to creds.json`, options);
+            return writeData(creds, 'creds.json')
+                .then(() => {
+                    logDebug(`Successfully saved credentials`, options);
+                })
+                .catch((error) => {
+                    logDebug(`Error saving credentials: ${error.message}`, options);
+                    throw error;
+                });
+        },
+        cache: null
     };
 };
-//# sourceMappingURL=use-multi-file-auth-state.js.map
+exports.useMultiFileAuthState = useMultiFileAuthState;

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

@@ -0,0 +1,12 @@
+import type { Logger } from 'pino';
+import type { AuthenticationState } from '../Types';
+/**
+ * @deprecated use multi file auth state instead please
+ * stores the full authentication state in a single JSON file
+ *
+ * DO NOT USE IN A PROD ENVIRONMENT, only meant to serve as an example
+ * */
+export declare const useSingleFileAuthState: (filename: string, logger?: Logger) => {
+    state: AuthenticationState;
+    saveState: () => void;
+};

package/lib/Utils/use-single-file-auth-state.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSingleFileAuthState = void 0;
+const WAProto_1 = require("../../WAProto");
+const auth_utils_1 = require("./auth-utils");
+const generics_1 = require("./generics");
+// useless key map only there to maintain backwards compatibility
+// do not use in your own systems please
+const KEY_MAP = {
+    'pre-key': 'preKeys',
+    'session': 'sessions',
+    'sender-key': 'senderKeys',
+    'app-state-sync-key': 'appStateSyncKeys',
+    'app-state-sync-version': 'appStateVersions',
+    'sender-key-memory': 'senderKeyMemory'
+};
+/**
+ * @deprecated use multi file auth state instead please
+ * stores the full authentication state in a single JSON file
+ *
+ * DO NOT USE IN A PROD ENVIRONMENT, only meant to serve as an example
+ * */
+const useSingleFileAuthState = (filename, logger) => {
+    // require fs here so that in case "fs" is not available -- the app does not crash
+    const { readFileSync, writeFileSync, existsSync } = require('fs');
+    let creds;
+    let keys = {};
+    // save the authentication state to a file
+    const saveState = () => {
+        logger && logger.trace('saving auth state');
+        writeFileSync(filename, 
+        // BufferJSON replacer utility saves buffers nicely
+        JSON.stringify({ creds, keys }, generics_1.BufferJSON.replacer, 2));
+    };
+    if (existsSync(filename)) {
+        const result = JSON.parse(readFileSync(filename, { encoding: 'utf-8' }), generics_1.BufferJSON.reviver);
+        creds = result.creds;
+        keys = result.keys;
+    }
+    else {
+        creds = (0, auth_utils_1.initAuthCreds)();
+        keys = {};
+    }
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const key = KEY_MAP[type];
+                    return ids.reduce((dict, id) => {
+                        var _a;
+                        let value = (_a = keys[key]) === null || _a === void 0 ? void 0 : _a[id];
+                        if (value) {
+                            if (type === 'app-state-sync-key') {
+                                value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            dict[id] = value;
+                        }
+                        return dict;
+                    }, {});
+                },
+                set: (data) => {
+                    for (const _key in data) {
+                        const key = KEY_MAP[_key];
+                        keys[key] = keys[key] || {};
+                        Object.assign(keys[key], data[_key]);
+                    }
+                    saveState();
+                }
+            }
+        },
+        saveState,
+        cache: null
+    };
+};
+exports.useSingleFileAuthState = useSingleFileAuthState;