@d0v3riz/baileys 6.7.8 → 6.7.12

package/lib/Defaults/baileys-version.json

@@ -1,3 +1,3 @@
 {
-    "version": [2, 3000, 1015901307]
+    "version": [2, 3000, 1019707846]
 }

package/lib/Defaults/index.js

@@ -59,6 +59,7 @@ exports.DEFAULT_CONNECTION_CONFIG = {
         patch: false,
         snapshot: false,
     },
+    countryCode: 'US',
     getMessage: async () => undefined,
     cachedGroupMetadata: async () => undefined,
     makeSignalRepository: libsignal_1.makeLibSignalRepository

package/lib/Socket/business.d.ts

@@ -18,7 +18,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         deleted: number;
     }>;
     productUpdate: (productId: string, update: ProductUpdate) => Promise<import("../Types").Product>;
-    sendMessageAck: ({ tag, attrs, content }: BinaryNode) => Promise<void>;
+    sendMessageAck: ({ tag, attrs, content }: BinaryNode, errorCode?: number | undefined) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAProto.IMessageKey, oldestMsgTimestamp: number | import("long").Long) => Promise<string>;
@@ -83,14 +83,12 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
     profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
-        exists: boolean;
         jid: string;
-    }[]>;
+        exists: unknown;
+    }[] | undefined>;
     fetchBlocklist: () => Promise<string[]>;
-    fetchStatus: (jid: string) => Promise<{
-        status: string | undefined;
-        setAt: Date;
-    } | undefined>;
+    fetchStatus: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
     updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
     removeProfilePicture: (jid: string) => Promise<void>;
     updateProfileStatus: (status: string) => Promise<void>;
@@ -117,6 +115,7 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         id: string;
         fromMe?: boolean | undefined;
     }[], star: boolean) => Promise<void>;
+    executeUSyncQuery: (usyncQuery: import("..").USyncQuery) => Promise<import("..").USyncQueryResult | undefined>;
     type: "md";
     ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {

package/lib/Socket/chats.d.ts

@@ -5,6 +5,7 @@ import { proto } from '../../WAProto';
 import { ChatModification, MessageUpsertType, SocketConfig, WABusinessProfile, WAMediaUpload, WAPatchCreate, WAPresence, WAPrivacyCallValue, WAPrivacyGroupAddValue, WAPrivacyOnlineValue, WAPrivacyValue, WAReadReceiptsValue } from '../Types';
 import { LabelActionBody } from '../Types/Label';
 import { BinaryNode } from '../WABinary';
+import { USyncQuery } from '../WAUSync';
 export declare const makeChatsSocket: (config: SocketConfig) => {
     processingMutex: {
         mutex<T>(code: () => T | Promise<T>): Promise<T>;
@@ -18,14 +19,12 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
     presenceSubscribe: (toJid: string, tcToken?: Buffer) => Promise<void>;
     profilePictureUrl: (jid: string, type?: 'preview' | 'image', timeoutMs?: number) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
-        exists: boolean;
         jid: string;
-    }[]>;
+        exists: unknown;
+    }[] | undefined>;
     fetchBlocklist: () => Promise<string[]>;
-    fetchStatus: (jid: string) => Promise<{
-        status: string | undefined;
-        setAt: Date;
-    } | undefined>;
+    fetchStatus: (...jids: string[]) => Promise<import("../WAUSync").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("../WAUSync").USyncQueryResultList[] | undefined>;
     updateProfilePicture: (jid: string, content: WAMediaUpload) => Promise<void>;
     removeProfilePicture: (jid: string) => Promise<void>;
     updateProfileStatus: (status: string) => Promise<void>;
@@ -52,6 +51,7 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
         id: string;
         fromMe?: boolean;
     }[], star: boolean) => Promise<void>;
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
     type: "md";
     ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {

package/lib/Socket/chats.js

@@ -13,11 +13,12 @@ const Utils_1 = require("../Utils");
 const make_mutex_1 = require("../Utils/make-mutex");
 const process_message_1 = __importDefault(require("../Utils/process-message"));
 const WABinary_1 = require("../WABinary");
-const socket_1 = require("./socket");
+const WAUSync_1 = require("../WAUSync");
+const usync_1 = require("./usync");
 const MAX_SYNC_ATTEMPTS = 2;
 const makeChatsSocket = (config) => {
     const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, } = config;
-    const sock = (0, socket_1.makeSocket)(config);
+    const sock = (0, usync_1.makeUSyncSocket)(config);
     const { ev, ws, authState, generateMessageTag, sendNode, query, onUnexpectedError, } = sock;
     let privacySettings;
     let needToFlushWithAppStateSync = false;
@@ -111,74 +112,38 @@ const makeChatsSocket = (config) => {
                 }]
         });
     };
-    /** helper function to run a generic IQ query */
-    const interactiveQuery = async (userNodes, queryNode) => {
-        const result = await query({
-            tag: 'iq',
-            attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
-                type: 'get',
-                xmlns: 'usync',
-            },
-            content: [
-                {
-                    tag: 'usync',
-                    attrs: {
-                        sid: generateMessageTag(),
-                        mode: 'query',
-                        last: 'true',
-                        index: '0',
-                        context: 'interactive',
-                    },
-                    content: [
-                        {
-                            tag: 'query',
-                            attrs: {},
-                            content: [queryNode]
-                        },
-                        {
-                            tag: 'list',
-                            attrs: {},
-                            content: userNodes
-                        }
-                    ]
-                }
-            ],
-        });
-        const usyncNode = (0, WABinary_1.getBinaryNodeChild)(result, 'usync');
-        const listNode = (0, WABinary_1.getBinaryNodeChild)(usyncNode, 'list');
-        const users = (0, WABinary_1.getBinaryNodeChildren)(listNode, 'user');
-        return users;
-    };
     const onWhatsApp = async (...jids) => {
-        const query = { tag: 'contact', attrs: {} };
-        const list = jids.map((jid) => {
-            // insures only 1 + is there
-            const content = `+${jid.replace('+', '')}`;
-            return {
-                tag: 'user',
-                attrs: {},
-                content: [{
-                        tag: 'contact',
-                        attrs: {},
-                        content,
-                    }],
-            };
-        });
-        const results = await interactiveQuery(list, query);
-        return results.map(user => {
-            const contact = (0, WABinary_1.getBinaryNodeChild)(user, 'contact');
-            return { exists: (contact === null || contact === void 0 ? void 0 : contact.attrs.type) === 'in', jid: user.attrs.jid };
-        }).filter(item => item.exists);
-    };
-    const fetchStatus = async (jid) => {
-        const [result] = await interactiveQuery([{ tag: 'user', attrs: { jid } }], { tag: 'status', attrs: {} });
+        const usyncQuery = new WAUSync_1.USyncQuery()
+            .withContactProtocol();
+        for (const jid of jids) {
+            const phone = `+${jid.replace('+', '').split('@')[0].split(':')[0]}`;
+            usyncQuery.withUser(new WAUSync_1.USyncUser().withPhone(phone));
+        }
+        const results = await sock.executeUSyncQuery(usyncQuery);
+        if (results) {
+            return results.list.filter((a) => !!a.contact).map(({ contact, id }) => ({ jid: id, exists: contact }));
+        }
+    };
+    const fetchStatus = async (...jids) => {
+        const usyncQuery = new WAUSync_1.USyncQuery()
+            .withStatusProtocol();
+        for (const jid of jids) {
+            usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid));
+        }
+        const result = await sock.executeUSyncQuery(usyncQuery);
         if (result) {
-            const status = (0, WABinary_1.getBinaryNodeChild)(result, 'status');
-            return {
-                status: status === null || status === void 0 ? void 0 : status.content.toString(),
-                setAt: new Date(+((status === null || status === void 0 ? void 0 : status.attrs.t) || 0) * 1000)
-            };
+            return result.list;
+        }
+    };
+    const fetchDisappearingDuration = async (...jids) => {
+        const usyncQuery = new WAUSync_1.USyncQuery()
+            .withDisappearingModeProtocol();
+        for (const jid of jids) {
+            usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid));
+        }
+        const result = await sock.executeUSyncQuery(usyncQuery);
+        if (result) {
+            return result.list;
         }
     };
     /** update the profile picture for yourself or a group */
@@ -852,6 +817,7 @@ const makeChatsSocket = (config) => {
         onWhatsApp,
         fetchBlocklist,
         fetchStatus,
+        fetchDisappearingDuration,
         updateProfilePicture,
         removeProfilePicture,
         updateProfileStatus,

package/lib/Socket/groups.d.ts

@@ -57,14 +57,12 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
     profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
-        exists: boolean;
         jid: string;
-    }[]>;
+        exists: unknown;
+    }[] | undefined>;
     fetchBlocklist: () => Promise<string[]>;
-    fetchStatus: (jid: string) => Promise<{
-        status: string | undefined;
-        setAt: Date;
-    } | undefined>;
+    fetchStatus: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
     updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
     removeProfilePicture: (jid: string) => Promise<void>;
     updateProfileStatus: (status: string) => Promise<void>;
@@ -91,6 +89,7 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
         id: string;
         fromMe?: boolean | undefined;
     }[], star: boolean) => Promise<void>;
+    executeUSyncQuery: (usyncQuery: import("..").USyncQuery) => Promise<import("..").USyncQueryResult | undefined>;
     type: "md";
     ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {

package/lib/Socket/index.d.ts

@@ -17,7 +17,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
         deleted: number;
     }>;
     productUpdate: (productId: string, update: import("../Types").ProductUpdate) => Promise<import("../Types").Product>;
-    sendMessageAck: ({ tag, attrs, content }: import("..").BinaryNode) => Promise<void>;
+    sendMessageAck: ({ tag, attrs, content }: import("..").BinaryNode, errorCode?: number | undefined) => Promise<void>;
     sendRetryRequest: (node: import("..").BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAProto.IMessageKey, oldestMsgTimestamp: number | import("long").Long) => Promise<string>;
@@ -82,14 +82,12 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
     profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
-        exists: boolean;
         jid: string;
-    }[]>;
+        exists: unknown;
+    }[] | undefined>;
     fetchBlocklist: () => Promise<string[]>;
-    fetchStatus: (jid: string) => Promise<{
-        status: string | undefined;
-        setAt: Date;
-    } | undefined>;
+    fetchStatus: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
     updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
     removeProfilePicture: (jid: string) => Promise<void>;
     updateProfileStatus: (status: string) => Promise<void>;
@@ -116,6 +114,7 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
         id: string;
         fromMe?: boolean | undefined;
     }[], star: boolean) => Promise<void>;
+    executeUSyncQuery: (usyncQuery: import("..").USyncQuery) => Promise<import("..").USyncQueryResult | undefined>;
     type: "md";
     ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {

package/lib/Socket/messages-recv.d.ts

@@ -5,7 +5,7 @@ import { proto } from '../../WAProto';
 import { MessageReceiptType, MessageRelayOptions, SocketConfig, WAMessageKey } from '../Types';
 import { BinaryNode } from '../WABinary';
 export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
-    sendMessageAck: ({ tag, attrs, content }: BinaryNode) => Promise<void>;
+    sendMessageAck: ({ tag, attrs, content }: BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     fetchMessageHistory: (count: number, oldestMsgKey: WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
@@ -70,14 +70,12 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
     profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
-        exists: boolean;
         jid: string;
-    }[]>;
+        exists: unknown;
+    }[] | undefined>;
     fetchBlocklist: () => Promise<string[]>;
-    fetchStatus: (jid: string) => Promise<{
-        status: string | undefined;
-        setAt: Date;
-    } | undefined>;
+    fetchStatus: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>;
     updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
     removeProfilePicture: (jid: string) => Promise<void>;
     updateProfileStatus: (status: string) => Promise<void>;
@@ -104,6 +102,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
         id: string;
         fromMe?: boolean | undefined;
     }[], star: boolean) => Promise<void>;
+    executeUSyncQuery: (usyncQuery: import("..").USyncQuery) => Promise<import("..").USyncQueryResult | undefined>;
     type: "md";
     ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {

package/lib/Socket/messages-recv.js

@@ -35,22 +35,25 @@ const makeMessagesRecvSocket = (config) => {
         useClones: false
     });
     let sendActiveReceipts = false;
-    const sendMessageAck = async ({ tag, attrs, content }) => {
+    const sendMessageAck = async ({ tag, attrs, content }, errorCode) => {
         const stanza = {
             tag: 'ack',
             attrs: {
                 id: attrs.id,
                 to: attrs.from,
-                class: tag,
+                class: tag
             }
         };
+        if (!!errorCode) {
+            stanza.attrs.error = errorCode.toString();
+        }
         if (!!attrs.participant) {
             stanza.attrs.participant = attrs.participant;
         }
         if (!!attrs.recipient) {
             stanza.attrs.recipient = attrs.recipient;
         }
-        if (!!attrs.type && (tag !== 'message' || (0, WABinary_1.getBinaryNodeChild)({ tag, attrs, content }, 'unavailable'))) {
+        if (!!attrs.type && (tag !== 'message' || (0, WABinary_1.getBinaryNodeChild)({ tag, attrs, content }, 'unavailable') || errorCode !== 0)) {
             stanza.attrs.type = attrs.type;
         }
         if (tag === 'message' && (0, WABinary_1.getBinaryNodeChild)({ tag, attrs, content }, 'unavailable')) {
@@ -626,9 +629,13 @@ const makeMessagesRecvSocket = (config) => {
         try {
             await Promise.all([
                 processingMutex.mutex(async () => {
+                    var _a;
                     await decrypt();
                     // message failed to decrypt
                     if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
+                        if (((_a = msg === null || msg === void 0 ? void 0 : msg.messageStubParameters) === null || _a === void 0 ? void 0 : _a[0]) === Utils_1.MISSING_KEYS_ERROR_TEXT) {
+                            return sendMessageAck(node, Utils_1.NACK_REASONS.ParsingError);
+                        }
                         retryMutex.mutex(async () => {
                             if (ws.isOpen) {
                                 if ((0, WABinary_1.getBinaryNodeChild)(node, 'unavailable')) {
@@ -671,12 +678,13 @@ const makeMessagesRecvSocket = (config) => {
                         }
                     }
                     (0, Utils_2.cleanMessage)(msg, authState.creds.me.id);
+                    await sendMessageAck(node);
                     await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
                 })
             ]);
         }
-        finally {
-            await sendMessageAck(node);
+        catch (error) {
+            logger.error({ error, node }, 'error in handling message');
         }
     };
     const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
@@ -762,19 +770,19 @@ const makeMessagesRecvSocket = (config) => {
     };
     const handleBadAck = async ({ attrs }) => {
         const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id };
-        // current hypothesis is that if pash is sent in the ack
-        // it means -- the message hasn't reached all devices yet
-        // we'll retry sending the message here
-        if (attrs.phash) {
-            logger.info({ attrs }, 'received phash in ack, resending message...');
-            const msg = await getMessage(key);
-            if (msg) {
-                await relayMessage(key.remoteJid, msg, { messageId: key.id, useUserDevicesCache: false });
-            }
-            else {
-                logger.warn({ attrs }, 'could not send message again, as it was not found');
-            }
-        }
+        // WARNING: REFRAIN FROM ENABLING THIS FOR NOW. IT WILL CAUSE A LOOP
+        // // current hypothesis is that if pash is sent in the ack
+        // // it means -- the message hasn't reached all devices yet
+        // // we'll retry sending the message here
+        // if(attrs.phash) {
+        // 	logger.info({ attrs }, 'received phash in ack, resending message...')
+        // 	const msg = await getMessage(key)
+        // 	if(msg) {
+        // 		await relayMessage(key.remoteJid!, msg, { messageId: key.id!, useUserDevicesCache: false })
+        // 	} else {
+        // 		logger.warn({ attrs }, 'could not send message again, as it was not found')
+        // 	}
+        // }
         // error in acknowledgement,
         // device could not display the message
         if (attrs.error) {
@@ -799,22 +807,63 @@ const makeMessagesRecvSocket = (config) => {
         await execTask();
         ev.flush();
         function execTask() {
-            return exec(node)
+            return exec(node, false)
                 .catch(err => onUnexpectedError(err, identifier));
         }
     };
+    const makeOfflineNodeProcessor = () => {
+        const nodeProcessorMap = new Map([
+            ['message', handleMessage],
+            ['call', handleCall],
+            ['receipt', handleReceipt],
+            ['notification', handleNotification]
+        ]);
+        const nodes = [];
+        let isProcessing = false;
+        const enqueue = (type, node) => {
+            nodes.push({ type, node });
+            if (isProcessing) {
+                return;
+            }
+            isProcessing = true;
+            const promise = async () => {
+                while (nodes.length && ws.isOpen) {
+                    const { type, node } = nodes.shift();
+                    const nodeProcessor = nodeProcessorMap.get(type);
+                    if (!nodeProcessor) {
+                        onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');
+                        continue;
+                    }
+                    await nodeProcessor(node);
+                }
+                isProcessing = false;
+            };
+            promise().catch(error => onUnexpectedError(error, 'processing offline nodes'));
+        };
+        return { enqueue };
+    };
+    const offlineNodeProcessor = makeOfflineNodeProcessor();
+    const processNode = (type, node, identifier, exec) => {
+        const isOffline = !!node.attrs.offline;
+        if (isOffline) {
+            offlineNodeProcessor.enqueue(type, node);
+        }
+        else {
+            processNodeWithBuffer(node, identifier, exec);
+        }
+    };
     // recv a message
     ws.on('CB:message', (node) => {
-        processNodeWithBuffer(node, 'processing message', handleMessage);
+        processNode('message', node, 'processing message', handleMessage);
     });
     ws.on('CB:call', async (node) => {
-        processNodeWithBuffer(node, 'handling call', handleCall);
+        processNode('call', node, 'handling call', handleCall);
     });
     ws.on('CB:receipt', node => {
-        processNodeWithBuffer(node, 'handling receipt', handleReceipt);
+        processNode('receipt', node, 'handling receipt', handleReceipt);
     });
     ws.on('CB:notification', async (node) => {
-        processNodeWithBuffer(node, 'handling notification', handleNotification);
+        processNode('notification', node, 'handling notification', handleNotification);
     });
     ws.on('CB:ack,class:message', (node) => {
         handleBadAck(node)

package/lib/Socket/messages-send.d.ts

@@ -4,6 +4,7 @@ import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto';
 import { AnyMessageContent, MediaConnInfo, MessageReceiptType, MessageRelayOptions, MiscMessageGenerationOptions, SocketConfig, WAMessageKey } from '../Types';
 import { BinaryNode, JidWithDevice } from '../WABinary';
+import { USyncQuery } from '../WAUSync';
 export declare const makeMessagesSocket: (config: SocketConfig) => {
     getPrivacyTokens: (jids: string[]) => Promise<BinaryNode>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
@@ -63,14 +64,12 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
     profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
     onWhatsApp: (...jids: string[]) => Promise<{
-        exists: boolean;
         jid: string;
-    }[]>;
+        exists: unknown;
+    }[] | undefined>;
     fetchBlocklist: () => Promise<string[]>;
-    fetchStatus: (jid: string) => Promise<{
-        status: string | undefined;
-        setAt: Date;
-    } | undefined>;
+    fetchStatus: (...jids: string[]) => Promise<import("../WAUSync").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("../WAUSync").USyncQueryResultList[] | undefined>;
     updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
     removeProfilePicture: (jid: string) => Promise<void>;
     updateProfileStatus: (status: string) => Promise<void>;
@@ -97,6 +96,7 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
         id: string;
         fromMe?: boolean | undefined;
     }[], star: boolean) => Promise<void>;
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
     type: "md";
     ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {

package/lib/Socket/messages-send.js

@@ -11,11 +11,12 @@ const Defaults_1 = require("../Defaults");
 const Utils_1 = require("../Utils");
 const link_preview_1 = require("../Utils/link-preview");
 const WABinary_1 = require("../WABinary");
+const WAUSync_1 = require("../WAUSync");
 const groups_1 = require("./groups");
 const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: axiosOptions, patchMessageBeforeSending, cachedGroupMetadata, } = config;
     const sock = (0, groups_1.makeGroupsSocket)(config);
-    const { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, generateMessageTag, sendNode, groupMetadata, groupToggleEphemeral, } = sock;
+    const { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, } = sock;
     const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES,
         useClones: false
@@ -115,66 +116,46 @@ const makeMessagesSocket = (config) => {
         if (!useCache) {
             logger.debug('not using cache for devices');
         }
-        const users = [];
+        const toFetch = [];
         jids = Array.from(new Set(jids));
         for (let jid of jids) {
             const user = (_a = (0, WABinary_1.jidDecode)(jid)) === null || _a === void 0 ? void 0 : _a.user;
             jid = (0, WABinary_1.jidNormalizedUser)(jid);
-            const devices = userDevicesCache.get(user);
-            if (devices && useCache) {
-                deviceResults.push(...devices);
-                logger.trace({ user }, 'using cache for devices');
+            if (useCache) {
+                const devices = userDevicesCache.get(user);
+                if (devices) {
+                    deviceResults.push(...devices);
+                    logger.trace({ user }, 'using cache for devices');
+                }
+                else {
+                    toFetch.push(jid);
+                }
             }
             else {
-                users.push({ tag: 'user', attrs: { jid } });
+                toFetch.push(jid);
             }
         }
-        if (!users.length) {
+        if (!toFetch.length) {
             return deviceResults;
         }
-        const iq = {
-            tag: 'iq',
-            attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
-                type: 'get',
-                xmlns: 'usync',
-            },
-            content: [
-                {
-                    tag: 'usync',
-                    attrs: {
-                        sid: generateMessageTag(),
-                        mode: 'query',
-                        last: 'true',
-                        index: '0',
-                        context: 'message',
-                    },
-                    content: [
-                        {
-                            tag: 'query',
-                            attrs: {},
-                            content: [
-                                {
-                                    tag: 'devices',
-                                    attrs: { version: '2' }
-                                }
-                            ]
-                        },
-                        { tag: 'list', attrs: {}, content: users }
-                    ]
-                },
-            ],
-        };
-        const result = await query(iq);
-        const extracted = (0, Utils_1.extractDeviceJids)(result, authState.creds.me.id, ignoreZeroDevices);
-        const deviceMap = {};
-        for (const item of extracted) {
-            deviceMap[item.user] = deviceMap[item.user] || [];
-            deviceMap[item.user].push(item);
-            deviceResults.push(item);
-        }
-        for (const key in deviceMap) {
-            userDevicesCache.set(key, deviceMap[key]);
+        const query = new WAUSync_1.USyncQuery()
+            .withContext('message')
+            .withDeviceProtocol();
+        for (const jid of toFetch) {
+            query.withUser(new WAUSync_1.USyncUser().withId(jid));
+        }
+        const result = await sock.executeUSyncQuery(query);
+        if (result) {
+            const extracted = (0, Utils_1.extractDeviceJids)(result === null || result === void 0 ? void 0 : result.list, authState.creds.me.id, ignoreZeroDevices);
+            const deviceMap = {};
+            for (const item of extracted) {
+                deviceMap[item.user] = deviceMap[item.user] || [];
+                deviceMap[item.user].push(item);
+                deviceResults.push(item);
+            }
+            for (const key in deviceMap) {
+                userDevicesCache.set(key, deviceMap[key]);
+            }
         }
         return deviceResults;
     };

package/lib/Socket/socket.js

@@ -526,6 +526,14 @@ const makeSocket = (config) => {
     ws.on('CB:ib,,downgrade_webclient', () => {
         end(new boom_1.Boom('Multi-device beta not joined', { statusCode: Types_1.DisconnectReason.multideviceMismatch }));
     });
+    ws.on('CB:ib,,offline_preview', (node) => {
+        logger.info('offline preview received', node);
+        sendNode({
+            tag: 'ib',
+            attrs: {},
+            content: [{ tag: 'offline_batch', attrs: { count: '100' } }]
+        });
+    });
     ws.on('CB:ib,,edge_routing', (node) => {
         const edgeRoutingNode = (0, WABinary_1.getBinaryNodeChild)(node, 'edge_routing');
         const routingInfo = (0, WABinary_1.getBinaryNodeChild)(edgeRoutingNode, 'routing_info');