gifted-baileys 1.5.5 → 1.5.7

package/lib/Utils/noise-handler.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from 'pino';
+import { proto } from '../../WAProto';
+import { KeyPair } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const makeNoiseHandler: ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, mobile, logger, routingInfo }: {
+    keyPair: KeyPair;
+    NOISE_HEADER: Uint8Array;
+    mobile: boolean;
+    logger: Logger;
+    routingInfo?: Buffer | undefined;
+}) => {
+    encrypt: (plaintext: Uint8Array) => any;
+    decrypt: (ciphertext: Uint8Array) => any;
+    authenticate: (data: Uint8Array) => void;
+    mixIntoKey: (data: Uint8Array) => void;
+    finishInit: () => void;
+    processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => any;
+    encodeFrame: (data: Buffer | Uint8Array) => any;
+    decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => void;
+};

package/lib/Utils/process-message.d.ts

@@ -0,0 +1,41 @@
+import { AxiosRequestConfig } from 'axios';
+import type { Logger } from 'pino';
+import { proto } from '../../WAProto';
+import { AuthenticationCreds, BaileysEventEmitter, SignalKeyStoreWithTransaction, SocketConfig } from '../Types';
+type ProcessMessageContext = {
+    shouldProcessHistoryMsg: boolean;
+    creds: AuthenticationCreds;
+    keyStore: SignalKeyStoreWithTransaction;
+    ev: BaileysEventEmitter;
+    getMessage: SocketConfig['getMessage'];
+    logger?: Logger;
+    options: AxiosRequestConfig<{}>;
+};
+/** Cleans a received message to further processing */
+export declare const cleanMessage: (message: proto.IWebMessageInfo, meId: string) => void;
+export declare const isRealMessage: (message: proto.IWebMessageInfo, meId: string) => boolean | undefined;
+export declare const shouldIncrementChatUnread: (message: proto.IWebMessageInfo) => boolean;
+/**
+ * Get the ID of the chat from the given key.
+ * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
+ */
+export declare const getChatId: ({ remoteJid, participant, fromMe }: proto.IMessageKey) => string;
+type PollContext = {
+    /** normalised jid of the person that created the poll */
+    pollCreatorJid: string;
+    /** ID of the poll creation message */
+    pollMsgId: string;
+    /** poll creation message enc key */
+    pollEncKey: Uint8Array;
+    /** jid of the person that voted */
+    voterJid: string;
+};
+/**
+ * Decrypt a poll vote
+ * @param vote encrypted vote
+ * @param ctx additional info about the poll required for decryption
+ * @returns list of SHA256 options
+ */
+export declare function decryptPollVote({ encPayload, encIv }: proto.Message.IPollEncValue, { pollCreatorJid, pollMsgId, pollEncKey, voterJid, }: PollContext): proto.Message.PollVoteMessage;
+declare const processMessage: (message: proto.IWebMessageInfo, { shouldProcessHistoryMsg, ev, creds, keyStore, logger, options, getMessage }: ProcessMessageContext) => Promise<void>;
+export default processMessage;

package/{src → lib}/Utils/process-message.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.getChatId = exports.shouldIncrementChatUnread = exports.isRealMessage = exports.cleanMessage = void 0;
 exports.decryptPollVote = decryptPollVote;
@@ -111,8 +102,8 @@ function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pol
         return Buffer.from(txt);
     }
 }
-const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], void 0, function* (message, { shouldProcessHistoryMsg, ev, creds, keyStore, logger, options, getMessage }) {
-    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+const processMessage = async (message, { shouldProcessHistoryMsg, ev, creds, keyStore, logger, options, getMessage }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     const meId = creds.me.id;
     const { accountSettings } = creds;
     const chat = { id: (0, WABinary_1.jidNormalizedUser)((0, exports.getChatId)(message.key)) };
@@ -127,7 +118,7 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
     const content = (0, messages_1.normalizeMessageContent)(message.message);
     // unarchive chat if it's a real message, or someone reacted to our message
     // and we've the unarchive chats setting on
-    if ((isRealMsg || ((_c = (_b = content === null || content === void 0 ? void 0 : content.reactionMessage) === null || _b === void 0 ? void 0 : _b.key) === null || _c === void 0 ? void 0 : _c.fromMe))
+    if ((isRealMsg || ((_b = (_a = content === null || content === void 0 ? void 0 : content.reactionMessage) === null || _a === void 0 ? void 0 : _a.key) === null || _b === void 0 ? void 0 : _b.fromMe))
         && (accountSettings === null || accountSettings === void 0 ? void 0 : accountSettings.unarchiveChats)) {
         chat.archived = false;
         chat.readOnly = false;
@@ -138,7 +129,7 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
             case WAProto_1.proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION:
                 const histNotification = protocolMsg.historySyncNotification;
                 const process = shouldProcessHistoryMsg;
-                const isLatest = !((_d = creds.processedHistoryMessages) === null || _d === void 0 ? void 0 : _d.length);
+                const isLatest = !((_c = creds.processedHistoryMessages) === null || _c === void 0 ? void 0 : _c.length);
                 logger === null || logger === void 0 ? void 0 : logger.info({
                     histNotification,
                     process,
@@ -152,24 +143,24 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
                             { key: message.key, messageTimestamp: message.messageTimestamp }
                         ]
                     });
-                    const data = yield (0, history_1.downloadAndProcessHistorySyncNotification)(histNotification, options);
-                    ev.emit('messaging-history.set', Object.assign(Object.assign({}, data), { isLatest }));
+                    const data = await (0, history_1.downloadAndProcessHistorySyncNotification)(histNotification, options);
+                    ev.emit('messaging-history.set', { ...data, isLatest });
                 }
                 break;
             case WAProto_1.proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE:
                 const keys = protocolMsg.appStateSyncKeyShare.keys;
                 if (keys === null || keys === void 0 ? void 0 : keys.length) {
                     let newAppStateSyncKeyId = '';
-                    yield keyStore.transaction(() => __awaiter(void 0, void 0, void 0, function* () {
+                    await keyStore.transaction(async () => {
                         const newKeys = [];
                         for (const { keyData, keyId } of keys) {
                             const strKeyId = Buffer.from(keyId.keyId).toString('base64');
                             newKeys.push(strKeyId);
-                            yield keyStore.set({ 'app-state-sync-key': { [strKeyId]: keyData } });
+                            await keyStore.set({ 'app-state-sync-key': { [strKeyId]: keyData } });
                             newAppStateSyncKeyId = strKeyId;
                         }
                         logger === null || logger === void 0 ? void 0 : logger.info({ newAppStateSyncKeyId, newKeys }, 'injecting new app state sync keys');
-                    }));
+                    });
                     ev.emit('creds.update', { myAppStateKeyId: newAppStateSyncKeyId });
                 }
                 else {
@@ -179,7 +170,10 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
             case WAProto_1.proto.Message.ProtocolMessage.Type.REVOKE:
                 ev.emit('messages.update', [
                     {
-                        key: Object.assign(Object.assign({}, message.key), { id: protocolMsg.key.id }),
+                        key: {
+                            ...message.key,
+                            id: protocolMsg.key.id
+                        },
                         update: { message: null, messageStubType: Types_1.WAMessageStubType.REVOKE, key: message.key }
                     }
                 ]);
@@ -208,7 +202,10 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
         }
     }
     else if (content === null || content === void 0 ? void 0 : content.reactionMessage) {
-        const reaction = Object.assign(Object.assign({}, content.reactionMessage), { key: message.key });
+        const reaction = {
+            ...content.reactionMessage,
+            key: message.key,
+        };
         ev.emit('messages.reaction', [{
                 reaction,
                 key: content.reactionMessage.key,
@@ -221,7 +218,7 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
         const emitParticipantsUpdate = (action) => (ev.emit('group-participants.update', { id: jid, author: message.participant, participants, action }));
         const emitGroupUpdate = (update) => {
             var _a;
-            ev.emit('groups.update', [Object.assign(Object.assign({ id: jid }, update), { author: (_a = message.participant) !== null && _a !== void 0 ? _a : undefined })]);
+            ev.emit('groups.update', [{ id: jid, ...update, author: (_a = message.participant) !== null && _a !== void 0 ? _a : undefined }]);
         };
         const participantsIncludesMe = () => participants.find(jid => (0, WABinary_1.areJidsSameUser)(meId, jid));
         switch (message.messageStubType) {
@@ -252,28 +249,28 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
                 emitParticipantsUpdate('promote');
                 break;
             case Types_1.WAMessageStubType.GROUP_CHANGE_ANNOUNCE:
-                const announceValue = (_e = message.messageStubParameters) === null || _e === void 0 ? void 0 : _e[0];
+                const announceValue = (_d = message.messageStubParameters) === null || _d === void 0 ? void 0 : _d[0];
                 emitGroupUpdate({ announce: announceValue === 'true' || announceValue === 'on' });
                 break;
             case Types_1.WAMessageStubType.GROUP_CHANGE_RESTRICT:
-                const restrictValue = (_f = message.messageStubParameters) === null || _f === void 0 ? void 0 : _f[0];
+                const restrictValue = (_e = message.messageStubParameters) === null || _e === void 0 ? void 0 : _e[0];
                 emitGroupUpdate({ restrict: restrictValue === 'true' || restrictValue === 'on' });
                 break;
             case Types_1.WAMessageStubType.GROUP_CHANGE_SUBJECT:
-                const name = (_g = message.messageStubParameters) === null || _g === void 0 ? void 0 : _g[0];
+                const name = (_f = message.messageStubParameters) === null || _f === void 0 ? void 0 : _f[0];
                 chat.name = name;
                 emitGroupUpdate({ subject: name });
                 break;
             case Types_1.WAMessageStubType.GROUP_CHANGE_INVITE_LINK:
-                const code = (_h = message.messageStubParameters) === null || _h === void 0 ? void 0 : _h[0];
+                const code = (_g = message.messageStubParameters) === null || _g === void 0 ? void 0 : _g[0];
                 emitGroupUpdate({ inviteCode: code });
                 break;
             case Types_1.WAMessageStubType.GROUP_MEMBER_ADD_MODE:
-                const memberAddValue = (_j = message.messageStubParameters) === null || _j === void 0 ? void 0 : _j[0];
+                const memberAddValue = (_h = message.messageStubParameters) === null || _h === void 0 ? void 0 : _h[0];
                 emitGroupUpdate({ memberAddMode: memberAddValue === 'all_member_add' });
                 break;
             case Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE:
-                const approvalMode = (_k = message.messageStubParameters) === null || _k === void 0 ? void 0 : _k[0];
+                const approvalMode = (_j = message.messageStubParameters) === null || _j === void 0 ? void 0 : _j[0];
                 emitGroupUpdate({ joinApprovalMode: approvalMode === 'on' });
                 break;
         }
@@ -281,12 +278,12 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
     else if (content === null || content === void 0 ? void 0 : content.pollUpdateMessage) {
         const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey;
         // we need to fetch the poll creation message to get the poll enc key
-        const pollMsg = yield getMessage(creationMsgKey);
+        const pollMsg = await getMessage(creationMsgKey);
         if (pollMsg) {
             const meIdNormalised = (0, WABinary_1.jidNormalizedUser)(meId);
             const pollCreatorJid = (0, generics_1.getKeyAuthor)(creationMsgKey, meIdNormalised);
             const voterJid = (0, generics_1.getKeyAuthor)(message.key, meIdNormalised);
-            const pollEncKey = (_l = pollMsg.messageContextInfo) === null || _l === void 0 ? void 0 : _l.messageSecret;
+            const pollEncKey = (_k = pollMsg.messageContextInfo) === null || _k === void 0 ? void 0 : _k.messageSecret;
             try {
                 const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
                     pollEncKey,
@@ -320,5 +317,5 @@ const processMessage = (message_1, _a) => __awaiter(void 0, [message_1, _a], voi
     if (Object.keys(chat).length > 1) {
         ev.emit('chats.update', [chat]);
     }
-});
+};
 exports.default = processMessage;

package/lib/Utils/signal.d.ts

@@ -0,0 +1,33 @@
+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;
+}>;
+export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: number) => {
+    newPreKeys: {
+        [id: number]: KeyPair;
+    };
+    lastPreKeyId: number;
+    preKeysRange: readonly [number, number];
+};
+export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode;
+export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode;
+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
+ */
+export declare const getNextPreKeys: ({ creds, keys }: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>;
+    preKeys: {
+        [id: string]: KeyPair;
+    };
+}>;
+export declare const getNextPreKeysNode: (state: AuthenticationState, count: number) => Promise<{
+    update: Partial<AuthenticationCreds>;
+    node: BinaryNode;
+}>;

package/{src → lib}/Utils/signal.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.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids = exports.parseAndInjectE2ESessions = exports.xmppPreKey = exports.xmppSignedPreKey = exports.generateOrGetPreKeys = exports.getPreKeys = exports.createSignalIdentity = void 0;
 const Defaults_1 = require("../Defaults");
@@ -21,13 +12,13 @@ const createSignalIdentity = (wid, accountSignatureKey) => {
     };
 };
 exports.createSignalIdentity = createSignalIdentity;
-const getPreKeys = (_a, min_1, limit_1) => __awaiter(void 0, [_a, min_1, limit_1], void 0, function* ({ get }, min, limit) {
+const getPreKeys = async ({ get }, min, limit) => {
     const idList = [];
     for (let id = min; id < limit; id++) {
         idList.push(id.toString());
     }
     return get('pre-key', idList);
-});
+};
 exports.getPreKeys = getPreKeys;
 const generateOrGetPreKeys = (creds, range) => {
     const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
@@ -65,7 +56,7 @@ const xmppPreKey = (pair, id) => ({
     ]
 });
 exports.xmppPreKey = xmppPreKey;
-const parseAndInjectE2ESessions = (node, repository) => __awaiter(void 0, void 0, void 0, function* () {
+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')),
@@ -75,13 +66,13 @@ const parseAndInjectE2ESessions = (node, repository) => __awaiter(void 0, void 0
     for (const node of nodes) {
         (0, WABinary_1.assertNodeErrorFree)(node);
     }
-    yield Promise.all(nodes.map((node) => __awaiter(void 0, void 0, void 0, function* () {
+    await Promise.all(nodes.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 = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
-        yield repository.injectE2ESession({
+        await repository.injectE2ESession({
             jid,
             session: {
                 registrationId: registrationId,
@@ -90,31 +81,23 @@ const parseAndInjectE2ESessions = (node, repository) => __awaiter(void 0, void 0
                 preKey: extractKey(key)
             }
         });
-    })));
-});
+    }));
+};
 exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
 const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    var _a;
     const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
     const extracted = [];
-    for (const node of result.content) {
-        const list = (_a = (0, WABinary_1.getBinaryNodeChild)(node, 'list')) === null || _a === void 0 ? void 0 : _a.content;
-        if (list && Array.isArray(list)) {
-            for (const item of list) {
-                const { user } = (0, WABinary_1.jidDecode)(item.attrs.jid);
-                const devicesNode = (0, WABinary_1.getBinaryNodeChild)(item, 'devices');
-                const deviceListNode = (0, WABinary_1.getBinaryNodeChild)(devicesNode, 'device-list');
-                if (Array.isArray(deviceListNode === null || deviceListNode === void 0 ? void 0 : deviceListNode.content)) {
-                    for (const { tag, attrs } of deviceListNode.content) {
-                        const device = +attrs.id;
-                        if (tag === 'device' && // ensure the "device" tag
-                            (!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 || !!attrs['key-index']) // ensure that "key-index" is specified for "non-zero" devices, produces a bad req otherwise
-                        ) {
-                            extracted.push({ user, device });
-                        }
-                    }
+    for (const userResult of result) {
+        const { devices, id } = userResult;
+        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 });
                 }
             }
         }
@@ -126,20 +109,20 @@ exports.extractDeviceJids = extractDeviceJids;
  * get the next N keys for upload or processing
  * @param count number of pre-keys to get or generate
  */
-const getNextPreKeys = (_a, count_1) => __awaiter(void 0, [_a, count_1], void 0, function* ({ creds, keys }, 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)
     };
-    yield keys.set({ 'pre-key': newPreKeys });
-    const preKeys = yield (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
+    await keys.set({ 'pre-key': newPreKeys });
+    const preKeys = await (0, exports.getPreKeys)(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
     return { update, preKeys };
-});
+};
 exports.getNextPreKeys = getNextPreKeys;
-const getNextPreKeysNode = (state, count) => __awaiter(void 0, void 0, void 0, function* () {
+const getNextPreKeysNode = async (state, count) => {
     const { creds } = state;
-    const { update, preKeys } = yield (0, exports.getNextPreKeys)(state, count);
+    const { update, preKeys } = await (0, exports.getNextPreKeys)(state, count);
     const node = {
         tag: 'iq',
         attrs: {
@@ -156,5 +139,5 @@ const getNextPreKeysNode = (state, count) => __awaiter(void 0, void 0, void 0, f
         ]
     };
     return { update, node };
-});
+};
 exports.getNextPreKeysNode = getNextPreKeysNode;

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

@@ -0,0 +1,12 @@
+import { AuthenticationState } from '../Types';
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * 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 declare const useMultiFileAuthState: (folder: string) => Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+}>;

package/{src → lib}/Utils/use-multi-file-auth-state.js

@@ -1,12 +1,6 @@
 "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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMultiFileAuthState = void 0;
@@ -15,6 +9,8 @@ const path_1 = require("path");
 const WAProto_1 = require("../../WAProto");
 const auth_utils_1 = require("./auth-utils");
 const generics_1 = require("./generics");
+const async_lock_1 = __importDefault(require("async-lock"));
+const fileLock = new async_lock_1.default({ maxPending: Infinity });
 /**
  * stores the full authentication state in a single folder.
  * Far more efficient than singlefileauthstate
@@ -22,53 +18,56 @@ const generics_1 = require("./generics");
  * 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
  * */
-const useMultiFileAuthState = (folder) => __awaiter(void 0, void 0, void 0, function* () {
+const useMultiFileAuthState = async (folder) => {
     const writeData = (data, file) => {
-        return (0, promises_1.writeFile)((0, path_1.join)(folder, fixFileName(file)), JSON.stringify(data, generics_1.BufferJSON.replacer));
+        const filePath = (0, path_1.join)(folder, fixFileName(file));
+        return fileLock.acquire(filePath, () => (0, promises_1.writeFile)((0, path_1.join)(filePath), JSON.stringify(data, generics_1.BufferJSON.replacer)));
     };
-    const readData = (file) => __awaiter(void 0, void 0, void 0, function* () {
+    const readData = async (file) => {
         try {
-            const data = yield (0, promises_1.readFile)((0, path_1.join)(folder, fixFileName(file)), { encoding: 'utf-8' });
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const data = await fileLock.acquire(filePath, () => (0, promises_1.readFile)(filePath, { encoding: 'utf-8' }));
             return JSON.parse(data, generics_1.BufferJSON.reviver);
         }
         catch (error) {
             return null;
         }
-    });
-    const removeData = (file) => __awaiter(void 0, void 0, void 0, function* () {
+    };
+    const removeData = async (file) => {
         try {
-            yield (0, promises_1.unlink)((0, path_1.join)(folder, fixFileName(file)));
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            await fileLock.acquire(filePath, () => (0, promises_1.unlink)(filePath));
         }
         catch (_a) {
         }
-    });
-    const folderInfo = yield (0, promises_1.stat)(folder).catch(() => { });
+    };
+    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
     if (folderInfo) {
         if (!folderInfo.isDirectory()) {
             throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
         }
     }
     else {
-        yield (0, promises_1.mkdir)(folder, { recursive: true });
+        await (0, promises_1.mkdir)(folder, { recursive: true });
     }
     const fixFileName = (file) => { var _a; return (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.replace(/:/g, '-'); };
-    const creds = (yield readData('creds.json')) || (0, auth_utils_1.initAuthCreds)();
+    const creds = await readData('creds.json') || (0, auth_utils_1.initAuthCreds)();
     return {
         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}.json`);
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}.json`);
                         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) => {
                     const tasks = [];
                     for (const category in data) {
                         for (const id in data[category]) {
@@ -77,13 +76,13 @@ const useMultiFileAuthState = (folder) => __awaiter(void 0, void 0, void 0, func
                             tasks.push(value ? writeData(value, file) : removeData(file));
                         }
                     }
-                    yield Promise.all(tasks);
-                })
+                    await Promise.all(tasks);
+                }
             }
         },
         saveCreds: () => {
             return writeData(creds, 'creds.json');
         }
     };
-});
+};
 exports.useMultiFileAuthState = useMultiFileAuthState;

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,11 @@
+import { proto } from '../../WAProto';
+import type { AuthenticationCreds, SignalCreds, SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+export declare const generateMobileNode: (config: SocketConfig) => proto.IClientPayload;
+export declare const generateLoginNode: (userJid: string, config: SocketConfig) => proto.IClientPayload;
+export declare const generateRegistrationNode: ({ registrationId, signedPreKey, signedIdentityKey }: SignalCreds, config: SocketConfig) => proto.ClientPayload;
+export declare const configureSuccessfulPairing: (stanza: BinaryNode, { advSecretKey, signedIdentityKey, signalIdentities }: Pick<AuthenticationCreds, 'advSecretKey' | 'signedIdentityKey' | 'signalIdentities'>) => {
+    creds: Partial<AuthenticationCreds>;
+    reply: BinaryNode;
+};
+export declare const encodeSignedDeviceIdentity: (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => Uint8Array;

package/{src → lib}/Utils/validate-connection.js

@@ -17,12 +17,24 @@ const getUserAgent = (config) => {
     const manufacturer = config.mobile ? 'Apple' : '';
     const platform = config.mobile ? WAProto_1.proto.ClientPayload.UserAgent.Platform.IOS : WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB;
     const phoneId = config.mobile ? { phoneId: config.auth.creds.phoneId } : {};
-    return Object.assign({ appVersion: {
+    return {
+        appVersion: {
             primary: version[0],
             secondary: version[1],
             tertiary: version[2],
-        }, platform, releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE, mcc: ((_a = config.auth.creds.registration) === null || _a === void 0 ? void 0 : _a.phoneNumberMobileCountryCode) || '000', mnc: ((_b = config.auth.creds.registration) === null || _b === void 0 ? void 0 : _b.phoneNumberMobileNetworkCode) || '000', osVersion: osVersion, manufacturer,
-        device, osBuildNumber: osVersion, localeLanguageIso6391: 'en', localeCountryIso31661Alpha2: 'US' }, phoneId);
+        },
+        platform,
+        releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        mcc: ((_a = config.auth.creds.registration) === null || _a === void 0 ? void 0 : _a.phoneNumberMobileCountryCode) || '000',
+        mnc: ((_b = config.auth.creds.registration) === null || _b === void 0 ? void 0 : _b.phoneNumberMobileNetworkCode) || '000',
+        osVersion: osVersion,
+        manufacturer,
+        device,
+        osBuildNumber: osVersion,
+        localeLanguageIso6391: 'en',
+        localeCountryIso31661Alpha2: 'US',
+        ...phoneId
+    };
 };
 const PLATFORM_MAP = {
     'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
@@ -50,16 +62,31 @@ const generateMobileNode = (config) => {
     if (!config.auth.creds) {
         throw new boom_1.Boom('No registration data found', { data: config });
     }
-    const payload = Object.assign(Object.assign({}, getClientPayload(config)), { sessionId: Math.floor(Math.random() * 999999999 + 1), shortConnect: true, connectAttemptCount: 0, device: 0, dnsSource: {
+    const payload = {
+        ...getClientPayload(config),
+        sessionId: Math.floor(Math.random() * 999999999 + 1),
+        shortConnect: true,
+        connectAttemptCount: 0,
+        device: 0,
+        dnsSource: {
             appCached: false,
             dnsMethod: WAProto_1.proto.ClientPayload.DNSSource.DNSResolutionMethod.SYSTEM,
-        }, passive: false, pushName: 'test', username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`) });
+        },
+        passive: false,
+        pushName: 'test',
+        username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`),
+    };
     return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
 exports.generateMobileNode = generateMobileNode;
 const generateLoginNode = (userJid, config) => {
     const { user, device } = (0, WABinary_1.jidDecode)(userJid);
-    const payload = Object.assign(Object.assign({}, getClientPayload(config)), { passive: true, username: +user, device: device });
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        username: +user,
+        device: device,
+    };
     return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
 exports.generateLoginNode = generateLoginNode;
@@ -79,7 +106,10 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
         requireFullSync: config.syncFullHistory,
     };
     const companionProto = WAProto_1.proto.DeviceProps.encode(companion).finish();
-    const registerPayload = Object.assign(Object.assign({}, getClientPayload(config)), { passive: false, devicePairingData: {
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
             eRegid: (0, generics_1.encodeBigEndian)(registrationId),
@@ -88,7 +118,8 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
             eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
             eSkeySig: signedPreKey.signature,
-        } });
+        },
+    };
     return WAProto_1.proto.ClientPayload.fromObject(registerPayload);
 };
 exports.generateRegistrationNode = generateRegistrationNode;
@@ -161,7 +192,7 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
 exports.configureSuccessfulPairing = configureSuccessfulPairing;
 const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
     var _a;
-    account = Object.assign({}, account);
+    account = { ...account };
     // set to null if we are not to include the signature key
     // or if we are including the signature key but it is empty
     if (!includeSignatureKey || !((_a = account.accountSignatureKey) === null || _a === void 0 ? void 0 : _a.length)) {