@periskope/baileys 6.7.19-4 → 6.8.0-alpha-1

package/lib/Socket/messages-recv.js

@@ -5,7 +5,7 @@ import Long from 'long';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaults/index.js';
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
-import { addRecentMessage, aesDecryptCTR, aesEncryptGCM, cleanMessage, cleanupOldRetryStates, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getMessageForRetry, getNextPreKeys, getRecentMessage, getStatusFromReceiptType, hkdf, incrementIncomingRetryCounter, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, shouldDropRetryRequest, shouldRecreateSession, executeSessionRecreation, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isJidUser, isLidUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
@@ -14,9 +14,6 @@ export const makeMessagesRecvSocket = (config) => {
     const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid } = config;
     const sock = makeMessagesSocket(config);
     const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage } = sock;
-    const PENDING_MESSAGE_DECRYPTIONS = new Map();
-    const MAX_DECRYPT_RETRY_COUNT = 3;
-    const DECRYPT_RETRY_DELAY = 2000;
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     const msgRetryCache = config.msgRetryCounterCache ||
@@ -110,55 +107,20 @@ export const makeMessagesRecvSocket = (config) => {
         const { fullMessage } = decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '');
         const { key: msgKey } = fullMessage;
         const msgId = msgKey.id;
-        // const senderJid = node.attrs.from || ''
-        // // Check internal retry counter (whatsmeow pattern - max 10 per sender/message)
-        // const internalRetryCount = incrementIncomingRetryCounter(senderJid, msgId)
-        // if (shouldDropRetryRequest(senderJid, msgId)) {
-        // 	logger.warn(
-        // 		{
-        // 			senderJid,
-        // 			msgId,
-        // 			internalRetryCount
-        // 		},
-        // 		'Dropping retry request: internal retry counter exceeded limit (10)'
-        // 	)
-        // 	return
-        // }
         const key = `${msgId}:${msgKey?.participant}`;
         let retryCount = msgRetryCache.get(key) || 0;
-        // Enhanced retry limit check (whatsmeow uses 5 max retries)
         if (retryCount >= maxMsgRetryCount) {
-            logger.warn({ retryCount, msgId }, 'reached maximum retry limit (5), not sending more retry receipts');
+            logger.debug({ retryCount, msgId }, 'reached retry limit, clearing');
             msgRetryCache.del(key);
             return;
         }
         retryCount += 1;
         msgRetryCache.set(key, retryCount);
         const { account, signedPreKey, signedIdentityKey: identityKey } = authState.creds;
-        // Enhanced retry logic inspired by whatsmeow
         if (retryCount === 1) {
-            // First retry - request resend via phone (whatsmeow pattern)
-            try {
-                const msgId = await requestPlaceholderResend(msgKey);
-                logger.debug({
-                    retryCount,
-                    msgId
-                    // internalRetryCount
-                }, 'sendRetryRequest: requested placeholder resend for message (first retry)');
-            }
-            catch (error) {
-                logger.warn({
-                    msgId,
-                    error: error.message
-                }, 'Failed to request placeholder resend');
-            }
-        }
-        else {
-            logger.debug({
-                retryCount,
-                msgId
-                // internalRetryCount
-            }, 'sendRetryRequest: retry count > 1, skipping placeholder resend');
+            //request a resend via phone
+            const msgId = await requestPlaceholderResend(msgKey);
+            logger.debug(`sendRetryRequest: requested placeholder resend for message ${msgId}`);
         }
         const deviceIdentity = encodeSignedDeviceIdentity(account, true);
         await authState.keys.transaction(async () => {
@@ -192,12 +154,7 @@ export const makeMessagesRecvSocket = (config) => {
             if (node.attrs.participant) {
                 receipt.attrs.participant = node.attrs.participant;
             }
-            // Include keys based on whatsmeow logic:
-            // - Always include on first retry (retryCount === 1)
-            // - Include when forced (MAC errors, session errors)
-            // - Include when retry count > 1 (session recreation scenarios)
-            const shouldIncludeKeys = retryCount === 1 || forceIncludeKeys || retryCount > 1;
-            if (shouldIncludeKeys) {
+            if (retryCount > 1 || forceIncludeKeys) {
                 const { update, preKeys } = await getNextPreKeys(authState, 1);
                 const [keyId] = Object.keys(preKeys);
                 const key = preKeys[+keyId];
@@ -214,20 +171,6 @@ export const makeMessagesRecvSocket = (config) => {
                     ]
                 });
                 ev.emit('creds.update', update);
-                logger.debug({
-                    retryCount,
-                    forceIncludeKeys,
-                    shouldIncludeKeys
-                    // internalRetryCount
-                }, 'Including keys and device identity in retry receipt');
-            }
-            else {
-                logger.debug({
-                    retryCount,
-                    forceIncludeKeys,
-                    shouldIncludeKeys
-                    // internalRetryCount
-                }, 'Not including keys in retry receipt');
             }
             await sendNode(receipt);
             logger.info({ msgAttrs: node.attrs, retryCount }, 'sent retry receipt');
@@ -535,7 +478,7 @@ export const makeMessagesRecvSocket = (config) => {
     const willSendMessageAgain = (id, participant) => {
         const key = `${id}:${participant}`;
         const retryCount = msgRetryCache.get(key) || 0;
-        return retryCount < maxMsgRetryCount;
+        return retryCount <= maxMsgRetryCount;
     };
     const updateSendMessageAgainCount = (id, participant) => {
         const key = `${id}:${participant}`;
@@ -543,53 +486,23 @@ export const makeMessagesRecvSocket = (config) => {
         msgRetryCache.set(key, newValue);
     };
     const sendMessagesAgain = async (key, ids, retryNode) => {
-        // Use WhatsmeOW-compatible message retrieval (cache first, then callback)
-        const msgs = await Promise.all(ids.map(id => getMessageForRetry(key.remoteJid, id, getMessage)));
+        // todo: implement a cache to store the last 256 sent messages (copy whatsmeow)
+        const msgs = await Promise.all(ids.map(id => getMessage({ ...key, id })));
         const remoteJid = key.remoteJid;
         const participant = key.participant || remoteJid;
         // if it's the primary jid sending the request
         // just re-send the message to everyone
         // prevents the first message decryption failure
         const sendToAll = !jidDecode(participant)?.device;
-        const retryCount = +(retryNode.attrs.count || '1');
-        // Create session recreation context (same approach as decode-wa-message.ts)
-        const sessionContext = {
-            authState,
-            logger,
-            signalRepository,
-            query
-        };
-        // Use the sophisticated session recreation logic from decode-wa-message.ts
-        const sessionResult = await shouldRecreateSession(participant, retryCount, sessionContext);
-        if (sessionResult.recreate && sessionResult.shouldFetchPreKeys) {
-            logger.warn({
-                participant,
-                retryCount,
-                reason: sessionResult.reason
-            }, 'Session recreation recommended for retry');
-            // Execute session recreation with prekey fetching (includes LID support)
-            const success = await executeSessionRecreation(participant, sessionContext);
-            if (!success) {
-                logger.warn({ participant }, 'Session recreation failed, proceeding with existing session');
-            }
-        }
-        // Ensure we have sessions (use force=false to allow LID migration logic)
-        await assertSessions([participant], false);
-        // Only clear sender key memory if session recreation was recommended and it's a group
-        // This prevents unnecessary decryption failures for other group members
-        if (isJidGroup(remoteJid) && sessionResult.recreate) {
+        await assertSessions([participant], true);
+        if (isJidGroup(remoteJid)) {
             await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } });
-            logger.debug({ participant, retryCount, reason: sessionResult.reason }, 'cleared sender key memory due to session recreation');
         }
-        logger.debug({
-            participant,
-            sendToAll,
-            retryCount,
-            sessionRecreated: sessionResult.recreate,
-            reason: sessionResult.reason
-        }, 'handling retry receipt');
+        logger.debug({ participant, sendToAll }, 'forced new session for retry recp');
         for (const [i, msg] of msgs.entries()) {
-            if (msg) {
+            if (!ids[i])
+                continue;
+            if (msg && willSendMessageAgain(ids[i], participant)) {
                 updateSendMessageAgainCount(ids[i], participant);
                 const msgRelayOpts = { messageId: ids[i] };
                 if (sendToAll) {
@@ -637,7 +550,7 @@ export const makeMessagesRecvSocket = (config) => {
                     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 >= proto.WebMessageInfo.Status.SERVER_ACK) {
+                        (status >= proto.WebMessageInfo.Status.SERVER_ACK)) {
                         if (isJidGroup(remoteJid) || isJidStatusBroadcast(remoteJid)) {
                             const updateKey = status === proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp';
                             if (attrs.participant) {
@@ -679,60 +592,24 @@ export const makeMessagesRecvSocket = (config) => {
                         // correctly set who is asking for the retry
                         key.participant = key.participant || attrs.from;
                         const retryNode = getBinaryNodeChild(node, 'retry');
-                        // // Check internal retry counter (whatsmeow pattern)
-                        // const senderJid = attrs.from || ''
-                        const messageId = ids[0] || '';
-                        // if (shouldDropRetryRequest(senderJid, messageId)) {
-                        // 	logger.warn(
-                        // 		{
-                        // 			senderJid,
-                        // 			messageId,
-                        // 			attrs
-                        // 		},
-                        // 		'Dropping retry receipt: internal retry counter exceeded limit (10)'
-                        // 	)
-                        // 	return
-                        // }
-                        // // Increment internal retry counter
-                        // const internalRetryCount = incrementIncomingRetryCounter(senderJid, messageId)
-                        if (willSendMessageAgain(ids[0], key.participant)) {
+                        if (ids[0] && key.participant && willSendMessageAgain(ids[0], key.participant)) {
                             if (key.fromMe) {
                                 try {
-                                    logger.debug({
-                                        attrs,
-                                        key
-                                        // internalRetryCount
-                                    }, 'recv retry request');
-                                    // Check if we have the message in recent cache (whatsmeow pattern)
-                                    const recentMessage = getRecentMessage(key.remoteJid || '', messageId);
-                                    //eslint-disable-next-line max-depth
-                                    if (recentMessage) {
-                                        logger.debug({
-                                            jid: key.remoteJid,
-                                            id: messageId
-                                        }, 'Found message in recent cache for retry');
-                                    }
+                                    updateSendMessageAgainCount(ids[0], key.participant);
+                                    logger.debug({ attrs, key }, 'recv retry request');
                                     await sendMessagesAgain(key, ids, retryNode);
                                     ev.emit('messages.retry', { key, ids, retryNode });
                                 }
                                 catch (error) {
-                                    logger.error({ key, ids, trace: error.stack }, 'error in sending message again');
+                                    logger.error({ key, ids, trace: error instanceof Error ? error.stack : 'Unknown error' }, 'error in sending message again');
                                 }
                             }
                             else {
-                                logger.info({
-                                    attrs,
-                                    key
-                                    // internalRetryCount
-                                }, 'recv retry for not fromMe message');
+                                logger.info({ attrs, key }, 'recv retry for not fromMe message');
                             }
                         }
                         else {
-                            logger.info({
-                                attrs,
-                                key
-                                // internalRetryCount
-                            }, 'will not send message again, as sent too many times');
+                            logger.info({ attrs, key }, 'will not send message again, as sent too many times');
                         }
                     }
                 })
@@ -756,15 +633,15 @@ export const makeMessagesRecvSocket = (config) => {
                     if (msg) {
                         const fromMe = areJidsSameUser(node.attrs.participant || remoteJid, authState.creds.me.id);
                         msg.key = {
-                            ...(msg.key || {}),
                             remoteJid,
                             fromMe,
                             participant: node.attrs.participant,
-                            id: node.attrs.id
+                            id: node.attrs.id,
+                            ...(msg.key || {})
                         };
                         msg.participant ?? (msg.participant = node.attrs.participant);
                         msg.messageTimestamp = +node.attrs.t;
-                        const fullMsg = proto.WebMessageInfo.fromObject(msg);
+                        const fullMsg = proto.WebMessageInfo.create(msg);
                         await upsertMessage(fullMsg, 'append');
                     }
                 })
@@ -802,15 +679,7 @@ export const makeMessagesRecvSocket = (config) => {
                 placeholderResendCache.del(node.attrs.id);
             }
         }
-        const messageKey = `${node.attrs.from}_${node.attrs.id}_${node.attrs.participant || ''}`;
-        // Create session recreation context (whatsmeow-inspired)
-        const sessionContext = {
-            authState,
-            logger,
-            signalRepository,
-            query
-        };
-        const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger, sendRetryRequest, sessionContext);
+        const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger);
         if (response && msg?.messageStubParameters?.[0] === NO_MESSAGE_FOUND_ERROR_TEXT) {
             msg.messageStubParameters = [NO_MESSAGE_FOUND_ERROR_TEXT, response];
         }
@@ -851,155 +720,95 @@ export const makeMessagesRecvSocket = (config) => {
         try {
             await Promise.all([
                 processingMutex.mutex(async () => {
-                    try {
-                        await decrypt();
-                        // Remove from retry queue if the decrypt was succeed
-                        if (PENDING_MESSAGE_DECRYPTIONS.has(messageKey)) {
-                            PENDING_MESSAGE_DECRYPTIONS.delete(messageKey);
-                            console.warn({ messageKey }, 'Message decrypted successfully after retry');
+                    await decrypt();
+                    // message failed to decrypt
+                    if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT) {
+                        if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) {
+                            return sendMessageAck(node, NACK_REASONS.ParsingError);
                         }
-                        if (msg.key?.remoteJid && msg.key?.id) {
-                            addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message);
-                            logger.debug({
-                                jid: msg.key.remoteJid,
-                                id: msg.key.id
-                            }, 'Added message to recent cache for retry receipts');
-                        }
-                        // message failed to decrypt
-                        if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT) {
-                            if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) {
-                                return sendMessageAck(node, NACK_REASONS.ParsingError);
-                            }
-                            retryMutex.mutex(async () => {
-                                if (ws.isOpen) {
-                                    if (getBinaryNodeChild(node, 'unavailable')) {
-                                        return;
+                        const errorMessage = msg?.messageStubParameters?.[0] || '';
+                        const isPreKeyError = errorMessage.includes('PreKey');
+                        console.debug(`[handleMessage] Attempting retry request for failed decryption`);
+                        // Handle both pre-key and normal retries in single mutex
+                        retryMutex.mutex(async () => {
+                            try {
+                                if (!ws.isOpen) {
+                                    logger.debug({ node }, 'Connection closed, skipping retry');
+                                    return;
+                                }
+                                if (getBinaryNodeChild(node, 'unavailable')) {
+                                    logger.debug('Message unavailable, skipping retry');
+                                    return;
+                                }
+                                // Handle pre-key errors with upload and delay
+                                if (isPreKeyError) {
+                                    logger.info({ error: errorMessage }, 'PreKey error detected, uploading and retrying');
+                                    try {
+                                        logger.debug('Uploading pre-keys for error recovery');
+                                        await uploadPreKeys(5);
+                                        logger.debug('Waiting for server to process new pre-keys');
+                                        await delay(1000);
                                     }
-                                    const encNode = getBinaryNodeChild(node, 'enc');
-                                    console.warn({ messageKey, node }, 'Message decryption failed, sending retry request');
-                                    await sendRetryRequest(node, !encNode);
-                                    if (retryRequestDelayMs) {
-                                        await delay(retryRequestDelayMs);
+                                    catch (uploadErr) {
+                                        logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
                                     }
                                 }
-                                else {
-                                    logger.debug({ node }, 'connection closed, ignoring retry req');
+                                const encNode = getBinaryNodeChild(node, 'enc');
+                                await sendRetryRequest(node, !encNode);
+                                if (retryRequestDelayMs) {
+                                    await delay(retryRequestDelayMs);
                                 }
-                            });
-                        }
-                        else {
-                            let type = undefined;
-                            let participant = msg.key.participant;
-                            if (category === 'peer') {
-                                type = 'peer_msg';
                             }
-                            else if (msg.key.fromMe) {
-                                type = 'sender';
-                                if (isJidUser(msg.key.remoteJid)) {
-                                    participant = author;
+                            catch (err) {
+                                logger.error({ err, isPreKeyError }, 'Failed to handle retry, attempting basic retry');
+                                // Still attempt retry even if pre-key upload failed
+                                try {
+                                    const encNode = getBinaryNodeChild(node, 'enc');
+                                    await sendRetryRequest(node, !encNode);
+                                }
+                                catch (retryErr) {
+                                    logger.error({ retryErr }, 'Failed to send retry after error handling');
                                 }
                             }
-                            else if (!sendActiveReceipts) {
-                                type = 'inactive';
-                            }
-                            await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type);
-                            const isAnyHistoryMsg = getHistoryMsg(msg.message);
-                            if (isAnyHistoryMsg) {
-                                const jid = jidNormalizedUser(msg.key.remoteJid);
-                                await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
-                            }
-                        }
-                        cleanMessage(msg, authState.creds.me.id);
-                        await sendMessageAck(node);
-                        await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
+                        });
                     }
-                    catch (decryptError) {
-                        console.error({ error: decryptError, messageKey }, 'Decryption failed');
-                        if (decryptError.message.includes('No session') ||
-                            decryptError.message.includes('Bad MAC') ||
-                            decryptError.message.includes('MAC verification') ||
-                            decryptError.message.includes('No matching sessions')) {
-                            console.warn('trying to handle session error in message decryption');
-                            const pendingDecryption = PENDING_MESSAGE_DECRYPTIONS.get(messageKey);
-                            if (!pendingDecryption) {
-                                // Primeira falha - adiciona à queue
-                                PENDING_MESSAGE_DECRYPTIONS.set(messageKey, {
-                                    node,
-                                    retryCount: 1,
-                                    timestamp: Date.now()
-                                });
-                                console.warn({ messageKey, error: decryptError.message }, 'Session not found, scheduling retry');
-                                // Agenda retry
-                                setTimeout(() => {
-                                    retryMessageDecryption(messageKey).catch(err => logger.error({ err, messageKey }, 'Error in retry decryption'));
-                                }, DECRYPT_RETRY_DELAY);
-                                // try to process the message as a ciphertext
-                                msg.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
-                                msg.messageStubParameters = ['Session not ready, retrying...'];
-                                cleanMessage(msg, authState.creds.me.id);
-                                await sendMessageAck(node);
-                                await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
-                            }
-                            else if (pendingDecryption.retryCount < MAX_DECRYPT_RETRY_COUNT) {
-                                // Retry
-                                pendingDecryption.retryCount++;
-                                console.warn({ messageKey, retryCount: pendingDecryption.retryCount }, 'Retrying message decryption');
-                                setTimeout(() => {
-                                    retryMessageDecryption(messageKey).catch(err => console.error({ err, messageKey }, 'Error in retry decryption'));
-                                }, DECRYPT_RETRY_DELAY * pendingDecryption.retryCount);
-                            }
-                            else {
-                                // max retry count reached
-                                PENDING_MESSAGE_DECRYPTIONS.delete(messageKey);
-                                console.error({ messageKey }, 'Max retry count reached for message decryption');
-                                msg.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
-                                msg.messageStubParameters = ['Decryption failed after retries'];
-                                cleanMessage(msg, authState.creds.me.id);
-                                await sendMessageAck(node);
-                                await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
+                    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 (isJidUser(msg.key.remoteJid)) {
+                                participant = author;
                             }
                         }
-                        else {
-                            // other error, log and throw
-                            logger.error({ error: decryptError, messageKey }, 'Decryption failed with non-session error');
-                            throw decryptError;
+                        else if (!sendActiveReceipts) {
+                            type = 'inactive';
+                        }
+                        await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type);
+                        // send ack for history message
+                        const isAnyHistoryMsg = getHistoryMsg(msg.message);
+                        if (isAnyHistoryMsg) {
+                            const jid = jidNormalizedUser(msg.key.remoteJid);
+                            await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
                         }
                     }
+                    cleanMessage(msg, authState.creds.me.id);
+                    await sendMessageAck(node);
+                    await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
                 })
             ]);
         }
         catch (error) {
             logger.error({ error, node }, 'error in handling message');
-            await sendMessageAck(node); // Ainda assim envia ack para evitar loops
-        }
-    };
-    const retryMessageDecryption = async (messageKey) => {
-        const pendingDecryption = PENDING_MESSAGE_DECRYPTIONS.get(messageKey);
-        if (!pendingDecryption) {
-            return;
-        }
-        const { node } = pendingDecryption;
-        try {
-            // try to decrypt the message again
-            await handleMessage(node);
-        }
-        catch (error) {
-            logger.error({ error, messageKey }, 'Retry decryption failed');
-            if (pendingDecryption.retryCount >= MAX_DECRYPT_RETRY_COUNT) {
-                PENDING_MESSAGE_DECRYPTIONS.delete(messageKey);
-            }
         }
     };
-    setInterval(() => {
-        const now = Date.now();
-        const maxAge = 5 * 60 * 1000; // 5 minutes
-        for (const [key, pending] of PENDING_MESSAGE_DECRYPTIONS.entries()) {
-            if (now - pending.timestamp > maxAge) {
-                PENDING_MESSAGE_DECRYPTIONS.delete(key);
-                logger.debug({ key }, 'Removed old pending decryption from queue');
-            }
-        }
-    }, 60000);
     const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
         if (!authState.creds.me?.id) {
             throw new Boom('Not authenticated');
@@ -1241,7 +1050,7 @@ export const makeMessagesRecvSocket = (config) => {
                             ? Buffer.from(plaintextNode.content, 'binary')
                             : Buffer.from(plaintextNode.content);
                         const messageProto = proto.Message.decode(contentBuf);
-                        const fullMessage = proto.WebMessageInfo.fromObject({
+                        const fullMessage = proto.WebMessageInfo.create({
                             key: {
                                 remoteJid: from,
                                 id: child.attrs.message_id || child.attrs.server_id,
@@ -1357,7 +1166,7 @@ export const makeMessagesRecvSocket = (config) => {
             else {
                 msg.message = { call: { callKey: Buffer.from(call.id) } };
             }
-            const protoMsg = proto.WebMessageInfo.fromObject(msg);
+            const protoMsg = proto.WebMessageInfo.create(msg);
             upsertMessage(protoMsg, call.offline ? 'append' : 'notify');
         }
     });
@@ -1367,21 +1176,6 @@ export const makeMessagesRecvSocket = (config) => {
             logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`);
         }
     });
-    // Setup automatic cleanup of old retry states (inspired by whatsmeow)
-    const cleanupInterval = setInterval(() => {
-        try {
-            cleanupOldRetryStates();
-        }
-        catch (error) {
-            logger.warn({ error: error.message }, 'Failed to cleanup old retry states');
-        }
-    }, 60 * 60 * 1000); // Run every hour
-    // Cleanup on socket close
-    sock.ev.on('connection.update', ({ connection }) => {
-        if (connection === 'close') {
-            clearInterval(cleanupInterval);
-        }
-    });
     return {
         ...sock,
         sendMessageAck,