@d0v3riz/baileys 6.7.7 → 6.7.8

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto';
 import { MessageReceiptType, MessageRelayOptions, SocketConfig, WAMessageKey } from '../Types';
@@ -8,7 +9,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     fetchMessageHistory: (count: number, oldestMsgKey: WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
-    requestPlaceholderResend: (messageKey: WAMessageKey) => Promise<'RESOLVED' | string | undefined>;
+    requestPlaceholderResend: (messageKey: WAMessageKey) => Promise<string | undefined>;
     getPrivacyTokens: (jids: string[]) => Promise<BinaryNode>;
     assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
     relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }: MessageRelayOptions) => Promise<string>;
@@ -94,6 +95,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
     chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
     cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => Promise<void>;
+    addLabel: (jid: string, labels: import("../Types/Label").LabelActionBody) => Promise<void>;
     addChatLabel: (jid: string, labelId: string) => Promise<void>;
     removeChatLabel: (jid: string, labelId: string) => Promise<void>;
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
@@ -103,7 +105,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
         fromMe?: boolean | undefined;
     }[], star: boolean) => Promise<void>;
     type: "md";
-    ws: any;
+    ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;

package/lib/Socket/messages-recv.js

@@ -460,8 +460,7 @@ const makeMessagesRecvSocket = (config) => {
             await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } });
         }
         logger.debug({ participant, sendToAll }, 'forced new session for retry recp');
-        for (let i = 0; i < msgs.length; i++) {
-            const msg = msgs[i];
+        for (const [i, msg] of msgs.entries()) {
             if (msg) {
                 updateSendMessageAgainCount(ids[i], participant);
                 const msgRelayOpts = { messageId: ids[i] };
@@ -504,59 +503,63 @@ const makeMessagesRecvSocket = (config) => {
             const items = (0, WABinary_1.getBinaryNodeChildren)(content[0], 'item');
             ids.push(...items.map(i => i.attrs.id));
         }
-        await Promise.all([
-            processingMutex.mutex(async () => {
-                const status = (0, Utils_1.getStatusFromReceiptType)(attrs.type);
-                if (typeof status !== 'undefined' &&
-                    (
-                    // basically, we only want to know when a message from us has been delivered to/read by the other person
-                    // or another device of ours has read some messages
-                    status > WAProto_1.proto.WebMessageInfo.Status.DELIVERY_ACK ||
-                        !isNodeFromMe)) {
-                    if ((0, WABinary_1.isJidGroup)(remoteJid) || (0, WABinary_1.isJidStatusBroadcast)(remoteJid)) {
-                        if (attrs.participant) {
-                            const updateKey = status === WAProto_1.proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp';
-                            ev.emit('message-receipt.update', ids.map(id => ({
+        try {
+            await Promise.all([
+                processingMutex.mutex(async () => {
+                    const status = (0, Utils_1.getStatusFromReceiptType)(attrs.type);
+                    if (typeof status !== 'undefined' &&
+                        (
+                        // basically, we only want to know when a message from us has been delivered to/read by the other person
+                        // or another device of ours has read some messages
+                        status > WAProto_1.proto.WebMessageInfo.Status.DELIVERY_ACK ||
+                            !isNodeFromMe)) {
+                        if ((0, WABinary_1.isJidGroup)(remoteJid) || (0, WABinary_1.isJidStatusBroadcast)(remoteJid)) {
+                            if (attrs.participant) {
+                                const updateKey = status === WAProto_1.proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp';
+                                ev.emit('message-receipt.update', ids.map(id => ({
+                                    key: { ...key, id },
+                                    receipt: {
+                                        userJid: (0, WABinary_1.jidNormalizedUser)(attrs.participant),
+                                        [updateKey]: +attrs.t
+                                    }
+                                })));
+                            }
+                        }
+                        else {
+                            ev.emit('messages.update', ids.map(id => ({
                                 key: { ...key, id },
-                                receipt: {
-                                    userJid: (0, WABinary_1.jidNormalizedUser)(attrs.participant),
-                                    [updateKey]: +attrs.t
-                                }
+                                update: { status }
                             })));
                         }
                     }
-                    else {
-                        ev.emit('messages.update', ids.map(id => ({
-                            key: { ...key, id },
-                            update: { status }
-                        })));
-                    }
-                }
-                if (attrs.type === 'retry') {
-                    // correctly set who is asking for the retry
-                    key.participant = key.participant || attrs.from;
-                    const retryNode = (0, WABinary_1.getBinaryNodeChild)(node, 'retry');
-                    if (willSendMessageAgain(ids[0], key.participant)) {
-                        if (key.fromMe) {
-                            try {
-                                logger.debug({ attrs, key }, 'recv retry request');
-                                await sendMessagesAgain(key, ids, retryNode);
+                    if (attrs.type === 'retry') {
+                        // correctly set who is asking for the retry
+                        key.participant = key.participant || attrs.from;
+                        const retryNode = (0, WABinary_1.getBinaryNodeChild)(node, 'retry');
+                        if (willSendMessageAgain(ids[0], key.participant)) {
+                            if (key.fromMe) {
+                                try {
+                                    logger.debug({ attrs, key }, 'recv retry request');
+                                    await sendMessagesAgain(key, ids, retryNode);
+                                }
+                                catch (error) {
+                                    logger.error({ key, ids, trace: error.stack }, 'error in sending message again');
+                                }
                             }
-                            catch (error) {
-                                logger.error({ key, ids, trace: error.stack }, 'error in sending message again');
+                            else {
+                                logger.info({ attrs, key }, 'recv retry for not fromMe message');
                             }
                         }
                         else {
-                            logger.info({ attrs, key }, 'recv retry for not fromMe message');
+                            logger.info({ attrs, key }, 'will not send message again, as sent too many times');
                         }
                     }
-                    else {
-                        logger.info({ attrs, key }, 'will not send message again, as sent too many times');
-                    }
-                }
-            }),
-            sendMessageAck(node)
-        ]);
+                })
+            ]);
+        }
+        finally {
+            await sendMessageAck(node);
+        }
     };
     const handleNotification = async (node) => {
         const remoteJid = node.attrs.from;
@@ -565,27 +568,31 @@ const makeMessagesRecvSocket = (config) => {
             await sendMessageAck(node);
             return;
         }
-        await Promise.all([
-            processingMutex.mutex(async () => {
-                var _a;
-                const msg = await processNotification(node);
-                if (msg) {
-                    const fromMe = (0, WABinary_1.areJidsSameUser)(node.attrs.participant || remoteJid, authState.creds.me.id);
-                    msg.key = {
-                        remoteJid,
-                        fromMe,
-                        participant: node.attrs.participant,
-                        id: node.attrs.id,
-                        ...(msg.key || {})
-                    };
-                    (_a = msg.participant) !== null && _a !== void 0 ? _a : (msg.participant = node.attrs.participant);
-                    msg.messageTimestamp = +node.attrs.t;
-                    const fullMsg = WAProto_1.proto.WebMessageInfo.fromObject(msg);
-                    await upsertMessage(fullMsg, 'append');
-                }
-            }),
-            sendMessageAck(node)
-        ]);
+        try {
+            await Promise.all([
+                processingMutex.mutex(async () => {
+                    var _a;
+                    const msg = await processNotification(node);
+                    if (msg) {
+                        const fromMe = (0, WABinary_1.areJidsSameUser)(node.attrs.participant || remoteJid, authState.creds.me.id);
+                        msg.key = {
+                            remoteJid,
+                            fromMe,
+                            participant: node.attrs.participant,
+                            id: node.attrs.id,
+                            ...(msg.key || {})
+                        };
+                        (_a = msg.participant) !== null && _a !== void 0 ? _a : (msg.participant = node.attrs.participant);
+                        msg.messageTimestamp = +node.attrs.t;
+                        const fullMsg = WAProto_1.proto.WebMessageInfo.fromObject(msg);
+                        await upsertMessage(fullMsg, 'append');
+                    }
+                })
+            ]);
+        }
+        finally {
+            await sendMessageAck(node);
+        }
     };
     const handleMessage = async (node) => {
         var _a, _b, _c;
@@ -613,62 +620,64 @@ const makeMessagesRecvSocket = (config) => {
         if (response && ((_a = msg === null || msg === void 0 ? void 0 : msg.messageStubParameters) === null || _a === void 0 ? void 0 : _a[0]) === Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT) {
             msg.messageStubParameters = [Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT, response];
         }
-        if (((_c = (_b = msg.message) === null || _b === void 0 ? void 0 : _b.protocolMessage) === null || _c === void 0 ? void 0 : _c.type) === WAProto_1.proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER) {
-            if (node.attrs.sender_pn) {
-                ev.emit('chats.phoneNumberShare', { lid: node.attrs.from, jid: node.attrs.sender_pn });
-            }
-        }
-        await Promise.all([
-            processingMutex.mutex(async () => {
-                await decrypt();
-                // message failed to decrypt
-                if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
-                    retryMutex.mutex(async () => {
-                        if (ws.isOpen) {
-                            if ((0, WABinary_1.getBinaryNodeChild)(node, 'unavailable')) {
-                                return;
+        if (((_c = (_b = msg.message) === null || _b === void 0 ? void 0 : _b.protocolMessage) === null || _c === void 0 ? void 0 : _c.type) === WAProto_1.proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER && node.attrs.sender_pn) {
+            ev.emit('chats.phoneNumberShare', { lid: node.attrs.from, jid: node.attrs.sender_pn });
+        }
+        try {
+            await Promise.all([
+                processingMutex.mutex(async () => {
+                    await decrypt();
+                    // message failed to decrypt
+                    if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
+                        retryMutex.mutex(async () => {
+                            if (ws.isOpen) {
+                                if ((0, WABinary_1.getBinaryNodeChild)(node, 'unavailable')) {
+                                    return;
+                                }
+                                const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc');
+                                await sendRetryRequest(node, !encNode);
+                                if (retryRequestDelayMs) {
+                                    await (0, Utils_1.delay)(retryRequestDelayMs);
+                                }
                             }
-                            const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc');
-                            await sendRetryRequest(node, !encNode);
-                            if (retryRequestDelayMs) {
-                                await (0, Utils_1.delay)(retryRequestDelayMs);
+                            else {
+                                logger.debug({ node }, 'connection closed, ignoring retry req');
                             }
+                        });
+                    }
+                    else {
+                        // no type in the receipt => message delivered
+                        let type = undefined;
+                        let participant = msg.key.participant;
+                        if (category === 'peer') { // special peer message
+                            type = 'peer_msg';
                         }
-                        else {
-                            logger.debug({ node }, 'connection closed, ignoring retry req');
+                        else if (msg.key.fromMe) { // message was sent by us from a different device
+                            type = 'sender';
+                            // need to specially handle this case
+                            if ((0, WABinary_1.isJidUser)(msg.key.remoteJid)) {
+                                participant = author;
+                            }
                         }
-                    });
-                }
-                else {
-                    // no type in the receipt => message delivered
-                    let type = undefined;
-                    let participant = msg.key.participant;
-                    if (category === 'peer') { // special peer message
-                        type = 'peer_msg';
-                    }
-                    else if (msg.key.fromMe) { // message was sent by us from a different device
-                        type = 'sender';
-                        // need to specially handle this case
-                        if ((0, WABinary_1.isJidUser)(msg.key.remoteJid)) {
-                            participant = author;
+                        else if (!sendActiveReceipts) {
+                            type = 'inactive';
+                        }
+                        await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type);
+                        // send ack for history message
+                        const isAnyHistoryMsg = (0, Utils_1.getHistoryMsg)(msg.message);
+                        if (isAnyHistoryMsg) {
+                            const jid = (0, WABinary_1.jidNormalizedUser)(msg.key.remoteJid);
+                            await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
                         }
                     }
-                    else if (!sendActiveReceipts) {
-                        type = 'inactive';
-                    }
-                    await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type);
-                    // send ack for history message
-                    const isAnyHistoryMsg = (0, Utils_1.getHistoryMsg)(msg.message);
-                    if (isAnyHistoryMsg) {
-                        const jid = (0, WABinary_1.jidNormalizedUser)(msg.key.remoteJid);
-                        await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
-                    }
-                }
-                (0, Utils_2.cleanMessage)(msg, authState.creds.me.id);
-                await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
-            }),
-            sendMessageAck(node)
-        ]);
+                    (0, Utils_2.cleanMessage)(msg, authState.creds.me.id);
+                    await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
+                })
+            ]);
+        }
+        finally {
+            await sendMessageAck(node);
+        }
     };
     const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
         var _a;
@@ -745,7 +754,7 @@ const makeMessagesRecvSocket = (config) => {
             call.isGroup = existingCall.isGroup;
         }
         // delete data once call has ended
-        if (status === 'reject' || status === 'accept' || status === 'timeout') {
+        if (status === 'reject' || status === 'accept' || status === 'timeout' || status === 'terminate') {
             callOfferCache.del(call.id);
         }
         ev.emit('call', [call]);

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto';
 import { AnyMessageContent, MediaConnInfo, MessageReceiptType, MessageRelayOptions, MiscMessageGenerationOptions, SocketConfig, WAMessageKey } from '../Types';
@@ -87,6 +88,7 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
     chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
     cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => Promise<void>;
+    addLabel: (jid: string, labels: import("../Types/Label").LabelActionBody) => Promise<void>;
     addChatLabel: (jid: string, labelId: string) => Promise<void>;
     removeChatLabel: (jid: string, labelId: string) => Promise<void>;
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
@@ -96,7 +98,7 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
         fromMe?: boolean | undefined;
     }[], star: boolean) => Promise<void>;
     type: "md";
-    ws: any;
+    ws: import("./Client").WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;

package/lib/Socket/messages-send.js

@@ -380,14 +380,13 @@ const makeMessagesSocket = (config) => {
                 await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
             }
             else {
-                const { user: meUser, device: meDevice } = (0, WABinary_1.jidDecode)(meId);
+                const { user: meUser } = (0, WABinary_1.jidDecode)(meId);
                 if (!participant) {
                     devices.push({ user });
-                    // do not send message to self if the device is 0 (mobile)
-                    if (!((additionalAttributes === null || additionalAttributes === void 0 ? void 0 : additionalAttributes['category']) === 'peer' && user === meUser)) {
-                        if (meDevice !== undefined && meDevice !== 0) {
-                            devices.push({ user: meUser });
-                        }
+                    if (user !== meUser) {
+                        devices.push({ user: meUser });
+                    }
+                    if ((additionalAttributes === null || additionalAttributes === void 0 ? void 0 : additionalAttributes['category']) !== 'peer') {
                         const additionalDevices = await getUSyncDevices([meId, jid], !!useUserDevicesCache, true);
                         devices.push(...additionalDevices);
                     }
@@ -434,7 +433,7 @@ const makeMessagesSocket = (config) => {
                 tag: 'message',
                 attrs: {
                     id: msgId,
-                    type: 'text',
+                    type: getMessageType(message),
                     ...(additionalAttributes || {})
                 },
                 content: binaryNodeContent
@@ -474,6 +473,12 @@ const makeMessagesSocket = (config) => {
         });
         return msgId;
     };
+    const getMessageType = (message) => {
+        if (message.pollCreationMessage || message.pollCreationMessageV2 || message.pollCreationMessageV3) {
+            return 'poll';
+        }
+        return 'text';
+    };
     const getMediaType = (message) => {
         if (message.imageMessage) {
             return 'image';
@@ -643,7 +648,9 @@ const makeMessagesSocket = (config) => {
                 const isDeleteMsg = 'delete' in content && !!content.delete;
                 const isEditMsg = 'edit' in content && !!content.edit;
                 const isPinMsg = 'pin' in content && !!content.pin;
+                const isPollMessage = 'poll' in content && !!content.poll;
                 const additionalAttributes = {};
+                const additionalNodes = [];
                 // required for delete
                 if (isDeleteMsg) {
                     // if the chat is a group, and I am not the author, then delete the message as an admin
@@ -660,10 +667,18 @@ const makeMessagesSocket = (config) => {
                 else if (isPinMsg) {
                     additionalAttributes.edit = '2';
                 }
+                else if (isPollMessage) {
+                    additionalNodes.push({
+                        tag: 'meta',
+                        attrs: {
+                            polltype: 'creation'
+                        },
+                    });
+                }
                 if ('cachedGroupMetadata' in options) {
                     console.warn('cachedGroupMetadata in sendMessage are deprecated, now cachedGroupMetadata is part of the socket config.');
                 }
-                await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, additionalAttributes, statusJidList: options.statusJidList });
+                await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, additionalAttributes, statusJidList: options.statusJidList, additionalNodes });
                 if (config.emitOwnEvents) {
                     process.nextTick(() => {
                         processingMutex.mutex(() => (upsertMessage(fullMsg, 'append')));

package/lib/Socket/socket.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Boom } from '@hapi/boom';
 import { SocketConfig } from '../Types';
 import { BinaryNode } from '../WABinary';
+import { WebSocketClient } from './Client';
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -10,7 +12,7 @@ import { BinaryNode } from '../WABinary';
  */
 export declare const makeSocket: (config: SocketConfig) => {
     type: "md";
-    ws: any;
+    ws: WebSocketClient;
     ev: import("../Types").BaileysEventEmitter & {
         process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
         buffer(): void;

package/lib/Socket/socket.js

@@ -20,15 +20,14 @@ const Client_1 = require("./Client");
 const makeSocket = (config) => {
     var _a, _b;
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository, } = config;
-    let url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
-    config.mobile = config.mobile || url.protocol === 'tcp:';
-    if (config.mobile && url.protocol !== 'tcp:') {
-        url = new url_1.URL(`tcp://${Defaults_1.MOBILE_ENDPOINT}:${Defaults_1.MOBILE_PORT}`);
+    const url = typeof waWebSocketUrl === 'string' ? new url_1.URL(waWebSocketUrl) : waWebSocketUrl;
+    if (config.mobile || url.protocol === 'tcp:') {
+        throw new boom_1.Boom('Mobile API is not supported anymore', { statusCode: Types_1.DisconnectReason.loggedOut });
     }
-    if (!config.mobile && url.protocol === 'wss' && ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.routingInfo)) {
+    if (url.protocol === 'wss' && ((_a = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _a === void 0 ? void 0 : _a.routingInfo)) {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
-    const ws = config.socket ? config.socket : config.mobile ? new Client_1.MobileSocketClient(url, config) : new Client_1.WebSocketClient(url, config);
+    const ws = new Client_1.WebSocketClient(url, config);
     ws.connect();
     const ev = (0, Utils_1.makeEventBuffer)(logger);
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
@@ -36,8 +35,7 @@ const makeSocket = (config) => {
     /** WA noise protocol wrapper */
     const noise = (0, Utils_1.makeNoiseHandler)({
         keyPair: ephemeralKeyPair,
-        NOISE_HEADER: config.mobile ? Defaults_1.MOBILE_NOISE_HEADER : Defaults_1.NOISE_WA_HEADER,
-        mobile: config.mobile,
+        NOISE_HEADER: Defaults_1.NOISE_WA_HEADER,
         logger,
         routingInfo: (_b = authState === null || authState === void 0 ? void 0 : authState.creds) === null || _b === void 0 ? void 0 : _b.routingInfo
     });
@@ -159,10 +157,7 @@ const makeSocket = (config) => {
         logger.trace({ handshake }, 'handshake recv from WA');
         const keyEnc = noise.processHandshake(handshake, creds.noiseKey);
         let node;
-        if (config.mobile) {
-            node = (0, Utils_1.generateMobileNode)(config);
-        }
-        else if (!creds.me) {
+        if (!creds.me) {
             node = (0, Utils_1.generateRegistrationNode)(creds, config);
             logger.info({ node }, 'not logged in, attempting registration...');
         }
@@ -232,11 +227,11 @@ const makeSocket = (config) => {
                 const l0 = frame.tag;
                 const l1 = frame.attrs || {};
                 const l2 = Array.isArray(frame.content) ? (_a = frame.content[0]) === null || _a === void 0 ? void 0 : _a.tag : '';
-                Object.keys(l1).forEach(key => {
+                for (const key of Object.keys(l1)) {
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]},${l2}`, frame) || anyTriggered;
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}:${l1[key]}`, frame) || anyTriggered;
                     anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},${key}`, frame) || anyTriggered;
-                });
+                }
                 anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0},,${l2}`, frame) || anyTriggered;
                 anyTriggered = ws.emit(`${Defaults_1.DEF_CALLBACK_PREFIX}${l0}`, frame) || anyTriggered;
                 if (!anyTriggered && logger.level === 'debug') {

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

@@ -1,5 +1,6 @@
+import { Store } from 'cache-manager';
 import { AuthenticationCreds } from '../Types';
-declare const makeCacheManagerAuthState: (store: Storage, sessionKey: string) => Promise<{
+declare const makeCacheManagerAuthState: (store: Store, sessionKey: string) => Promise<{
     clearState: () => Promise<void>;
     saveCreds: () => Promise<void>;
     state: {

package/lib/Store/make-in-memory-store.js

@@ -182,16 +182,14 @@ exports.default = (config) => {
                         const jid = (0, WABinary_1.jidNormalizedUser)(msg.key.remoteJid);
                         const list = assertMessageList(jid);
                         list.upsert(msg, 'append');
-                        if (type === 'notify') {
-                            if (!chats.get(jid)) {
-                                ev.emit('chats.upsert', [
-                                    {
-                                        id: jid,
-                                        conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
-                                        unreadCount: 1
-                                    }
-                                ]);
-                            }
+                        if (type === 'notify' && !chats.get(jid)) {
+                            ev.emit('chats.upsert', [
+                                {
+                                    id: jid,
+                                    conversationTimestamp: (0, Utils_1.toNumber)(msg.messageTimestamp),
+                                    unreadCount: 1
+                                }
+                            ]);
                         }
                     }
                     break;

package/lib/Store/make-ordered-dictionary.js

@@ -56,9 +56,9 @@ function makeOrderedDictionary(idGetter) {
         },
         clear: () => {
             array.splice(0, array.length);
-            Object.keys(dict).forEach(key => {
+            for (const key of Object.keys(dict)) {
                 delete dict[key];
-            });
+            }
         },
         filter: (contain) => {
             let i = 0;

package/lib/Types/Auth.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import type { proto } from '../../WAProto';
-import { RegistrationOptions } from '../Socket/registration';
 import type { Contact } from './Contact';
 import type { MinimalMessage } from './Message';
 export type KeyPair = {
@@ -57,12 +57,7 @@ export type AuthenticationCreds = SignalCreds & {
     /** number of times history & app state has been synced */
     accountSyncCounter: number;
     accountSettings: AccountSettings;
-    deviceId: string;
-    phoneId: string;
-    identityId: Buffer;
     registered: boolean;
-    backupToken: Buffer;
-    registration: RegistrationOptions;
     pairingCode: string | undefined;
     lastPropHash: string | undefined;
     routingInfo: Buffer | undefined;

package/lib/Types/Call.d.ts

@@ -1,4 +1,4 @@
-export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept';
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept' | 'terminate';
 export type WACallEvent = {
     chatId: string;
     from: string;

package/lib/Types/Chat.d.ts

@@ -1,9 +1,10 @@
 import type { proto } from '../../WAProto';
 import type { AccountSettings } from './Auth';
 import type { BufferedEventData } from './Events';
+import type { LabelActionBody } from './Label';
 import type { ChatLabelAssociationActionBody } from './LabelAssociation';
 import type { MessageLabelAssociationActionBody } from './LabelAssociation';
-import type { MinimalMessage } from './Message';
+import type { MinimalMessage, WAMessageKey } from './Message';
 /** privacy settings in WhatsApp Web */
 export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
 export type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
@@ -61,12 +62,12 @@ export type ChatModification = {
     /** mute for duration, or provide timestamp of mute to remove*/
     mute: number | null;
 } | {
-    clear: 'all' | {
-        messages: {
-            id: string;
-            fromMe?: boolean;
-            timestamp: number;
-        }[];
+    clear: boolean;
+} | {
+    deleteForMe: {
+        deleteMedia: boolean;
+        key: WAMessageKey;
+        timestamp: number;
     };
 } | {
     star: {
@@ -82,6 +83,8 @@ export type ChatModification = {
 } | {
     delete: true;
     lastMessages: LastMessageList;
+} | {
+    addLabel: LabelActionBody;
 } | {
     addChatLabel: ChatLabelAssociationActionBody;
 } | {

package/lib/Types/Contact.d.ts

@@ -14,6 +14,6 @@ export interface Contact {
      * null => if the profile picture has not been set (default profile picture)
      * any other string => url of the profile picture
      */
-    imgUrl?: string | null | 'changed';
+    imgUrl?: string | null;
     status?: string;
 }