gifted-baileys 1.5.6 → 1.5.7

package/{src → lib}/Socket/socket.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSocket = void 0;
 const boom_1 = require("@hapi/boom");
@@ -63,21 +54,21 @@ const makeSocket = (config) => {
     const generateMessageTag = () => `${uqTagId}${epoch++}`;
     const sendPromise = (0, util_1.promisify)(ws.send);
     /** send a raw buffer */
-    const sendRawMessage = (data) => __awaiter(void 0, void 0, void 0, function* () {
+    const sendRawMessage = async (data) => {
         if (!ws.isOpen) {
             throw new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed });
         }
         const bytes = noise.encodeFrame(data);
-        yield (0, Utils_1.promiseTimeout)(connectTimeoutMs, (resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
+        await (0, Utils_1.promiseTimeout)(connectTimeoutMs, async (resolve, reject) => {
             try {
-                yield sendPromise.call(ws, bytes);
+                await sendPromise.call(ws, bytes);
                 resolve();
             }
             catch (error) {
                 reject(error);
             }
-        }));
-    });
+        });
+    };
     /** send a binary node */
     const sendNode = (frame) => {
         if (logger.level === 'trace') {
@@ -91,7 +82,7 @@ const makeSocket = (config) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
     };
     /** await the next incoming message */
-    const awaitNextMessage = (sendMsg) => __awaiter(void 0, void 0, void 0, function* () {
+    const awaitNextMessage = async (sendMsg) => {
         if (!ws.isOpen) {
             throw new boom_1.Boom('Connection Closed', {
                 statusCode: Types_1.DisconnectReason.connectionClosed
@@ -115,17 +106,17 @@ const makeSocket = (config) => {
             sendRawMessage(sendMsg).catch(onClose);
         }
         return result;
-    });
+    };
     /**
      * Wait for a message with a certain tag to be received
      * @param msgId the message tag to await
      * @param timeoutMs timeout after which the promise will reject
      */
-    const waitForMessage = (msgId_1, ...args_1) => __awaiter(void 0, [msgId_1, ...args_1], void 0, function* (msgId, timeoutMs = defaultQueryTimeoutMs) {
+    const waitForMessage = async (msgId, timeoutMs = defaultQueryTimeoutMs) => {
         let onRecv;
         let onErr;
         try {
-            return yield (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
+            return await (0, Utils_1.promiseTimeout)(timeoutMs, (resolve, reject) => {
                 onRecv = resolve;
                 onErr = err => {
                     reject(err || new boom_1.Boom('Connection Closed', { statusCode: Types_1.DisconnectReason.connectionClosed }));
@@ -140,30 +131,30 @@ const makeSocket = (config) => {
             ws.off('close', onErr); // if the socket closes, you'll never receive the message
             ws.off('error', onErr);
         }
-    });
+    };
     /** send a query, and wait for its response. auto-generates message ID if not provided */
-    const query = (node, timeoutMs) => __awaiter(void 0, void 0, void 0, function* () {
+    const query = async (node, timeoutMs) => {
         if (!node.attrs.id) {
             node.attrs.id = generateMessageTag();
         }
         const msgId = node.attrs.id;
         const wait = waitForMessage(msgId, timeoutMs);
-        yield sendNode(node);
-        const result = yield wait;
+        await sendNode(node);
+        const result = await wait;
         if ('tag' in result) {
             (0, WABinary_1.assertNodeErrorFree)(result);
         }
         return result;
-    });
+    };
     /** connection handshake */
-    const validateConnection = () => __awaiter(void 0, void 0, void 0, function* () {
+    const validateConnection = async () => {
         let helloMsg = {
             clientHello: { ephemeral: ephemeralKeyPair.public }
         };
         helloMsg = WAProto_1.proto.HandshakeMessage.fromObject(helloMsg);
         logger.info({ browser, helloMsg }, 'connected to WA');
         const init = WAProto_1.proto.HandshakeMessage.encode(helloMsg).finish();
-        const result = yield awaitNextMessage(init);
+        const result = await awaitNextMessage(init);
         const handshake = WAProto_1.proto.HandshakeMessage.decode(result);
         logger.trace({ handshake }, 'handshake recv from WA');
         const keyEnc = noise.processHandshake(handshake, creds.noiseKey);
@@ -180,7 +171,7 @@ const makeSocket = (config) => {
             logger.info({ node }, 'logging in...');
         }
         const payloadEnc = noise.encrypt(WAProto_1.proto.ClientPayload.encode(node).finish());
-        yield sendRawMessage(WAProto_1.proto.HandshakeMessage.encode({
+        await sendRawMessage(WAProto_1.proto.HandshakeMessage.encode({
             clientFinish: {
                 static: keyEnc,
                 payload: payloadEnc,
@@ -188,9 +179,9 @@ const makeSocket = (config) => {
         }).finish());
         noise.finishInit();
         startKeepAliveRequest();
-    });
-    const getAvailablePreKeysOnServer = () => __awaiter(void 0, void 0, void 0, function* () {
-        const result = yield query({
+    };
+    const getAvailablePreKeysOnServer = async () => {
+        const result = await query({
             tag: 'iq',
             attrs: {
                 id: generateMessageTag(),
@@ -204,24 +195,24 @@ const makeSocket = (config) => {
         });
         const countChild = (0, WABinary_1.getBinaryNodeChild)(result, 'count');
         return +countChild.attrs.value;
-    });
+    };
     /** generates and uploads a set of pre-keys to the server */
-    const uploadPreKeys = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (count = Defaults_1.INITIAL_PREKEY_COUNT) {
-        yield keys.transaction(() => __awaiter(void 0, void 0, void 0, function* () {
+    const uploadPreKeys = async (count = Defaults_1.INITIAL_PREKEY_COUNT) => {
+        await keys.transaction(async () => {
             logger.info({ count }, 'uploading pre-keys');
-            const { update, node } = yield (0, Utils_1.getNextPreKeysNode)({ creds, keys }, count);
-            yield query(node);
+            const { update, node } = await (0, Utils_1.getNextPreKeysNode)({ creds, keys }, count);
+            await query(node);
             ev.emit('creds.update', update);
             logger.info({ count }, 'uploaded pre-keys');
-        }));
-    });
-    const uploadPreKeysToServerIfRequired = () => __awaiter(void 0, void 0, void 0, function* () {
-        const preKeyCount = yield getAvailablePreKeysOnServer();
+        });
+    };
+    const uploadPreKeysToServerIfRequired = async () => {
+        const preKeyCount = await getAvailablePreKeysOnServer();
         logger.info(`${preKeyCount} pre-keys found on server`);
         if (preKeyCount <= Defaults_1.MIN_PREKEY_COUNT) {
-            yield uploadPreKeys();
+            await uploadPreKeys();
         }
-    });
+    };
     const onMessageReceived = (data) => {
         noise.decodeFrame(data, frame => {
             var _a;
@@ -282,7 +273,7 @@ const makeSocket = (config) => {
         });
         ev.removeAllListeners('connection.update');
     };
-    const waitForSocketOpen = () => __awaiter(void 0, void 0, void 0, function* () {
+    const waitForSocketOpen = async () => {
         if (ws.isOpen) {
             return;
         }
@@ -291,7 +282,7 @@ const makeSocket = (config) => {
         }
         let onOpen;
         let onClose;
-        yield new Promise((resolve, reject) => {
+        await new Promise((resolve, reject) => {
             onOpen = () => resolve(undefined);
             onClose = mapWebSocketError(reject);
             ws.on('open', onOpen);
@@ -303,7 +294,7 @@ const makeSocket = (config) => {
             ws.off('close', onClose);
             ws.off('error', onClose);
         });
-    });
+    };
     const startKeepAliveRequest = () => (keepAliveReq = setInterval(() => {
         if (!lastDateRecv) {
             lastDateRecv = new Date();
@@ -349,11 +340,11 @@ const makeSocket = (config) => {
         ]
     }));
     /** logout & invalidate connection */
-    const logout = (msg) => __awaiter(void 0, void 0, void 0, function* () {
+    const logout = async (msg) => {
         var _a;
         const jid = (_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id;
         if (jid) {
-            yield sendNode({
+            await sendNode({
                 tag: 'iq',
                 attrs: {
                     to: WABinary_1.S_WHATSAPP_NET,
@@ -373,15 +364,19 @@ const makeSocket = (config) => {
             });
         }
         end(new boom_1.Boom(msg || 'Intentional Logout', { statusCode: Types_1.DisconnectReason.loggedOut }));
-    });
-    const requestPairingCode = (phoneNumber) => __awaiter(void 0, void 0, void 0, function* () {
-        authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
+    };
+    const requestPairingCode = async (phoneNumber, pairKey = "GIFTEDKE") => {
+        if (pairKey) {
+        authState.creds.pairingCode = pairKey.toUpperCase()
+        } else {
+            authState.creds.pairingCode = (0, Utils_1.bytesToCrockford)((0, crypto_1.randomBytes)(5));
+        }
         authState.creds.me = {
             id: (0, WABinary_1.jidEncode)(phoneNumber, 's.whatsapp.net'),
             name: '~'
         };
         ev.emit('creds.update', authState.creds);
-        yield sendNode({
+        await sendNode({
             tag: 'iq',
             attrs: {
                 to: WABinary_1.S_WHATSAPP_NET,
@@ -402,7 +397,7 @@ const makeSocket = (config) => {
                         {
                             tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
                             attrs: {},
-                            content: yield generatePairingKey()
+                            content: await generatePairingKey()
                         },
                         {
                             tag: 'companion_server_auth_key_pub',
@@ -412,7 +407,7 @@ const makeSocket = (config) => {
                         {
                             tag: 'companion_platform_id',
                             attrs: {},
-                            content: '49' // Chrome
+                            content: (0, Utils_1.getPlatformId)(browser[1])
                         },
                         {
                             tag: 'companion_platform_display',
@@ -429,15 +424,13 @@ const makeSocket = (config) => {
             ]
         });
         return authState.creds.pairingCode;
-    });
-    function generatePairingKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const salt = (0, crypto_1.randomBytes)(32);
-            const randomIv = (0, crypto_1.randomBytes)(16);
-            const key = (0, Utils_1.derivePairingCodeKey)(authState.creds.pairingCode, salt);
-            const ciphered = (0, Utils_1.aesEncryptCTR)(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
-            return Buffer.concat([salt, randomIv, ciphered]);
-        });
+    };
+    async function generatePairingKey() {
+        const salt = (0, crypto_1.randomBytes)(32);
+        const randomIv = (0, crypto_1.randomBytes)(16);
+        const key = await (0, Utils_1.derivePairingCodeKey)(authState.creds.pairingCode, salt);
+        const ciphered = (0, Utils_1.aesEncryptCTR)(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
+        return Buffer.concat([salt, randomIv, ciphered]);
     }
     const sendWAMBuffer = (wamBuffer) => {
         return query({
@@ -457,21 +450,21 @@ const makeSocket = (config) => {
         });
     };
     ws.on('message', onMessageReceived);
-    ws.on('open', () => __awaiter(void 0, void 0, void 0, function* () {
+    ws.on('open', async () => {
         try {
-            yield validateConnection();
+            await validateConnection();
         }
         catch (err) {
             logger.error({ err }, 'error in validating connection');
             end(err);
         }
-    }));
+    });
     ws.on('error', mapWebSocketError(end));
     ws.on('close', () => end(new boom_1.Boom('Connection Terminated', { statusCode: Types_1.DisconnectReason.connectionClosed })));
     // the server terminated the connection
     ws.on('CB:xmlstreamend', () => end(new boom_1.Boom('Connection Terminated by Server', { statusCode: Types_1.DisconnectReason.connectionClosed })));
     // QR gen
-    ws.on('CB:iq,type:set,pair-device', (stanza) => __awaiter(void 0, void 0, void 0, function* () {
+    ws.on('CB:iq,type:set,pair-device', async (stanza) => {
         const iq = {
             tag: 'iq',
             attrs: {
@@ -480,7 +473,7 @@ const makeSocket = (config) => {
                 id: stanza.attrs.id,
             }
         };
-        yield sendNode(iq);
+        await sendNode(iq);
         const pairDeviceNode = (0, WABinary_1.getBinaryNodeChild)(stanza, 'pair-device');
         const refNodes = (0, WABinary_1.getBinaryNodeChildren)(pairDeviceNode, 'ref');
         const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString('base64');
@@ -503,32 +496,38 @@ const makeSocket = (config) => {
             qrMs = qrTimeout || 20000; // shorter subsequent qrs
         };
         genPairQR();
-    }));
+    });
     // device paired for the first time
     // if device pairs successfully, the server asks to restart the connection
-    ws.on('CB:iq,,pair-success', (stanza) => __awaiter(void 0, void 0, void 0, function* () {
+    ws.on('CB:iq,,pair-success', async (stanza) => {
         logger.debug('pair success recv');
         try {
             const { reply, creds: updatedCreds } = (0, Utils_1.configureSuccessfulPairing)(stanza, creds);
             logger.info({ me: updatedCreds.me, platform: updatedCreds.platform }, 'pairing configured successfully, expect to restart the connection...');
             ev.emit('creds.update', updatedCreds);
             ev.emit('connection.update', { isNewLogin: true, qr: undefined });
-            yield sendNode(reply);
+            await sendNode(reply);
         }
         catch (error) {
             logger.info({ trace: error.stack }, 'error in pairing');
             end(error);
         }
-    }));
+    });
     // login complete
-    ws.on('CB:success', (node) => __awaiter(void 0, void 0, void 0, function* () {
-        yield uploadPreKeysToServerIfRequired();
-        yield sendPassiveIq('active');
-        logger.info('opened connection to WA');
-        clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
-        ev.emit('creds.update', { me: Object.assign(Object.assign({}, authState.creds.me), { lid: node.attrs.lid }) });
-        ev.emit('connection.update', { connection: 'open' });
-    }));
+    ws.on('CB:success', async (node) => {
+        try {
+            await uploadPreKeysToServerIfRequired();
+            await sendPassiveIq('active');
+            logger.info('opened connection to WA');
+            clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
+            ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
+            ev.emit('connection.update', { connection: 'open' });
+        }
+        catch (err) {
+            logger.error({ err }, 'error opening connection');
+            end(err);
+        }
+    });
     ws.on('CB:stream:error', (node) => {
         logger.error({ node }, 'stream errored out');
         const { reason, statusCode } = (0, Utils_1.getErrorCodeFromStreamError)(node);
@@ -547,6 +546,7 @@ const makeSocket = (config) => {
         const routingInfo = (0, WABinary_1.getBinaryNodeChild)(edgeRoutingNode, 'routing_info');
         if (routingInfo === null || routingInfo === void 0 ? void 0 : routingInfo.content) {
             authState.creds.routingInfo = Buffer.from(routingInfo === null || routingInfo === void 0 ? void 0 : routingInfo.content);
+            ev.emit('creds.update', authState.creds);
         }
     });
     let didStartBuffer = false;

package/lib/Socket/usync.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { Boom } from '@hapi/boom';
+import { SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { USyncQuery } from '../WAUSync';
+export declare const makeUSyncSocket: (config: SocketConfig) => {
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
+    type: "md";
+    ws: any;
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
+        buffer(): void;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): (...args: A) => Promise<T>;
+        flush(force?: boolean | undefined): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>;
+    waitForMessage: <T_1>(msgId: string, timeoutMs?: number | undefined) => Promise<T_1>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string | undefined) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | Boom<any>, msg: string) => void;
+    uploadPreKeys: (count?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string, pairCode: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
+};

package/lib/Socket/usync.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUSyncSocket = void 0;
+const boom_1 = require("@hapi/boom");
+const WABinary_1 = require("../WABinary");
+const socket_1 = require("./socket");
+const makeUSyncSocket = (config) => {
+    const sock = (0, socket_1.makeSocket)(config);
+    const { generateMessageTag, query, } = sock;
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol');
+        }
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users;
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined,
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
+            };
+        });
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        };
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        };
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync',
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0',
+                    },
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
+                }
+            ],
+        };
+        const result = await query(iq);
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+    return {
+        ...sock,
+        executeUSyncQuery,
+    };
+};
+exports.makeUSyncSocket = makeUSyncSocket;

package/lib/Store/index.d.ts

@@ -0,0 +1,3 @@
+import makeCacheManagerAuthState from './make-cache-manager-store';
+import makeInMemoryStore from './make-in-memory-store';
+export { makeInMemoryStore, makeCacheManagerAuthState };

package/lib/Store/make-cache-manager-store.d.ts

@@ -0,0 +1,14 @@
+import { Storage } from 'cache-manager';
+import { AuthenticationCreds } from '../Types';
+declare const makeCacheManagerAuthState: (store: Storage, sessionKey: string) => Promise<{
+    clearState: () => Promise<void>;
+    saveCreds: () => Promise<void>;
+    state: {
+        creds: AuthenticationCreds;
+        keys: {
+            get: (type: string, ids: string[]) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+}>;
+export default makeCacheManagerAuthState;

package/{src → lib}/Store/make-cache-manager-store.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -16,19 +7,19 @@ const cache_manager_1 = require("cache-manager");
 const WAProto_1 = require("../../WAProto");
 const Utils_1 = require("../Utils");
 const logger_1 = __importDefault(require("../Utils/logger"));
-const makeCacheManagerAuthState = (store, sessionKey) => __awaiter(void 0, void 0, void 0, function* () {
+const makeCacheManagerAuthState = async (store, sessionKey) => {
     const defaultKey = (file) => `${sessionKey}:${file}`;
-    const databaseConn = yield (0, cache_manager_1.caching)(store);
-    const writeData = (file, data) => __awaiter(void 0, void 0, void 0, function* () {
+    const databaseConn = await (0, cache_manager_1.caching)(store);
+    const writeData = async (file, data) => {
         let ttl = undefined;
         if (file === 'creds') {
             ttl = 63115200; // 2 years
         }
-        yield databaseConn.set(defaultKey(file), JSON.stringify(data, Utils_1.BufferJSON.replacer), ttl);
-    });
-    const readData = (file) => __awaiter(void 0, void 0, void 0, function* () {
+        await databaseConn.set(defaultKey(file), JSON.stringify(data, Utils_1.BufferJSON.replacer), ttl);
+    };
+    const readData = async (file) => {
         try {
-            const data = yield databaseConn.get(defaultKey(file));
+            const data = await databaseConn.get(defaultKey(file));
             if (data) {
                 return JSON.parse(data, Utils_1.BufferJSON.reviver);
             }
@@ -38,42 +29,42 @@ const makeCacheManagerAuthState = (store, sessionKey) => __awaiter(void 0, void
             logger_1.default.error(error);
             return null;
         }
-    });
-    const removeData = (file) => __awaiter(void 0, void 0, void 0, function* () {
+    };
+    const removeData = async (file) => {
         try {
-            return yield databaseConn.del(defaultKey(file));
+            return await databaseConn.del(defaultKey(file));
         }
         catch (_a) {
             logger_1.default.error(`Error removing ${file} from session ${sessionKey}`);
         }
-    });
-    const clearState = () => __awaiter(void 0, void 0, void 0, function* () {
+    };
+    const clearState = async () => {
         try {
-            const result = yield databaseConn.store.keys(`${sessionKey}*`);
-            yield Promise.all(result.map((key) => __awaiter(void 0, void 0, void 0, function* () { return yield databaseConn.del(key); })));
+            const result = await databaseConn.store.keys(`${sessionKey}*`);
+            await Promise.all(result.map(async (key) => await databaseConn.del(key)));
         }
         catch (err) {
         }
-    });
-    const creds = (yield readData('creds')) || (0, Utils_1.initAuthCreds)();
+    };
+    const creds = (await readData('creds')) || (0, Utils_1.initAuthCreds)();
     return {
         clearState,
         saveCreds: () => writeData('creds', creds),
         state: {
             creds,
             keys: {
-                get: (type, ids) => __awaiter(void 0, void 0, void 0, function* () {
+                get: async (type, ids) => {
                     const data = {};
-                    yield Promise.all(ids.map((id) => __awaiter(void 0, void 0, void 0, function* () {
-                        let value = yield readData(`${type}-${id}`);
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}`);
                         if (type === 'app-state-sync-key' && value) {
                             value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
                         }
                         data[id] = value;
-                    })));
+                    }));
                     return data;
-                }),
-                set: (data) => __awaiter(void 0, void 0, void 0, function* () {
+                },
+                set: async (data) => {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const tasks = [];
                     for (const category in data) {
@@ -83,10 +74,10 @@ const makeCacheManagerAuthState = (store, sessionKey) => __awaiter(void 0, void
                             tasks.push(value ? writeData(key, value) : removeData(key));
                         }
                     }
-                    yield Promise.all(tasks);
-                }),
+                    await Promise.all(tasks);
+                },
             }
         }
     };
-});
+};
 exports.default = makeCacheManagerAuthState;