@heavstaltech/baileys 2.3.4 → 3.2.4

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { Logger } from 'pino';
 import { proto } from '../../WAProto';
 import { KeyPair } from '../Types';
@@ -9,12 +10,12 @@ export declare const makeNoiseHandler: ({ keyPair: { private: privateKey, public
     logger: Logger;
     routingInfo?: Buffer | undefined;
 }) => {
-    encrypt: (plaintext: Uint8Array) => any;
-    decrypt: (ciphertext: Uint8Array) => any;
+    encrypt: (plaintext: Uint8Array) => Buffer;
+    decrypt: (ciphertext: Uint8Array) => Buffer;
     authenticate: (data: Uint8Array) => void;
     mixIntoKey: (data: Uint8Array) => void;
     finishInit: () => void;
-    processHandshake: ({ serverHello }: proto.HandshakeMessage, noiseKey: KeyPair) => any;
-    encodeFrame: (data: Buffer | Uint8Array) => any;
+    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

@@ -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([]);
@@ -77,17 +77,12 @@ 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);
             }
@@ -97,9 +92,9 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
                 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) => {
@@ -130,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
@@ -148,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);
@@ -157,4 +152,4 @@ const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey },
         }
     };
 };
-exports.makeNoiseHandler = makeNoiseHandler;
+exports.makeNoiseHandler = makeNoiseHandler;

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

@@ -1,14 +1,14 @@
 import { AxiosRequestConfig } from 'axios';
+import type { Logger } from 'pino';
 import { proto } from '../../WAProto';
-import { AuthenticationCreds, BaileysEventEmitter, CacheStore, SignalKeyStoreWithTransaction } 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;
-    logger?: ILogger;
+    getMessage: SocketConfig['getMessage'];
+    logger?: Logger;
     options: AxiosRequestConfig<{}>;
 };
 /** Cleans a received message to further processing */
@@ -37,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 }: 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");
@@ -102,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 }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+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)) {
@@ -138,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:
@@ -196,42 +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;
-                        //eslint-disable-next-line max-depth
                         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;
         }
     }
@@ -242,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 }));
@@ -254,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 || [];
@@ -290,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) {
@@ -335,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

@@ -4,14 +4,8 @@ exports.getNextPreKeysNode = exports.getNextPreKeys = exports.extractDeviceJids
 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");
-function chunk(array, size) {
-    const result = [];
-    for (let i = 0; i < array.length; i += size) {
-        result.push(array.slice(i, i + size));
-    }
-    return result;
-}
 const createSignalIdentity = (wid, accountSignatureKey) => {
     return {
         identifier: { name: wid, deviceId: 0 },
@@ -65,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 = 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>;
 }>;
+