@modzneverdie/baileys 17.1.12 → 17.1.17

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

@@ -1,19 +1,21 @@
-import { ILogger } from './logger';
+/// <reference types="node" />
+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, logger, routingInfo }: {
+export declare const makeNoiseHandler: ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, mobile, logger, routingInfo }: {
     keyPair: KeyPair;
     NOISE_HEADER: Uint8Array;
-    logger: ILogger;
+    mobile: boolean;
+    logger: Logger;
     routingInfo?: Buffer | undefined;
 }) => {
-    encrypt: (plaintext: Uint8Array) => Buffer<ArrayBuffer>;
-    decrypt: (ciphertext: Uint8Array) => Buffer<ArrayBuffer>;
+    encrypt: (plaintext: Uint8Array) => Buffer;
+    decrypt: (ciphertext: Uint8Array) => Buffer;
     authenticate: (data: Uint8Array) => void;
-    mixIntoKey: (data: Uint8Array) => Promise<void>;
-    finishInit: () => Promise<void>;
-    processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => Promise<Buffer<ArrayBuffer>>;
-    encodeFrame: (data: Buffer | Uint8Array) => Buffer<ArrayBuffer>;
-    decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => Promise<void>;
+    mixIntoKey: (data: Uint8Array) => void;
+    finishInit: () => void;
+    processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => Buffer;
+    encodeFrame: (data: Buffer | Uint8Array) => Buffer;
+    decodeFrame: (newData: Buffer | Uint8Array, onFrame: (buff: Uint8Array | BinaryNode) => void) => void;
 };

package/lib/Utils/noise-handler.js

@@ -11,7 +11,7 @@ const generateIV = (counter) => {
     new DataView(iv).setUint32(8, counter);
     return new Uint8Array(iv);
 };
-const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }) => {
+const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, mobile, logger, routingInfo }) => {
     logger = logger.child({ class: 'ns' });
     const authenticate = (data) => {
         if (!isFinished) {
@@ -38,20 +38,20 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
         authenticate(ciphertext);
         return result;
     };
-    const localHKDF = async (data) => {
-        const key = await (0, crypto_1.hkdf)(Buffer.from(data), 64, { salt, info: '' });
+    const localHKDF = (data) => {
+        const key = (0, crypto_1.hkdf)(Buffer.from(data), 64, { salt, info: '' });
         return [key.slice(0, 32), key.slice(32)];
     };
-    const mixIntoKey = async (data) => {
-        const [write, read] = await localHKDF(data);
+    const mixIntoKey = (data) => {
+        const [write, read] = localHKDF(data);
         salt = write;
         encKey = read;
         decKey = read;
         readCounter = 0;
         writeCounter = 0;
     };
-    const finishInit = async () => {
-        const [write, read] = await localHKDF(new Uint8Array(0));
+    const finishInit = () => {
+        const [write, read] = localHKDF(new Uint8Array(0));
         encKey = write;
         decKey = read;
         hash = Buffer.from([]);
@@ -60,7 +60,7 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
         isFinished = true;
     };
     const data = Buffer.from(Defaults_1.NOISE_MODE);
-    let hash = data.byteLength === 32 ? data : (0, crypto_1.sha256)(data);
+    let hash = Buffer.from(data.byteLength === 32 ? data : (0, crypto_1.sha256)(data));
     let salt = hash;
     let encKey = hash;
     let decKey = hash;
@@ -77,19 +77,24 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
         authenticate,
         mixIntoKey,
         finishInit,
-        processHandshake: async ({ serverHello }, noiseKey) => {
+        processHandshake: ({ serverHello }, noiseKey) => {
             authenticate(serverHello.ephemeral);
-            await mixIntoKey(crypto_1.Curve.sharedKey(privateKey, serverHello.ephemeral));
+            mixIntoKey(crypto_1.Curve.sharedKey(privateKey, serverHello.ephemeral));
             const decStaticContent = decrypt(serverHello.static);
-            await mixIntoKey(crypto_1.Curve.sharedKey(privateKey, decStaticContent));
+            mixIntoKey(crypto_1.Curve.sharedKey(privateKey, decStaticContent));
             const certDecoded = decrypt(serverHello.payload);
-            const { intermediate: certIntermediate } = WAProto_1.proto.CertChain.decode(certDecoded);
-            const { issuerSerial } = WAProto_1.proto.CertChain.NoiseCertificate.Details.decode(certIntermediate.details);
-            if (issuerSerial !== Defaults_1.WA_CERT_DETAILS.SERIAL) {
-                throw new boom_1.Boom('certification match failed', { statusCode: 400 });
+            if (mobile) {
+                WAProto_1.proto.CertChain.NoiseCertificate.decode(certDecoded);
+            }
+            else {
+                const { intermediate: certIntermediate } = WAProto_1.proto.CertChain.decode(certDecoded);
+                const { issuerSerial } = WAProto_1.proto.CertChain.NoiseCertificate.Details.decode(certIntermediate.details);
+                if (issuerSerial !== Defaults_1.WA_CERT_DETAILS.SERIAL) {
+                    throw new boom_1.Boom('certification match failed', { statusCode: 400 });
+                }
             }
             const keyEnc = encrypt(noiseKey.public);
-            await mixIntoKey(crypto_1.Curve.sharedKey(noiseKey.private, serverHello.ephemeral));
+            mixIntoKey(crypto_1.Curve.sharedKey(noiseKey.private, serverHello.ephemeral));
             return keyEnc;
         },
         encodeFrame: (data) => {
@@ -120,7 +125,7 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
             frame.set(data, introSize + 3);
             return frame;
         },
-        decodeFrame: async (newData, onFrame) => {
+        decodeFrame: (newData, onFrame) => {
             var _a;
             // the binary protocol uses its own framing mechanism
             // on top of the WS frames
@@ -138,7 +143,7 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
                 inBytes = inBytes.slice(size + 3);
                 if (isFinished) {
                     const result = decrypt(frame);
-                    frame = await (0, WABinary_1.decodeBinaryNode)(result);
+                    frame = (0, WABinary_1.decodeBinaryNode)(result);
                 }
                 logger.trace({ msg: (_a = frame === null || frame === void 0 ? void 0 : frame.attrs) === null || _a === void 0 ? void 0 : _a.id }, 'recv frame');
                 onFrame(frame);

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

@@ -1,15 +1,14 @@
 import { AxiosRequestConfig } from 'axios';
+import type { Logger } from 'pino';
 import { proto } from '../../WAProto';
-import { AuthenticationCreds, BaileysEventEmitter, CacheStore, SignalKeyStoreWithTransaction, SocketConfig } from '../Types';
-import { ILogger } from './logger';
+import { AuthenticationCreds, BaileysEventEmitter, SignalKeyStoreWithTransaction, SocketConfig } from '../Types';
 type ProcessMessageContext = {
     shouldProcessHistoryMsg: boolean;
-    placeholderResendCache?: CacheStore;
     creds: AuthenticationCreds;
     keyStore: SignalKeyStoreWithTransaction;
     ev: BaileysEventEmitter;
     getMessage: SocketConfig['getMessage'];
-    logger?: ILogger;
+    logger?: Logger;
     options: AxiosRequestConfig<{}>;
 };
 /** Cleans a received message to further processing */
@@ -38,5 +37,5 @@ type PollContext = {
  * @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, placeholderResendCache, ev, creds, keyStore, logger, options, getMessage }: ProcessMessageContext) => Promise<void>;
+declare const processMessage: (message: proto.IWebMessageInfo, { shouldProcessHistoryMsg, ev, creds, keyStore, logger, options, getMessage }: ProcessMessageContext) => Promise<void>;
 export default processMessage;

package/lib/Utils/process-message.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChatId = exports.shouldIncrementChatUnread = exports.isRealMessage = exports.cleanMessage = void 0;
-exports.decryptPollVote = decryptPollVote;
+exports.decryptPollVote = exports.getChatId = exports.shouldIncrementChatUnread = exports.isRealMessage = exports.cleanMessage = void 0;
 const WAProto_1 = require("../../WAProto");
 const Types_1 = require("../Types");
 const messages_1 = require("../Utils/messages");
@@ -21,21 +20,8 @@ const REAL_MSG_REQ_ME_STUB_TYPES = new Set([
 /** Cleans a received message to further processing */
 const cleanMessage = (message, meId) => {
     // ensure remoteJid and participant doesn't have device or agent in it
-    // normalize JIDs but catch errors to avoid throwing on invalid LIDs/JIDs
-    try {
-        message.key.remoteJid = (0, WABinary_1.jidNormalizedUser)(message.key.remoteJid);
-    }
-    catch (_e) {
-        // if normalization fails, retain original remoteJid
-    }
-    if (message.key.participant) {
-        try {
-            message.key.participant = (0, WABinary_1.jidNormalizedUser)(message.key.participant);
-        }
-        catch (_e) {
-            // ignore if can't normalize participant
-        }
-    }
+    message.key.remoteJid = (0, WABinary_1.jidNormalizedUser)(message.key.remoteJid);
+    message.key.participant = message.key.participant ? (0, WABinary_1.jidNormalizedUser)(message.key.participant) : undefined;
     const content = (0, messages_1.normalizeMessageContent)(message.message);
     // if the message has a reaction, ensure fromMe & remoteJid are from our perspective
     if (content === null || content === void 0 ? void 0 : content.reactionMessage) {
@@ -115,14 +101,14 @@ function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pol
         return Buffer.from(txt);
     }
 }
-const processMessage = async (message, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, keyStore, logger, options, getMessage }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+exports.decryptPollVote = decryptPollVote;
+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)) };
     const isRealMsg = (0, exports.isRealMessage)(message, meId);
     if (isRealMsg) {
-        chat.messages = [{ message }];
         chat.conversationTimestamp = (0, generics_1.toNumber)(message.messageTimestamp);
         // only increment unread count if not CIPHERTEXT and from another person
         if ((0, exports.shouldIncrementChatUnread)(message)) {
@@ -151,22 +137,14 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                     isLatest,
                 }, 'got history notification');
                 if (process) {
-                    if (histNotification.syncType !== WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND) {
-                        ev.emit('creds.update', {
-                            processedHistoryMessages: [
-                                ...(creds.processedHistoryMessages || []),
-                                { key: message.key, messageTimestamp: message.messageTimestamp }
-                            ]
-                        });
-                    }
-                    const data = await (0, history_1.downloadAndProcessHistorySyncNotification)(histNotification, options);
-                    ev.emit('messaging-history.set', {
-                        ...data,
-                        isLatest: histNotification.syncType !== WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND
-                            ? isLatest
-                            : undefined,
-                        peerDataRequestSessionId: histNotification.peerDataRequestSessionId
+                    ev.emit('creds.update', {
+                        processedHistoryMessages: [
+                            ...(creds.processedHistoryMessages || []),
+                            { key: message.key, messageTimestamp: message.messageTimestamp }
+                        ]
                     });
+                    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:
@@ -209,41 +187,17 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             case WAProto_1.proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE:
                 const response = protocolMsg.peerDataOperationRequestResponseMessage;
                 if (response) {
-                    placeholderResendCache === null || placeholderResendCache === void 0 ? void 0 : placeholderResendCache.del(response.stanzaId);
-                    // TODO: IMPLEMENT HISTORY SYNC ETC (sticker uploads etc.).
                     const { peerDataOperationResult } = response;
                     for (const result of peerDataOperationResult) {
                         const { placeholderMessageResendResponse: retryResponse } = result;
                         if (retryResponse) {
                             const webMessageInfo = WAProto_1.proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes);
-                            // wait till another upsert event is available, don't want it to be part of the PDO response message
-                            setTimeout(() => {
-                                ev.emit('messages.upsert', {
-                                    messages: [webMessageInfo],
-                                    type: 'notify',
-                                    requestId: response.stanzaId
-                                });
-                            }, 500);
+                            ev.emit('messages.update', [
+                                { key: webMessageInfo.key, update: { message: webMessageInfo.message } }
+                            ]);
                         }
                     }
                 }
-            case WAProto_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT:
-                ev.emit('messages.update', [
-                    {
-                        // flip the sender / fromMe properties because they're in the perspective of the sender
-                        key: { ...message.key, id: (_d = protocolMsg.key) === null || _d === void 0 ? void 0 : _d.id },
-                        update: {
-                            message: {
-                                editedMessage: {
-                                    message: protocolMsg.editedMessage
-                                }
-                            },
-                            messageTimestamp: protocolMsg.timestampMs
-                                ? Math.floor((0, generics_1.toNumber)(protocolMsg.timestampMs) / 1000)
-                                : message.messageTimestamp
-                        }
-                    }
-                ]);
                 break;
         }
     }
@@ -254,11 +208,11 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         };
         ev.emit('messages.reaction', [{
                 reaction,
-                key: (_e = content.reactionMessage) === null || _e === void 0 ? void 0 : _e.key,
+                key: content.reactionMessage.key,
             }]);
     }
     else if (message.messageStubType) {
-        const jid = (_f = message.key) === null || _f === void 0 ? void 0 : _f.remoteJid;
+        const jid = message.key.remoteJid;
         //let actor = whatsappID (message.participant)
         let participants;
         const emitParticipantsUpdate = (action) => (ev.emit('group-participants.update', { id: jid, author: message.participant, participants, action }));
@@ -266,15 +220,8 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             var _a;
             ev.emit('groups.update', [{ id: jid, ...update, author: (_a = message.participant) !== null && _a !== void 0 ? _a : undefined }]);
         };
-        const emitGroupRequestJoin = (participant, action, method) => {
-            ev.emit('group.join-request', { id: jid, author: message.participant, participant, action, method: method });
-        };
         const participantsIncludesMe = () => participants.find(jid => (0, WABinary_1.areJidsSameUser)(meId, jid));
         switch (message.messageStubType) {
-            case Types_1.WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER:
-                participants = message.messageStubParameters || [];
-                emitParticipantsUpdate('modify');
-                break;
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_LEAVE:
             case Types_1.WAMessageStubType.GROUP_PARTICIPANT_REMOVE:
                 participants = message.messageStubParameters || [];
@@ -302,41 +249,30 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                 emitParticipantsUpdate('promote');
                 break;
             case Types_1.WAMessageStubType.GROUP_CHANGE_ANNOUNCE:
-                const announceValue = (_g = message.messageStubParameters) === null || _g === void 0 ? void 0 : _g[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 = (_h = message.messageStubParameters) === null || _h === void 0 ? void 0 : _h[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 = (_j = message.messageStubParameters) === null || _j === void 0 ? void 0 : _j[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_DESCRIPTION:
-                const description = (_k = message.messageStubParameters) === null || _k === void 0 ? void 0 : _k[0];
-                chat.description = description;
-                emitGroupUpdate({ desc: description });
-                break;
             case Types_1.WAMessageStubType.GROUP_CHANGE_INVITE_LINK:
-                const code = (_l = message.messageStubParameters) === null || _l === void 0 ? void 0 : _l[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 = (_m = message.messageStubParameters) === null || _m === void 0 ? void 0 : _m[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 = (_o = message.messageStubParameters) === null || _o === void 0 ? void 0 : _o[0];
+                const approvalMode = (_j = message.messageStubParameters) === null || _j === void 0 ? void 0 : _j[0];
                 emitGroupUpdate({ joinApprovalMode: approvalMode === 'on' });
                 break;
-            case Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD:
-                const participant = (_p = message.messageStubParameters) === null || _p === void 0 ? void 0 : _p[0];
-                const action = (_q = message.messageStubParameters) === null || _q === void 0 ? void 0 : _q[1];
-                const method = (_r = message.messageStubParameters) === null || _r === void 0 ? void 0 : _r[2];
-                emitGroupRequestJoin(participant, action, method);
-                break;
         }
     }
     else if (content === null || content === void 0 ? void 0 : content.pollUpdateMessage) {
@@ -347,7 +283,7 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             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 = (_s = pollMsg.messageContextInfo) === null || _s === void 0 ? void 0 : _s.messageSecret;
+            const pollEncKey = (_k = pollMsg.messageContextInfo) === null || _k === void 0 ? void 0 : _k.messageSecret;
             try {
                 const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
                     pollEncKey,

package/lib/Utils/signal.d.ts

@@ -1,7 +1,6 @@
 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;
@@ -16,7 +15,7 @@ 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 parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepository) => Promise<void>;
-export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, excludeZeroDevices: boolean) => JidWithDevice[];
+export declare const extractDeviceJids: (result: BinaryNode, myJid: string, excludeZeroDevices: boolean) => JidWithDevice[];
 /**
  * get the next N keys for upload or processing
  * @param count number of pre-keys to get or generate

package/lib/Utils/signal.js

@@ -1,10 +1,10 @@
 "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 lodash_1 = require("lodash");
 const Defaults_1 = require("../Defaults");
 const WABinary_1 = require("../WABinary");
 const crypto_1 = require("./crypto");
+const lodash_1 = require("lodash")
 const generics_1 = require("./generics");
 const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
@@ -59,61 +59,61 @@ const xmppPreKey = (pair, id) => ({
 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');
+        keyId: WABinary_1.getBinaryNodeChildUInt(key, 'id', 3),
+        publicKey: crypto_1.generateSignalPubKey(WABinary_1.getBinaryNodeChildBuffer(key, 'value')),
+        signature: WABinary_1.getBinaryNodeChildBuffer(key, 'signature')
+    }) : undefined)
+    const nodes = WABinary_1.getBinaryNodeChildren(WABinary_1.getBinaryNodeChild(node, 'list'), 'user')
     for (const node of nodes) {
-        (0, WABinary_1.assertNodeErrorFree)(node);
+        WABinary_1.assertNodeErrorFree(node)
     }
     // Most of the work in repository.injectE2ESession is CPU intensive, not IO
     // So Promise.all doesn't really help here,
     // but blocks even loop if we're using it inside keys.transaction, and it makes it "sync" actually
     // This way we chunk it in smaller parts and between those parts we can yield to the event loop
     // It's rare case when you need to E2E sessions for so many users, but it's possible
-    const chunkSize = 100;
-    const chunks = (0, lodash_1.chunk)(nodes, chunkSize);
+    const chunkSize = 100
+    const chunks = lodash_1.chunk(nodes, chunkSize)
     for (const nodesChunk of chunks) {
         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 = (0, WABinary_1.getBinaryNodeChildUInt)(node, 'registration', 4);
+            const signedKey = WABinary_1.getBinaryNodeChild(node, 'skey')
+            const key = WABinary_1.getBinaryNodeChild(node, 'key')
+            const identity = WABinary_1.getBinaryNodeChildBuffer(node, 'identity')
+            const jid = node.attrs.jid
+            const registrationId = WABinary_1.getBinaryNodeChildUInt(node, 'registration', 4)
             await repository.injectE2ESession({
                 jid,
                 session: {
                     registrationId: registrationId,
-                    identityKey: (0, crypto_1.generateSignalPubKey)(identity),
+                    identityKey: crypto_1.generateSignalPubKey(identity),
                     signedPreKey: extractKey(signedKey),
                     preKey: extractKey(key)
                 }
-            });
-        }));
+            })
+        }))
     }
-};
+}
 exports.parseAndInjectE2ESessions = parseAndInjectE2ESessions;
 const extractDeviceJids = (result, myJid, excludeZeroDevices) => {
-    const { user: myUser, device: myDevice } = (0, WABinary_1.jidDecode)(myJid);
-    const extracted = [];
+    const { user: myUser, device: myDevice } = WABinary_1.jidDecode(myJid)
+    const extracted = []
     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;
+        const { devices, id } = userResult
+        const { user } = WABinary_1.jidDecode(id)
+        const deviceList = 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 })
                 }
             }
         }
     }
-    return extracted;
-};
+    return extracted
+}
 exports.extractDeviceJids = extractDeviceJids;
 /**
  * get the next N keys for upload or processing

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

@@ -10,3 +10,4 @@ export declare const useMultiFileAuthState: (folder: string) => Promise<{
     state: AuthenticationState;
     saveCreds: () => Promise<void>;
 }>;
+ 

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

@@ -7,12 +7,7 @@ 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) {
@@ -29,7 +24,6 @@ const getFileLock = (path) => {
  * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
  * */
 const useMultiFileAuthState = async (folder) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const writeData = async (data, file) => {
         const filePath = (0, path_1.join)(folder, fixFileName(file));
         const mutex = getFileLock(filePath);

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

@@ -1,10 +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">) => {
+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<ArrayBufferLike>;
+}; 
+export declare const encodeSignedDeviceIdentity: (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => Uint8Array;