@queenanya/baileys 9.2.1 → 9.5.1

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

@@ -8,7 +8,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<string | undefined>;
+    requestPlaceholderResend: (messageKey: WAMessageKey, msgData?: Partial<WAMessage>) => Promise<string | undefined>;
     messageRetryManager: import("../Utils/index.js").MessageRetryManager | null;
     getPrivacyTokens: (jids: string[]) => Promise<any>;
     assertSessions: (jids: string[], force?: boolean) => Promise<boolean>;
@@ -29,6 +29,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<(import("../WABinary/index.js").JidWithDevice & {
         jid: string;
     })[]>;
+    updateMemberLabel: (jid: string, memberLabel: string) => Promise<string>;
     updateMediaMessage: (message: WAMessage) => Promise<WAMessage>;
     sendMessage: (jid: string, content: import("../Types/index.js").AnyMessageContent, options?: import("../Types/index.js").MiscMessageGenerationOptions) => Promise<WAMessage | undefined>;
     newsletterCreate: (name: string, description?: string) => Promise<import("../Types/index.js").NewsletterMetadata>;
@@ -89,13 +90,22 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
         startTime: number;
     }, timeoutMs?: number) => Promise<string | undefined>;
     getBotListV2: () => Promise<import("../Types/index.js").BotListInfo[]>;
-    processingMutex: {
+    messageMutex: {
+        mutex<T>(code: () => Promise<T> | T): Promise<T>;
+    };
+    receiptMutex: {
+        mutex<T>(code: () => Promise<T> | T): Promise<T>;
+    };
+    appStatePatchMutex: {
+        mutex<T>(code: () => Promise<T> | T): Promise<T>;
+    };
+    notificationMutex: {
         mutex<T>(code: () => Promise<T> | T): Promise<T>;
     };
     upsertMessage: (msg: WAMessage, type: import("../Types/index.js").MessageUpsertType) => Promise<void>;
     appPatch: (patchCreate: import("../Types/index.js").WAPatchCreate) => Promise<void>;
     sendPresenceUpdate: (type: import("../Types/index.js").WAPresence, toJid?: string) => Promise<void>;
-    presenceSubscribe: (toJid: string, tcToken?: Buffer) => Promise<void>;
+    presenceSubscribe: (toJid: string) => Promise<void>;
     profilePictureUrl: (jid: string, type?: "preview" | "image", timeoutMs?: number) => Promise<string | undefined>;
     fetchBlocklist: () => Promise<(string | undefined)[]>;
     fetchStatus: (...jids: string[]) => Promise<import("../index.js").USyncQueryResultList[] | undefined>;
@@ -157,13 +167,15 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
     sendNode: (frame: BinaryNode) => Promise<void>;
     logout: (msg?: string) => Promise<void>;
-    end: (error: Error | undefined) => void;
+    end: (error: Error | undefined) => Promise<void>;
     onUnexpectedError: (err: Error | Boom, msg: string) => void;
     uploadPreKeys: (count?: number, retryCount?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     digestKeyBundle: () => Promise<void>;
     rotateSignedPreKey: () => Promise<void>;
     requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    updateServerTimeOffset: ({ attrs }: BinaryNode) => void;
+    sendUnifiedSession: () => Promise<void>;
     wamBuffer: import("../index.js").BinaryInfo;
     waitForConnectionUpdate: (check: (u: Partial<import("../Types/index.js").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
     sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;

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

@@ -1 +1 @@
-{"version":3,"file":"messages-recv.d.ts","sourceRoot":"","sources":["../../src/Socket/messages-recv.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEjC,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAE9C,OAAO,KAAK,EAEX,kBAAkB,EAClB,mBAAmB,EAEnB,YAAY,EAEZ,SAAS,EACT,YAAY,EAEZ,MAAM,UAAU,CAAA;AA2BjB,OAAO,EAEN,KAAK,UAAU,EAef,MAAM,aAAa,CAAA;AAIpB,eAAO,MAAM,sBAAsB,GAAI,QAAQ,YAAY;8CAwQH,UAAU,cAAc,MAAM;6BA2D/C,UAAU;yBAtBd,MAAM,YAAY,MAAM;iCAzPlD,MAAM,gBACC,YAAY,sBACN,MAAM,GAAG,IAAI,KAC/B,OAAO,CAAC,MAAM,CAAC;2CAmBkC,YAAY,KAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAynBnE,CAAC;;;;;;;;;0DAjsB3B,GAAC,0BACiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAk+CtB,CAAA"}
+{"version":3,"file":"messages-recv.d.ts","sourceRoot":"","sources":["../../src/Socket/messages-recv.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEjC,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAQ9C,OAAO,KAAK,EAEX,kBAAkB,EAClB,mBAAmB,EAEnB,YAAY,EAEZ,SAAS,EACT,YAAY,EAEZ,MAAM,UAAU,CAAA;AA8BjB,OAAO,EAEN,KAAK,UAAU,EAef,MAAM,aAAa,CAAA;AAIpB,eAAO,MAAM,sBAAsB,GAAI,QAAQ,YAAY;8CA+QH,UAAU,cAAc,MAAM;6BA2D/C,UAAU;yBAtBd,MAAM,YAAY,MAAM;iCA9PlD,MAAM,gBACC,YAAY,sBACN,MAAM,GAAG,IAAI,KAC/B,OAAO,CAAC,MAAM,CAAC;2CAoBL,YAAY,YACd,OAAO,CAAC,SAAS,CAAC,KAC1B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAipBzB,CAAC;;;;;;;;;0DAhuBuD,GAAG,0BACxC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyjD3B,CAAA"}

package/lib/Socket/messages-recv.js

@@ -3,9 +3,9 @@ import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 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 { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT, PLACEHOLDER_MAX_AGE_SECONDS, STATUS_EXPIRY_SECONDS } from '../Defaults/index.js';
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
-import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, handleIdentityChange, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, toNumber, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import { areJidsSameUser, binaryNodeToString, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
@@ -13,7 +13,7 @@ import { makeMessagesSocket } from './messages-send.js';
 export const makeMessagesRecvSocket = (config) => {
     const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid, enableAutoSessionRecreation } = config;
     const sock = makeMessagesSocket(config);
-    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, messageRetryManager } = sock;
+    const { ev, authState, ws, messageMutex, notificationMutex, receiptMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, messageRetryManager } = sock;
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     const msgRetryCache = config.msgRetryCounterCache ||
@@ -50,19 +50,21 @@ export const makeMessagesRecvSocket = (config) => {
         };
         return sendPeerDataOperationMessage(pdoMessage);
     };
-    const requestPlaceholderResend = async (messageKey) => {
+    const requestPlaceholderResend = async (messageKey, msgData) => {
         if (!authState.creds.me?.id) {
             throw new Boom('Not authenticated');
         }
-        if (placeholderResendCache.get(messageKey?.id)) {
+        if (await placeholderResendCache.get(messageKey?.id)) {
             logger.debug({ messageKey }, 'already requested resend');
             return;
         }
         else {
-            await placeholderResendCache.set(messageKey?.id, true);
+            // Store original message data so PDO response handler can preserve
+            // metadata (LID details, timestamps, etc.) that the phone may omit
+            await placeholderResendCache.set(messageKey?.id, msgData || true);
         }
-        await delay(5000);
-        if (!placeholderResendCache.get(messageKey?.id)) {
+        await delay(2000);
+        if (!(await placeholderResendCache.get(messageKey?.id))) {
             logger.debug({ messageKey }, 'message received while resend requested');
             return 'RESOLVED';
         }
@@ -75,11 +77,11 @@ export const makeMessagesRecvSocket = (config) => {
             peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
         };
         setTimeout(async () => {
-            if (placeholderResendCache.get(messageKey?.id)) {
-                logger.debug({ messageKey }, 'PDO message without response after 15 seconds. Phone possibly offline');
+            if (await placeholderResendCache.get(messageKey?.id)) {
+                logger.debug({ messageKey }, 'PDO message without response after 8 seconds. Phone possibly offline');
                 await placeholderResendCache.del(messageKey?.id);
             }
-        }, 15000);
+        }, 8000);
         return sendPeerDataOperationMessage(pdoMessage);
     };
     // Handles mex newsletter notifications
@@ -300,12 +302,12 @@ export const makeMessagesRecvSocket = (config) => {
         // Check if we should recreate the session
         let shouldRecreateSession = false;
         let recreateReason = '';
-        if (enableAutoSessionRecreation && messageRetryManager) {
+        if (enableAutoSessionRecreation && messageRetryManager && retryCount > 1) {
             try {
                 // Check if we have a session with this JID
                 const sessionId = signalRepository.jidToSignalProtocolAddress(fromJid);
                 const hasSession = await signalRepository.validateSession(fromJid);
-                const result = messageRetryManager.shouldRecreateSession(fromJid, retryCount, hasSession.exists);
+                const result = messageRetryManager.shouldRecreateSession(fromJid, hasSession.exists);
                 shouldRecreateSession = result.recreate;
                 recreateReason = result.reason;
                 if (shouldRecreateSession) {
@@ -407,22 +409,15 @@ export const makeMessagesRecvSocket = (config) => {
             }
         }
         else {
-            const identityNode = getBinaryNodeChild(node, 'identity');
-            if (identityNode) {
-                logger.info({ jid: from }, 'identity changed');
-                if (identityAssertDebounce.get(from)) {
-                    logger.debug({ jid: from }, 'skipping identity assert (debounced)');
-                    return;
-                }
-                identityAssertDebounce.set(from, true);
-                try {
-                    await assertSessions([from], true);
-                }
-                catch (error) {
-                    logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
-                }
-            }
-            else {
+            const result = await handleIdentityChange(node, {
+                meId: authState.creds.me?.id,
+                meLid: authState.creds.me?.lid,
+                validateSession: signalRepository.validateSession,
+                assertSessions,
+                debounceCache: identityAssertDebounce,
+                logger
+            });
+            if (result.action === 'no_identity_node') {
                 logger.info({ node }, 'unknown encrypt notification');
             }
         }
@@ -556,19 +551,6 @@ export const makeMessagesRecvSocket = (config) => {
         const nodeType = node.attrs.type;
         const from = jidNormalizedUser(node.attrs.from);
         switch (nodeType) {
-            case 'privacy_token':
-                const tokenList = getBinaryNodeChildren(child, 'token');
-                for (const { attrs, content } of tokenList) {
-                    const jid = attrs.jid;
-                    ev.emit('chats.update', [
-                        {
-                            id: jid,
-                            tcToken: content
-                        }
-                    ]);
-                    logger.debug({ jid }, 'got privacy token update');
-                }
-                break;
             case 'newsletter':
                 await handleNewsletterNotification(node);
                 break;
@@ -605,6 +587,7 @@ export const makeMessagesRecvSocket = (config) => {
             case 'picture':
                 const setPicture = getBinaryNodeChild(node, 'set');
                 const delPicture = getBinaryNodeChild(node, 'delete');
+                // TODO: WAJIDHASH stuff proper support inhouse
                 ev.emit('contacts.update', [
                     {
                         id: jidNormalizedUser(node?.attrs?.from) || (setPicture || delPicture)?.attrs?.hash || '',
@@ -657,7 +640,7 @@ export const makeMessagesRecvSocket = (config) => {
                 const companionSharedKey = Curve.sharedKey(authState.creds.pairingEphemeralKeyPair.private, codePairingPublicKey);
                 const random = randomBytes(32);
                 const linkCodeSalt = randomBytes(32);
-                const linkCodePairingExpanded = await hkdf(companionSharedKey, 32, {
+                const linkCodePairingExpanded = hkdf(companionSharedKey, 32, {
                     salt: linkCodeSalt,
                     info: 'link_code_pairing_key_bundle_encryption_key'
                 });
@@ -671,7 +654,7 @@ export const makeMessagesRecvSocket = (config) => {
                 const encryptedPayload = Buffer.concat([linkCodeSalt, encryptIv, encrypted]);
                 const identitySharedKey = Curve.sharedKey(authState.creds.signedIdentityKey.private, primaryIdentityPublicKey);
                 const identityPayload = Buffer.concat([companionSharedKey, identitySharedKey, random]);
-                authState.creds.advSecretKey = (await hkdf(identityPayload, 32, { info: 'adv_secret' })).toString('base64');
+                authState.creds.advSecretKey = Buffer.from(hkdf(identityPayload, 32, { info: 'adv_secret' })).toString('base64');
                 await query({
                     tag: 'iq',
                     attrs: {
@@ -802,11 +785,11 @@ export const makeMessagesRecvSocket = (config) => {
         // Check if we should recreate session for this retry
         let shouldRecreateSession = false;
         let recreateReason = '';
-        if (enableAutoSessionRecreation && messageRetryManager) {
+        if (enableAutoSessionRecreation && messageRetryManager && retryCount > 1) {
             try {
                 const sessionId = signalRepository.jidToSignalProtocolAddress(participant);
                 const hasSession = await signalRepository.validateSession(participant);
-                const result = messageRetryManager.shouldRecreateSession(participant, retryCount, hasSession.exists);
+                const result = messageRetryManager.shouldRecreateSession(participant, hasSession.exists);
                 shouldRecreateSession = result.recreate;
                 recreateReason = result.reason;
                 if (shouldRecreateSession) {
@@ -869,7 +852,7 @@ export const makeMessagesRecvSocket = (config) => {
         }
         try {
             await Promise.all([
-                processingMutex.mutex(async () => {
+                receiptMutex.mutex(async () => {
                     const status = 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
@@ -890,7 +873,7 @@ export const makeMessagesRecvSocket = (config) => {
                         else {
                             ev.emit('messages.update', ids.map(id => ({
                                 key: { ...key, id },
-                                update: { status }
+                                update: { status, messageTimestamp: toNumber(+(attrs.t ?? 0)) }
                             })));
                         }
                     }
@@ -933,7 +916,7 @@ export const makeMessagesRecvSocket = (config) => {
         }
         try {
             await Promise.all([
-                processingMutex.mutex(async () => {
+                notificationMutex.mutex(async () => {
                     const msg = await processNotification(node);
                     if (msg) {
                         const fromMe = areJidsSameUser(node.attrs.participant || remoteJid, authState.creds.me.id);
@@ -967,7 +950,7 @@ export const makeMessagesRecvSocket = (config) => {
         }
         const encNode = getBinaryNodeChild(node, 'enc');
         // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
-        if (encNode && encNode.attrs.type === 'msmsg') {
+        if (encNode?.attrs.type === 'msmsg') {
             logger.debug({ key: node.attrs.key }, 'ignored msmsg');
             await sendMessageAck(node, NACK_REASONS.MissingMessageSecret);
             return;
@@ -997,58 +980,123 @@ export const makeMessagesRecvSocket = (config) => {
             }, 'Added message to recent cache for retry receipts');
         }
         try {
-            await processingMutex.mutex(async () => {
+            await messageMutex.mutex(async () => {
                 await decrypt();
                 // message failed to decrypt
                 if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT && msg.category !== 'peer') {
                     if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) {
                         return sendMessageAck(node, NACK_REASONS.ParsingError);
                     }
-                    const errorMessage = msg?.messageStubParameters?.[0] || '';
-                    const isPreKeyError = errorMessage.includes('PreKey');
-                    logger.debug(`[handleMessage] Attempting retry request for failed decryption`);
-                    // Handle both pre-key and normal retries in single mutex
-                    await retryMutex.mutex(async () => {
-                        try {
-                            if (!ws.isOpen) {
-                                logger.debug({ node }, 'Connection closed, 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);
-                                }
-                                catch (uploadErr) {
-                                    logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
-                                }
+                    if (msg.messageStubParameters?.[0] === NO_MESSAGE_FOUND_ERROR_TEXT) {
+                        // Message arrived without encryption (e.g. CTWA ads messages).
+                        // Check if this is eligible for placeholder resend (matching WA Web filters).
+                        const unavailableNode = getBinaryNodeChild(node, 'unavailable');
+                        const unavailableType = unavailableNode?.attrs?.type;
+                        if (unavailableType === 'bot_unavailable_fanout' ||
+                            unavailableType === 'hosted_unavailable_fanout' ||
+                            unavailableType === 'view_once_unavailable_fanout') {
+                            logger.debug({ msgId: msg.key.id, unavailableType }, 'skipping placeholder resend for excluded unavailable type');
+                            return sendMessageAck(node);
+                        }
+                        const messageAge = unixTimestampSeconds() - toNumber(msg.messageTimestamp);
+                        if (messageAge > PLACEHOLDER_MAX_AGE_SECONDS) {
+                            logger.debug({ msgId: msg.key.id, messageAge }, 'skipping placeholder resend for old message');
+                            return sendMessageAck(node);
+                        }
+                        // Request the real content from the phone via placeholder resend PDO.
+                        // Upsert the CIPHERTEXT stub as a placeholder (like WA Web's processPlaceholderMsg),
+                        // and store the requestId in stubParameters[1] so users can correlate
+                        // with the incoming PDO response event.
+                        const cleanKey = {
+                            remoteJid: msg.key.remoteJid,
+                            fromMe: msg.key.fromMe,
+                            id: msg.key.id,
+                            participant: msg.key.participant
+                        };
+                        // Cache the original message metadata so the PDO response handler
+                        // can preserve key fields (LID details etc.) that the phone may omit
+                        const msgData = {
+                            key: msg.key,
+                            messageTimestamp: msg.messageTimestamp,
+                            pushName: msg.pushName,
+                            participant: msg.participant,
+                            verifiedBizName: msg.verifiedBizName
+                        };
+                        requestPlaceholderResend(cleanKey, msgData)
+                            .then(requestId => {
+                            if (requestId && requestId !== 'RESOLVED') {
+                                logger.debug({ msgId: msg.key.id, requestId }, 'requested placeholder resend for unavailable message');
+                                ev.emit('messages.update', [
+                                    {
+                                        key: msg.key,
+                                        update: { messageStubParameters: [NO_MESSAGE_FOUND_ERROR_TEXT, requestId] }
+                                    }
+                                ]);
                             }
-                            const encNode = getBinaryNodeChild(node, 'enc');
-                            await sendRetryRequest(node, !encNode);
-                            if (retryRequestDelayMs) {
-                                await delay(retryRequestDelayMs);
+                        })
+                            .catch(err => {
+                            logger.warn({ err, msgId: msg.key.id }, 'failed to request placeholder resend for unavailable message');
+                        });
+                        await sendMessageAck(node);
+                        // Don't return — fall through to upsertMessage so the stub is emitted
+                    }
+                    else {
+                        // Skip retry for expired status messages (>24h old)
+                        if (isJidStatusBroadcast(msg.key.remoteJid)) {
+                            const messageAge = unixTimestampSeconds() - toNumber(msg.messageTimestamp);
+                            if (messageAge > STATUS_EXPIRY_SECONDS) {
+                                logger.debug({ msgId: msg.key.id, messageAge, remoteJid: msg.key.remoteJid }, 'skipping retry for expired status message');
+                                return sendMessageAck(node);
                             }
                         }
-                        catch (err) {
-                            logger.error({ err, isPreKeyError }, 'Failed to handle retry, attempting basic retry');
-                            // Still attempt retry even if pre-key upload failed
+                        const errorMessage = msg?.messageStubParameters?.[0] || '';
+                        const isPreKeyError = errorMessage.includes('PreKey');
+                        logger.debug(`[handleMessage] Attempting retry request for failed decryption`);
+                        // Handle both pre-key and normal retries in single mutex
+                        await retryMutex.mutex(async () => {
                             try {
+                                if (!ws.isOpen) {
+                                    logger.debug({ node }, 'Connection closed, 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);
+                                    }
+                                    catch (uploadErr) {
+                                        logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
+                                    }
+                                }
                                 const encNode = getBinaryNodeChild(node, 'enc');
                                 await sendRetryRequest(node, !encNode);
+                                if (retryRequestDelayMs) {
+                                    await delay(retryRequestDelayMs);
+                                }
                             }
-                            catch (retryErr) {
-                                logger.error({ retryErr }, 'Failed to send retry after error handling');
+                            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');
+                                }
                             }
-                        }
-                        await sendMessageAck(node, NACK_REASONS.UnhandledError);
-                    });
+                            await sendMessageAck(node, NACK_REASONS.UnhandledError);
+                        });
+                    }
                 }
                 else {
-                    await sendMessageAck(node);
+                    if (messageRetryManager && msg.key.id) {
+                        messageRetryManager.cancelPendingPhoneRequest(msg.key.id);
+                    }
                     const isNewsletter = isJidNewsletter(msg.key.remoteJid);
                     if (!isNewsletter) {
                         // no type in the receipt => message delivered
@@ -1074,10 +1122,11 @@ export const makeMessagesRecvSocket = (config) => {
                         const isAnyHistoryMsg = getHistoryMsg(msg.message);
                         if (isAnyHistoryMsg) {
                             const jid = jidNormalizedUser(msg.key.remoteJid);
-                            await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
+                            await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync'); // TODO: investigate
                         }
                     }
                     else {
+                        await sendMessageAck(node);
                         logger.debug({ key: msg.key }, 'processed newsletter message without receipts');
                     }
                 }
@@ -1101,6 +1150,7 @@ export const makeMessagesRecvSocket = (config) => {
         const call = {
             chatId: attrs.from,
             from,
+            callerPn: infoChild.attrs['caller_pn'],
             id: callId,
             date: new Date(+attrs.t * 1000),
             offline: !!attrs.offline,
@@ -1117,6 +1167,7 @@ export const makeMessagesRecvSocket = (config) => {
         if (existingCall) {
             call.isVideo = existingCall.isVideo;
             call.isGroup = existingCall.isGroup;
+            call.callerPn = call.callerPn || existingCall.callerPn;
         }
         // delete data once call has ended
         if (status === 'reject' || status === 'accept' || status === 'timeout' || status === 'terminate') {
@@ -1178,6 +1229,10 @@ export const makeMessagesRecvSocket = (config) => {
             return exec(node, false).catch(err => onUnexpectedError(err, identifier));
         }
     };
+    /** Yields control to the event loop to prevent blocking */
+    const yieldToEventLoop = () => {
+        return new Promise(resolve => setImmediate(resolve));
+    };
     const makeOfflineNodeProcessor = () => {
         const nodeProcessorMap = new Map([
             ['message', handleMessage],
@@ -1187,6 +1242,8 @@ export const makeMessagesRecvSocket = (config) => {
         ]);
         const nodes = [];
         let isProcessing = false;
+        // Number of nodes to process before yielding to event loop
+        const BATCH_SIZE = 10;
         const enqueue = (type, node) => {
             nodes.push({ type, node });
             if (isProcessing) {
@@ -1194,6 +1251,7 @@ export const makeMessagesRecvSocket = (config) => {
             }
             isProcessing = true;
             const promise = async () => {
+                let processedInBatch = 0;
                 while (nodes.length && ws.isOpen) {
                     const { type, node } = nodes.shift();
                     const nodeProcessor = nodeProcessorMap.get(type);
@@ -1202,6 +1260,13 @@ export const makeMessagesRecvSocket = (config) => {
                         continue;
                     }
                     await nodeProcessor(node);
+                    processedInBatch++;
+                    // Yield to event loop after processing a batch
+                    // This prevents blocking the event loop for too long when there are many offline nodes
+                    if (processedInBatch >= BATCH_SIZE) {
+                        processedInBatch = 0;
+                        await yieldToEventLoop();
+                    }
                 }
                 isProcessing = false;
             };