@kelvdra/baileys 1.0.3 → 1.0.4

package/lib/Socket/messages-send.js

@@ -2,20 +2,17 @@ import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import * as Utils_1 from "../Utils/index.js"
 import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex } from '../Utils/make-mutex.js';
-import * as WABinary_1 from "../WABinary/index.js"
+import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidGroup, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
-import hydra from './hydra.js'
-import { randomBytes } from "crypto"
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
-    const { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
+    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
     const userDevicesCache = config.userDevicesCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
@@ -258,6 +255,31 @@ export const makeMessagesSocket = (config) => {
         }
         return deviceResults;
     };
+    /**
+     * Update Member Label
+     */
+    const updateMemberLabel = (jid, memberLabel) => {
+        return relayMessage(jid, {
+            protocolMessage: {
+                type: proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE,
+                memberLabel: {
+                    label: memberLabel?.slice(0, 30),
+                    labelTimestamp: unixTimestampSeconds()
+                }
+            }
+        }, {
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    };
     const assertSessions = async (jids, force) => {
         let didFetchNewSession = false;
         const uniqueJids = [...new Set(jids)]; // Deduplicate JIDs
@@ -358,49 +380,51 @@ export const makeMessagesSocket = (config) => {
         const meLid = authState.creds.me?.lid;
         const meLidUser = meLid ? jidDecode(meLid)?.user : null;
         const encryptionPromises = patchedMessages.map(async ({ recipientJid: jid, message: patchedMessage }) => {
-            if (!jid)
-                return null;
-            let msgToEncrypt = patchedMessage;
-            if (dsmMessage) {
-                const { user: targetUser } = jidDecode(jid);
-                const { user: ownPnUser } = jidDecode(meId);
-                const ownLidUser = meLidUser;
-                const isOwnUser = targetUser === ownPnUser || (ownLidUser && targetUser === ownLidUser);
-                const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
-                if (isOwnUser && !isExactSenderDevice) {
-                    msgToEncrypt = dsmMessage;
-                    logger.debug({ jid, targetUser }, 'Using DSM for own device');
+            try {
+                if (!jid)
+                    return null;
+                let msgToEncrypt = patchedMessage;
+                if (dsmMessage) {
+                    const { user: targetUser } = jidDecode(jid);
+                    const { user: ownPnUser } = jidDecode(meId);
+                    const ownLidUser = meLidUser;
+                    const isOwnUser = targetUser === ownPnUser || (ownLidUser && targetUser === ownLidUser);
+                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+                    if (isOwnUser && !isExactSenderDevice) {
+                        msgToEncrypt = dsmMessage;
+                        logger.debug({ jid, targetUser }, 'Using DSM for own device');
+                    }
                 }
-            }
-            const bytes = encodeWAMessage(msgToEncrypt);
-            const mutexKey = jid;
-            const node = await encryptionMutex.mutex(mutexKey, async () => {
-                const { type, ciphertext } = await signalRepository.encryptMessage({
-                    jid,
-                    data: bytes
+                const bytes = encodeWAMessage(msgToEncrypt);
+                const mutexKey = jid;
+                const node = await encryptionMutex.mutex(mutexKey, async () => {
+                    const { type, ciphertext } = await signalRepository.encryptMessage({ jid, data: bytes });
+                    if (type === 'pkmsg') {
+                        shouldIncludeDeviceIdentity = true;
+                    }
+                    return {
+                        tag: 'to',
+                        attrs: { jid },
+                        content: [
+                            {
+                                tag: 'enc',
+                                attrs: { v: '2', type, ...(extraAttrs || {}) },
+                                content: ciphertext
+                            }
+                        ]
+                    };
                 });
-                if (type === 'pkmsg') {
-                    shouldIncludeDeviceIdentity = true;
-                }
-                return {
-                    tag: 'to',
-                    attrs: { jid },
-                    content: [
-                        {
-                            tag: 'enc',
-                            attrs: {
-                                v: '2',
-                                type,
-                                ...(extraAttrs || {})
-                            },
-                            content: ciphertext
-                        }
-                    ]
-                };
-            });
-            return node;
+                return node;
+            }
+            catch (err) {
+                logger.error({ jid, err }, 'Failed to encrypt for recipient');
+                return null;
+            }
         });
         const nodes = (await Promise.all(encryptionPromises)).filter(node => node !== null);
+        if (recipientJids.length > 0 && nodes.length === 0) {
+            throw new Boom('All encryptions failed', { statusCode: 500 });
+        }
         return { nodes, shouldIncludeDeviceIdentity };
     };
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }) => {
@@ -423,8 +447,7 @@ export const makeMessagesSocket = (config) => {
         const destinationJid = !isStatus ? finalJid : statusJid;
         const binaryNodeContent = [];
         const devices = [];
-        const messages = Utils_1.normalizeMessageContent(message)
-        const buttonType = getButtonType(messages)
+        let reportingMessage;
         const meMsg = {
             deviceSentMessage: {
                 destinationJid,
@@ -471,7 +494,7 @@ export const makeMessagesSocket = (config) => {
                 await sendNode(stanza);
                 return;
             }
-            if (normalizeMessageContent(message)?.pinInChatMessage) {
+            if (normalizeMessageContent(message)?.pinInChatMessage || normalizeMessageContent(message)?.reactionMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
             }
             if (isGroupOrStatus && !isRetryResend) {
@@ -519,6 +542,7 @@ export const makeMessagesSocket = (config) => {
                     throw new Boom('Per-jid patching is not supported in groups');
                 }
                 const bytes = encodeWAMessage(patched);
+                reportingMessage = patched;
                 const groupAddressingMode = additionalAttributes?.['addressing_mode'] || groupData?.addressingMode || 'lid';
                 const groupSenderIdentity = groupAddressingMode === 'lid' && meLid ? meLid : meId;
                 const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({
@@ -573,6 +597,12 @@ export const makeMessagesSocket = (config) => {
                     logger.debug({ to: jid, ownId }, 'Using PN identity for @s.whatsapp.net conversation');
                 }
                 const { user: ownUser } = jidDecode(ownId);
+                if (!participant) {
+                    const patchedForReporting = await patchMessageBeforeSending(message, [jid]);
+                    reportingMessage = Array.isArray(patchedForReporting)
+                        ? patchedForReporting.find(item => item.recipientJid === jid) || patchedForReporting[0]
+                        : patchedForReporting;
+                }
                 if (!isRetryResend) {
                     const targetUserServer = isLid ? 'lid' : 's.whatsapp.net';
                     devices.push({
@@ -708,16 +738,6 @@ export const makeMessagesSocket = (config) => {
             else {
                 stanza.attrs.to = destinationJid;
             }
-            if (!isNewsletter && buttonType) {
-                const buttonsNode = getButtonArgs(messages)
-                const filteredButtons = WABinary_1.getBinaryFilteredButtons(additionalNodes ? additionalNodes : [])
-                if (filteredButtons) {
-                    stanza.content.push(...additionalNodes)
-                    additionalAlready = true
-                } else {
-                    stanza.content.push(buttonsNode)
-                }
-            }
             if (shouldIncludeDeviceIdentity) {
                 ;
                 stanza.content.push({
@@ -727,6 +747,29 @@ export const makeMessagesSocket = (config) => {
                 });
                 logger.debug({ jid }, 'adding device identity');
             }
+            if (!isNewsletter &&
+                !isRetryResend &&
+                reportingMessage?.messageContextInfo?.messageSecret &&
+                shouldIncludeReportingToken(reportingMessage)) {
+                try {
+                    const encoded = encodeWAMessage(reportingMessage);
+                    const reportingKey = {
+                        id: msgId,
+                        fromMe: true,
+                        remoteJid: destinationJid,
+                        participant: participant?.jid
+                    };
+                    const reportingNode = await getMessageReportingToken(encoded, reportingMessage, reportingKey);
+                    if (reportingNode) {
+                        ;
+                        stanza.content.push(reportingNode);
+                        logger.trace({ jid }, 'added reporting token to message');
+                    }
+                }
+                catch (error) {
+                    logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
+                }
+            }
             const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
             const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
             if (tcTokenBuffer) {
@@ -754,12 +797,6 @@ export const makeMessagesSocket = (config) => {
         if (message.pollCreationMessage || message.pollCreationMessageV2 || message.pollCreationMessageV3) {
             return 'poll';
         }
-        if (message.eventMessage) {
-            return 'event';
-        }
-        if (getMediaType(message) !== '') {
-            return 'media';
-        }
         return 'text';
     };
     const getMediaType = (message) => {
@@ -810,114 +847,6 @@ export const makeMessagesSocket = (config) => {
         }
         return '';
     };
-    
-    const getButtonType = (message) => {
-        if (message.listMessage) {
-            return 'list'
-        }
-        else if (message.buttonsMessage) {
-            return 'buttons'
-        }
-        else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'review_and_pay') {
-            return 'review_and_pay'
-        }
-        else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'review_order') {
-            return 'review_order'
-        }
-        else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_info') {
-            return 'payment_info'
-        }
-        else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_status') {
-            return 'payment_status'
-        }
-        else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_method') {
-            return 'payment_method'
-        }
-        else if (message.interactiveMessage && message.interactiveMessage?.nativeFlowMessage) {
-            return 'interactive'
-        }
-        else if (message.interactiveMessage?.nativeFlowMessage) {
-            return 'native_flow'
-        }
-    }
-
-    const getButtonArgs = (message) => {
-        const message_content = message.viewOnceMessage?.message || message;
-        const message_flow = message_content.interactiveMessage?.nativeFlowMessage;
-        const flow_buttons_first = message_flow?.buttons?.[0]?.name;
-        const flow_buttons_special = [ 'mpm', 'cta_catalog', 'send_location', 'call_permission_request', 'wa_payment_transaction_details', 'automated_greeting_message_view_catalog' ];
-        const baseArgs = {
-            tag: 'biz',
-            attrs: {
-                actual_actors: '2',
-                host_storage: '2',
-                privacy_mode_ts: Utils_1.unixTimestampSeconds().toString()
-            }
-        };
-        if (message_flow && (flow_buttons_first === 'review_and_pay' || flow_buttons_first === 'payment_info')) {
-            return {
-                tag: 'biz',
-                attrs: {
-                    native_flow_name: flow_buttons_first === 'review_and_pay' ? 'order_details' : flow_buttons_first
-                }
-            };
-        }
-        if (message_flow && flow_buttons_special.includes(flow_buttons_first)) {
-            return {
-                ...baseArgs,
-                content: [
-                    {
-                        tag: 'interactive',
-                        attrs: { type: 'native_flow', v: '1' },
-                        content: [{
-                            tag: 'native_flow',
-                            attrs: { v: '2', name: flow_buttons_first }
-                        }]
-                    },
-                    {
-                        tag: 'quality_control',
-                        attrs: { source_type: 'third_party' }
-                    }
-                ]
-            };
-        }
-        if (message_flow || message_content.buttonsMessage) {
-            return {
-                ...baseArgs,
-                content: [
-                    {
-                        tag: 'interactive',
-                        attrs: { type: 'native_flow', v: '1' },
-                        content: [{
-                            tag: 'native_flow',
-                            attrs: { v: '9', name: 'mixed' }
-                        }]
-                    },
-                    {
-                        tag: 'quality_control',
-                        attrs: { source_type: 'third_party' }
-                    }
-                ]
-            };
-        }
-        if (message_content.listMessage) {
-            return {
-                ...baseArgs,
-                content: [
-                    {
-                        tag: 'list',
-                        attrs: { v: '2', type: 'product_list' }
-                    },
-                    {
-                        tag: 'quality_control',
-                        attrs: { source_type: 'third_party' }
-                    }
-                ]
-            };
-        }
-        return baseArgs;
-    };
-    
     const getPrivacyTokens = async (jids) => {
         const t = unixTimestampSeconds().toString();
         const result = await query({
@@ -944,22 +873,7 @@ export const makeMessagesSocket = (config) => {
         });
         return result;
     };
-    
-    const getEphemeralGroup = (jid) => {
-        if (!WABinary_1.isJidGroup(jid)) throw new TypeError("Jid should originate from a group!")
-
-        return groupQuery(jid, 'get', [{
-                tag: 'query',
-                attrs: {
-                    request: 'interactive'
-                }
-            }])
-            .then((groups) => WABinary_1.getBinaryNodeChild(groups, 'group'))
-            .then((metadata) => WABinary_1.getBinaryNodeChild(metadata, 'ephemeral')?.attrs?.expiration || 0)
-    }
-    
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
-    const kelvdra = new hydra(Utils_1, waUploadToServer, relayMessage)
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
     return {
         ...sock,
@@ -971,17 +885,17 @@ export const makeMessagesSocket = (config) => {
         readMessages,
         refreshMediaConn,
         waUploadToServer,
-        kelvdra,
         fetchPrivacySettings,
         sendPeerDataOperationMessage,
         createParticipantNodes,
         getUSyncDevices,
         messageRetryManager,
+        updateMemberLabel,
         updateMediaMessage: async (message) => {
             const content = assertMediaContent(message.message);
             const mediaKey = content.mediaKey;
             const meId = authState.creds.me.id;
-            const node = await encryptMediaRetryRequest(message.key, mediaKey, meId);
+            const node = encryptMediaRetryRequest(message.key, mediaKey, meId);
             let error = undefined;
             await Promise.all([
                 sendNode(node),
@@ -993,7 +907,7 @@ export const makeMessagesSocket = (config) => {
                         }
                         else {
                             try {
-                                const media = await decryptMediaRetryData(result.media, mediaKey, result.key.id);
+                                const media = decryptMediaRetryData(result.media, mediaKey, result.key.id);
                                 if (media.result !== proto.MediaRetryNotification.ResultType.SUCCESS) {
                                     const resultStr = proto.MediaRetryNotification.ResultType[media.result];
                                     throw new Boom(`Media re-upload failed by device (${resultStr})`, {
@@ -1019,285 +933,8 @@ export const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
-        sendStatusMentions: async (content, jids = []) => {
-            const userJid = WABinary_1.jidNormalizedUser(authState.creds.me.id)
-            let allUsers = new Set()
-            allUsers.add(userJid)
-
-            for (const id of jids) {
-                const isGroup = WABinary_1.isJidGroup(id)
-                const isPrivate = WABinary_1.isPnUser(id)
-
-                if (isGroup) {
-                    try {
-                        const metadata = await cachedGroupMetadata(id) || await global.groupMetadataCache(id)
-                        const participants = metadata.participants.map(p => WABinary_1.jidNormalizedUser(p.id))
-                        participants.forEach(jid => allUsers.add(jid))
-                    } catch (error) {
-                        logger.error(`Error getting metadata for group ${id}: ${error}`)
-                    }
-                } else if (isPrivate) {
-                    allUsers.add(WABinary_1.jidNormalizedUser(id))
-                }
-            }
-
-            const uniqueUsers = Array.from(allUsers)
-            const getRandomHexColor = () => "#" + Math.floor(Math.random() * 16777215).toString(16).padStart(6, "0")
-
-            const isMedia = content.image || content.video || content.audio
-            const isAudio = !!content.audio
-
-            const messageContent = {
-                ...content
-            }
-
-            if (isMedia && !isAudio) {
-                if (messageContent.text) {
-                    messageContent.caption = messageContent.text
-
-                    delete messageContent.text
-                }
-
-                delete messageContent.ptt
-                delete messageContent.font
-                delete messageContent.backgroundColor
-                delete messageContent.textColor
-            }
-
-            if (isAudio) {
-                delete messageContent.text
-                delete messageContent.caption
-                delete messageContent.font
-                delete messageContent.textColor
-            }
-
-            const font = !isMedia ? (content.font || Math.floor(Math.random() * 9)) : undefined
-            const textColor = !isMedia ? (content.textColor || getRandomHexColor()) : undefined
-            const backgroundColor = (!isMedia || isAudio) ? (content.backgroundColor || getRandomHexColor()) : undefined
-            const ptt = isAudio ? (typeof content.ptt === 'boolean' ? content.ptt : true) : undefined
-
-            let msg
-            let mediaHandle
-            try {
-                msg = await Utils_1.generateWAMessage(WABinary_1.STORIES_JID, messageContent, {
-                    logger,
-                    userJid,
-                    getUrlInfo: text => link_preview_1.getUrlInfo(text, {
-                        thumbnailWidth: linkPreviewImageThumbnailWidth,
-                        fetchOpts: {
-                            timeout: 3000,
-                            ...axiosOptions || {}
-                        },
-                        logger,
-                        uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
-                    }),
-                    upload: async (encFilePath, opts) => {
-                        const up = await waUploadToServer(encFilePath, {
-                            ...opts
-                        })
-                        mediaHandle = up.handle
-                        return up
-                    },
-                    mediaCache: config.mediaCache,
-                    options: config.options,
-                    font,
-                    textColor,
-                    backgroundColor,
-                    ptt
-                })
-            } catch (error) {
-                logger.error(`Error generating message: ${error}`)
-                throw error
-            }
-
-            await relayMessage(WABinary_1.STORIES_JID, msg.message, {
-                messageId: msg.key.id,
-                statusJidList: uniqueUsers,
-                additionalNodes: [{
-                    tag: 'meta',
-                    attrs: {},
-                    content: [{
-                        tag: 'mentioned_users',
-                        attrs: {},
-                        content: jids.map(jid => ({
-                            tag: 'to',
-                            attrs: {
-                                jid: WABinary_1.jidNormalizedUser(jid)
-                            }
-                        }))
-                    }]
-                }]
-            })
-
-            for (const id of jids) {
-                try {
-                    const normalizedId = WABinary_1.jidNormalizedUser(id)
-                    const isPrivate = WABinary_1.isJidUser(normalizedId)
-                    const type = isPrivate ? 'statusMentionMessage' : 'groupStatusMentionMessage'
-
-                    const protocolMessage = {
-                        [type]: {
-                            message: {
-                                protocolMessage: {
-                                    key: msg.key,
-                                    type: 25
-                                }
-                            }
-                        },
-                        messageContextInfo: {
-                            messageSecret: randomBytes(32)
-                        }
-                    }
-
-                    const statusMsg = await Utils_1.generateWAMessageFromContent(normalizedId,
-                        protocolMessage, {}
-                    )
-
-                    await relayMessage(
-                        normalizedId,
-                        statusMsg.message, {
-                            additionalNodes: [{
-                                tag: 'meta',
-                                attrs: isPrivate ? {
-                                    is_status_mention: 'true'
-                                } : {
-                                    is_group_status_mention: 'true'
-                                }
-                            }]
-                        }
-                    )
-
-                    await Utils_1.delay(2000)
-                } catch (error) {
-                    logger.error(`Error sending to ${id}: ${error}`)
-                }
-            }
-
-            return msg
-        },
-        sendAlbumMessage: async (jid, medias, options = {}) => {
-            const userJid = authState.creds.me.id
-            for (const media of medias) {
-                if (!media.image && !media.video) throw new TypeError(`medias[i] must have image or video property`)
-            }
-            if (medias.length < 2) throw new RangeError("Minimum 2 media")
-            const time = options.delay || 500
-            delete options.delay
-            const album = await Utils_1.generateWAMessageFromContent(jid, {
-                albumMessage: {
-                    expectedImageCount: medias.filter(media => media.image).length,
-                    expectedVideoCount: medias.filter(media => media.video).length,
-                    ...options
-                }
-            }, {
-                userJid,
-                ...options
-            })
-            await relayMessage(jid, album.message, {
-                messageId: album.key.id
-            })
-            let mediaHandle
-            let msg
-            for (const i in medias) {
-                const media = medias[i]
-                if (media.image) {
-                    msg = await Utils_1.generateWAMessage(jid, {
-                        image: media.image,
-                        ...media,
-                        ...options
-                    }, {
-                        userJid,
-                        upload: async (readStream, opts) => {
-                            const up = await waUploadToServer(readStream, {
-                                ...opts,
-                                newsletter: WABinary_1.isJidNewsletter(jid)
-                            })
-                            mediaHandle = up.handle
-                            return up
-                        },
-                        ...options
-                    })
-                } else if (media.video) {
-                    msg = await Utils_1.generateWAMessage(jid, {
-                        video: media.video,
-                        ...media,
-                        ...options
-                    }, {
-                        userJid,
-                        upload: async (readStream, opts) => {
-                            const up = await waUploadToServer(readStream, {
-                                ...opts,
-                                newsletter: WABinary_1.isJidNewsletter(jid)
-                            })
-                            mediaHandle = up.handle
-                            return up
-                        },
-                        ...options,
-                    })
-                }
-                if (msg) {
-                    msg.message.messageContextInfo = {
-                        messageSecret: randomBytes(32),
-                        messageAssociation: {
-                            associationType: 1,
-                            parentMessageKey: album.key
-                        }
-                    }
-                }
-                await relayMessage(jid, msg.message, {
-                    messageId: msg.key.id
-                })
-                await Utils_1.delay(time)
-            }
-            return album
-        },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
-            const additionalAttributes = {}
-            const { filter = false, quoted } = options;
-            const getParticipantAttr = () => filter ? { participant: { jid } } : {};
-            const messageType = kelvdra.detectType(content);    
-            if (messageType) {
-                switch(messageType) {
-                    case 'PAYMENT':
-                        const paymentContent = await kelvdra.handlePayment(content, quoted);
-                        return await relayMessage(jid, paymentContent, {
-                            messageId: Utils_1.generateMessageID(),
-                            ...getParticipantAttr()
-                        });
-                
-                    case 'PRODUCT':
-                        const productContent = await kelvdra.handleProduct(content, jid, quoted);
-                        const productMsg = await Utils_1.generateWAMessageFromContent(jid, productContent, { quoted });
-                        return await relayMessage(jid, productMsg.message, {
-                            messageId: productMsg.key.id,
-                            ...getParticipantAttr()
-                        });
-                
-                    case 'INTERACTIVE':
-                        const interactiveContent = await kelvdra.handleInteractive(content, jid, quoted);
-                        const interactiveMsg = await Utils_1.generateWAMessageFromContent(jid, interactiveContent, { quoted });
-                        return await relayMessage(jid, interactiveMsg.message, {
-                            messageId: interactiveMsg.key.id,
-                            ...getParticipantAttr()
-                        });
-                    case 'ALBUM':
-                        const albumContent = await kelvdra.handleAlbum(content, jid, quoted)
-                        return albumContent;
-                        
-                    case 'EVENT':
-                        return await kelvdra.handleEvent(content, jid, quoted)
-                        
-                    case 'POLL_RESULT':
-                        return await kelvdra.handlePollResult(content, jid, quoted)
-                        
-                    case 'CAROUSEL':
-            return await kelvdra.handleCarousel(content, jid, quoted);
-            
-                    case 'OLD_BUTTON':
-    return await kelvdra.handleOldButtons(content, jid, quoted);
-                }
-            }
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
                 typeof content['disappearingMessagesInChat'] !== 'undefined' &&
@@ -1380,7 +1017,7 @@ export const makeMessagesSocket = (config) => {
                 });
                 if (config.emitOwnEvents) {
                     process.nextTick(async () => {
-                        await processingMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
                 return fullMsg;