@hansaka02/baileys 7.3.4 → 7.3.6

package/lib/Socket/messages-recv.js

@@ -54,9 +54,10 @@ const {
   getBinaryNodeChildren, 
   getBinaryNodeChildString, 
   isJidGroup, 
+  isJidNewsletter, 
   isJidStatusBroadcast, 
   isLidUser,
-  isJidUser, 
+  isPnUser, 
   jidDecode, 
   jidNormalizedUser, 
   S_WHATSAPP_NET 
@@ -66,9 +67,40 @@ const { makeMutex } = require("../Utils/make-mutex")
 const { makeMessagesSocket } = require("./messages-send")
 
 const makeMessagesRecvSocket = (config) => {
-    const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid, enableAutoSessionRecreation } = config
+    const { 
+        logger, 
+        retryRequestDelayMs,
+        maxMsgRetryCount, 
+        getMessage, 
+        shouldIgnoreJid, 
+        enableAutoSessionRecreation 
+    } = config
+	
     const suki = makeMessagesSocket(config)
-    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, groupMetadata, getUSyncDevices, createParticipantNodes, messageRetryManager, sendPeerDataOperationMessage } = suki
+    
+    const {
+        ev, 
+        authState, 
+        ws, 
+        messageMutex, 
+        notificationMutex, 
+        receiptMutex, 
+        signalRepository, 
+        query, 
+        upsertMessage, 
+        resyncAppState, 
+        onUnexpectedError, 
+        assertSessions,
+        sendNode, 
+        relayMessage, 
+        sendReceipt, 
+        uploadPreKeys, 
+        groupMetadata, 
+        getUSyncDevices,
+        createParticipantNodes,
+        messageRetryManager, 
+        sendPeerDataOperationMessage 
+     } = suki
     
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex()
@@ -88,8 +120,73 @@ const makeMessagesRecvSocket = (config) => {
         useClones: false
     })
     
+    // Debounce identity-change session refreshes per JID to avoid bursts
+    const identityAssertDebounce = new NodeCache({
+        stdTTL: 5,
+        useClones: false
+    })
+    
     let sendActiveReceipts = false
     
+    const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
+        if (!authState.creds.me?.id) {
+            throw new Boom('Not authenticated')
+        }
+        
+        const pdoMessage = {
+            historySyncOnDemandRequest: {
+                chatJid: oldestMsgKey.remoteJid,
+                oldestMsgFromMe: oldestMsgKey.fromMe,
+                oldestMsgId: oldestMsgKey.id,
+                oldestMsgTimestampMs: oldestMsgTimestamp,
+                onDemandMsgCount: count
+            },
+            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
+        }
+        
+        return sendPeerDataOperationMessage(pdoMessage)
+    }
+    
+    const requestPlaceholderResend = async (messageKey) => {
+        if (!authState.creds.me?.id) {
+            throw new Boom('Not authenticated')
+        }
+        
+        if (await placeholderResendCache.get(messageKey?.id)) {
+            logger.debug({ messageKey }, 'already requested resend')
+            return
+        }
+        
+        else {
+            await placeholderResendCache.set(messageKey?.id, true)
+        }
+        
+        await delay(5000)
+        
+        if (!(await placeholderResendCache.get(messageKey?.id))) {
+            logger.debug({ messageKey }, 'message received while resend requested')
+            return 'RESOLVED'
+        }
+        
+        const pdoMessage = {
+            placeholderMessageResendRequest: [
+                {
+                    messageKey
+                }
+            ],
+            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
+        }
+        
+        setTimeout(async () => {
+            if (await placeholderResendCache.get(messageKey?.id)) {
+                logger.debug({ messageKey }, 'PDO message without response after 15 seconds. Phone possibly offline')
+                await placeholderResendCache.del(messageKey?.id)
+            }
+        }, 15000)
+        
+        return sendPeerDataOperationMessage(pdoMessage)
+    }
+    
     const sendMessageAck = async ({ tag, attrs, content }, errorCode) => {
         const stanza = {
             tag: 'ack',
@@ -223,20 +320,25 @@ const makeMessagesRecvSocket = (config) => {
             
             // Use the new retry count for the rest of the logic
             const key = `${msgId}:${msgKey?.participant}`
-            msgRetryCache.set(key, retryCount)
+            await msgRetryCache.set(key, retryCount)
         }
+        
         else {
             // Fallback to old system
             const key = `${msgId}:${msgKey?.participant}`
+            
             let retryCount = (await msgRetryCache.get(key)) || 0
             
             if (retryCount >= maxMsgRetryCount) {
                 logger.debug({ retryCount, msgId }, 'reached retry limit, clearing')
-                msgRetryCache.del(key)
+                
+                await msgRetryCache.del(key)
+                
                 return
             }
             
             retryCount += 1
+            
             await msgRetryCache.set(key, retryCount)
         }
         
@@ -260,12 +362,15 @@ const makeMessagesRecvSocket = (config) => {
                 recreateReason = result.reason
                 
                 if (shouldRecreateSession) {
-                    logger.info({ fromJid, retryCount, reason: recreateReason }, 'recreating session for retry')
+                    logger.debug({ fromJid, retryCount, reason: recreateReason }, 'recreating session for retry')
+                    
                     // Delete existing session to force recreation
                     await authState.keys.set({ session: { [sessionId]: null } })
+                    
                     forceIncludeKeys = true
                 }
             }
+            
             catch (error) {
                 logger.warn({ error, fromJid }, 'failed to check session recreation')
             }
@@ -277,22 +382,27 @@ const makeMessagesRecvSocket = (config) => {
                 // Schedule phone request with delay (like whatsmeow)
                 messageRetryManager.schedulePhoneRequest(msgId, async () => {
                     try {
-                        const msgId = await requestPlaceholderResend(msgKey)
-                        logger.debug(`sendRetryRequest: requested placeholder resend for message ${msgId} (scheduled)`)
+                        const requestId = await requestPlaceholderResend(msgKey)
+                        
+                        logger.debug(`sendRetryRequest: requested placeholder resend (${requestId}) for message ${msgId} (scheduled)`)
                     }
+                    
                     catch (error) {
-                        logger.warn({ error, msgId }, 'failed to send scheduled phone request');
+                        logger.warn({ error, msgId }, 'failed to send scheduled phone request')
                     }
                 })
             }
+            
             else {
                 // Fallback to immediate request
                 const msgId = await requestPlaceholderResend(msgKey)
+                
                 logger.debug(`sendRetryRequest: requested placeholder resend for message ${msgId}`)
             }
         }
         
         const deviceIdentity = encodeSignedDeviceIdentity(account, true)
+        
         await authState.keys.transaction(async () => {
             const receipt = {
                 tag: 'receipt',
@@ -308,7 +418,9 @@ const makeMessagesRecvSocket = (config) => {
                             count: retryCount.toString(),
                             id: node.attrs.id,
                             t: node.attrs.t,
-                            v: '1'
+                            v: '1',
+                            // ADD ERROR FIELD
+                            error: '0'
                         }
                     },
                     {
@@ -343,20 +455,25 @@ const makeMessagesRecvSocket = (config) => {
                         xmppSignedPreKey(signedPreKey),
                         { tag: 'device-identity', attrs: {}, content: deviceIdentity }
                     ]
-                });
+                })
+                
                 ev.emit('creds.update', update)
             }
+            
             await sendNode(receipt)
+            
             logger.info({ msgAttrs: node.attrs, retryCount }, 'sent retry receipt')
         }, authState?.creds?.me?.id || 'sendRetryRequest')
     }
     
     const handleEncryptNotification = async (node) => {
         const from = node.attrs.from
+        
         if (from === S_WHATSAPP_NET) {
             const countChild = getBinaryNodeChild(node, 'count')
             const count = +countChild.attrs.value
             const shouldUploadMorePreKeys = count < MIN_PREKEY_COUNT
+            
             logger.debug({ count, shouldUploadMorePreKeys }, 'recv pre-key count')
             
             if (shouldUploadMorePreKeys) {
@@ -366,10 +483,24 @@ const makeMessagesRecvSocket = (config) => {
         
         else {
             const identityNode = getBinaryNodeChild(node, 'identity')
+            
             if (identityNode) {
                 logger.info({ jid: from }, 'identity changed')
-                // not handling right now
-                // signal will override new identity anyway
+                
+                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 {
@@ -378,29 +509,35 @@ const makeMessagesRecvSocket = (config) => {
         }
     }
     
-    const handleGroupNotification = (participant, child, msg, mode) => {
-        let participantJid = mode === 'lid' ? getBinaryNodeChild(child, 'participant')?.attrs?.phone_number : getBinaryNodeChild(child, 'participant')?.attrs?.jid || participant
-        
-        // TODO: Add participant LID
-        switch (child.tag) {
+    const handleGroupNotification = (fullNode, child, msg) => {
+        // TODO: Support PN/LID (Here is only LID now)
+        const actingParticipantLid = fullNode.attrs.participant
+        const actingParticipantPn = fullNode.attrs.participant_pn
+        const affectedParticipantLid = getBinaryNodeChild(child, 'participant')?.attrs?.jid || actingParticipantLid
+        const affectedParticipantPn = getBinaryNodeChild(child, 'participant')?.attrs?.phone_number || actingParticipantPn
+        
+        switch (child?.tag) {
             case 'create':
                 const metadata = extractGroupMetadata(child)
                 msg.messageStubType = WAMessageStubType.GROUP_CREATE
                 msg.messageStubParameters = [metadata.subject]
-                msg.key = { participant: metadata.owner }
-                ev.emit('chats.upsert', [{
+                msg.key = { participant: metadata.owner, participantAlt: metadata.ownerPn }
+                
+                ev.emit('chats.upsert', [
+                    {
                         id: metadata.id,
                         name: metadata.subject,
-                        conversationTimestamp: metadata.creation,
-                    }])
-                ev.emit('groups.upsert', [{
+                        conversationTimestamp: metadata.creation
+                    }
+                ])
+                
+                ev.emit('groups.upsert', [
+                    {
                         ...metadata,
-                        author: participant
-                    }])
-                break
-            case 'delete':
-                msg.messageStubType = WAMessageStubType.COMMUNITY_PARENT_GROUP_DELETED
-                msg.messageStubParameters = [participantJid, 'delete']
+                        author: actingParticipantLid,
+                        authorPn: actingParticipantPn
+                    }
+                ])
                 break
             case 'ephemeral':
             case 'not_ephemeral':
@@ -412,7 +549,7 @@ const makeMessagesRecvSocket = (config) => {
                 }
                 break
             case 'modify':
-                const oldNumber = mode === 'lid' ? getBinaryNodeChildren(child, 'participant').map(p => p.attrs.phone_number) : getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
+                const oldNumber = getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
                 msg.messageStubParameters = oldNumber || []
                 msg.messageStubType = WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER
                 break
@@ -421,24 +558,32 @@ const makeMessagesRecvSocket = (config) => {
             case 'remove':
             case 'add':
             case 'leave':
-                let stubType = `GROUP_PARTICIPANT_${child.tag.toUpperCase()}`
-                if (child.attrs?.reason === 'linked_group_join') {
-                	stubType = GROUP_PARTICIPANT_LINKED_GROUP_JOIN
-                }
+                const stubType = `GROUP_PARTICIPANT_${child.tag.toUpperCase()}`
                 msg.messageStubType = WAMessageStubType[stubType]
-                const participants =  mode === 'lid' ? getBinaryNodeChildren(child, 'participant').map(p => p.attrs.phone_number) : getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
+                const participants = getBinaryNodeChildren(child, 'participant').map(({ attrs }) => {
+                    // TODO: Store LID MAPPINGS
+                    return {
+                        id: attrs.jid,
+                        phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
+                        lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+                        admin: (attrs.type || null)
+                    }
+                })
+                
                 if (participants.length === 1 &&
                     // if recv. "remove" message and sender removed themselves
                     // mark as left
-                    areJidsSameUser(participants[0], participant) &&
+                    (areJidsSameUser(participants[0].id, actingParticipantLid) ||
+                        areJidsSameUser(participants[0].id, actingParticipantPn)) &&
                     child.tag === 'remove') {
                     msg.messageStubType = WAMessageStubType.GROUP_PARTICIPANT_LEAVE
                 }
-                msg.messageStubParameters = participants
+                
+                msg.messageStubParameters = participants.map(a => JSON.stringify(a))
                 break
             case 'subject':
                 msg.messageStubType = WAMessageStubType.GROUP_CHANGE_SUBJECT
-                msg.messageStubParameters = [participantJid, child.attrs.subject]
+                msg.messageStubParameters = [child.attrs.subject]
                 break
             case 'description':
                 const description = getBinaryNodeChild(child, 'body')?.content?.toString()
@@ -448,19 +593,19 @@ const makeMessagesRecvSocket = (config) => {
             case 'announcement':
             case 'not_announcement':
                 msg.messageStubType = WAMessageStubType.GROUP_CHANGE_ANNOUNCE
-                msg.messageStubParameters = [(child.tag === 'announcement') ? 'on' : 'off']
+                msg.messageStubParameters = [child.tag === 'announcement' ? 'on' : 'off']
                 break
             case 'locked':
             case 'unlocked':
                 msg.messageStubType = WAMessageStubType.GROUP_CHANGE_RESTRICT
-                msg.messageStubParameters = [(child.tag === 'locked') ? 'on' : 'off']
+                msg.messageStubParameters = [child.tag === 'locked' ? 'on' : 'off']
                 break
             case 'invite':
                 msg.messageStubType = WAMessageStubType.GROUP_CHANGE_INVITE_LINK
                 msg.messageStubParameters = [child.attrs.code]
                 break
             case 'member_add_mode':
-                const addMode = child.content
+                const addMode = child.content;
                 if (addMode) {
                     msg.messageStubType = WAMessageStubType.GROUP_MEMBER_ADD_MODE
                     msg.messageStubParameters = [addMode.toString()]
@@ -474,52 +619,21 @@ const makeMessagesRecvSocket = (config) => {
                 }
                 break
             case 'created_membership_requests':
-            participantJid = mode === 'lid' ? getBinaryNodeChild(child, 'requested_user')?.attrs?.phone_number : getBinaryNodeChild(child, 'requested_user')?.attrs?.jid || participant
-            
                 msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
-                msg.messageStubParameters = [participantJid, 'created', child.attrs.request_method]
+                msg.messageStubParameters = [
+                    JSON.stringify({ lid: affectedParticipantLid, pn: affectedParticipantPn }),
+                    'created',
+                    child.attrs.request_method
+                ]
                 break
             case 'revoked_membership_requests':
-            participantJid = mode === 'lid' ? getBinaryNodeChild(child, 'requested_user')?.attrs?.phone_number : getBinaryNodeChild(child, 'requested_user')?.attrs?.jid || participant
-            
-                const isDenied = areJidsSameUser(participantJid, participant)
+                const isDenied = areJidsSameUser(affectedParticipantLid, actingParticipantLid)
+                // TODO: LIDMAPPING SUPPORT
                 msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
-                msg.messageStubParameters = [participantJid, isDenied ? 'revoked' : 'rejected']
-                break
-            case 'link':
-            case 'unlink':
-                const type = child.attrs?.unlink_type || child.attrs?.link_type
-                const stubMap = {
-                	parent_group: WAMessageStubType[`COMMUNITY_${child.tag.toUpperCase()}_PARENT_GROUP`],
-                    sibling_group: WAMessageStubType[`COMMUNITY_${child.tag.toUpperCase()}_SIBLING_GROUP`],
-                    sub_group: WAMessageStubType[`COMMUNITY_${child.tag.toUpperCase()}_SUB_GROUP`]
-                }
-                const groups = getBinaryNodeChildren(child, 'group')
-                    .map(g => g.attrs?.jid || g.attrs?.subject || '')
-                    .filter(x => x)
-                msg.messageStubType = stubMap?.[type] || WAMessageStubType[`COMMUNITY_${child.tag.toUpperCase()}_PARENT_GROUP`]
-                msg.messageStubParameters = [participantJid, child.tag, groups]
-                break
-            case 'linked_group_promote':
-            case 'linked_group_demote':
-                const stubtype = `COMMUNITY_PARTICIPANT_${child.tag.split('_')[2].toUpperCase()}`
-                const participantS =  mode === 'lid' ? getBinaryNodeChildren(child, 'participant').map(p => p.attrs.phone_number) : getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
-                msg.messageStubType = WAMessageStubType[stubtype]
-                msg.messageStubParameters = participantS
-                break
-            case 'created_sub_group_suggestion':    
-                msg.messageStubType = WAMessageStubType.SUGGESTED_SUBGROUP_ANNOUNCE
-                msg.messageStubParameters = [participantJid, 'add']
-                break
-            case 'revoked_sub_group_suggestions':
-                const res = getBinaryNodeChildren(child, 'sub_group_suggestions')
-                const reason = res.attrs?.reason 
-                if (reason === 'approved') msg.messageStubType = WAMessageStubType.GROUP_CREATE
-                else msg.messageStubType = WAMessageStubType.GENERIC_NOTIFICATION
-                msg.messageStubParameters = [participantJid, reason]
-                break
-            default:
-                logger.warn(child.tag, 'Unhandled group node') 
+                msg.messageStubParameters = [
+                    JSON.stringify({ lid: affectedParticipantLid, pn: affectedParticipantPn }),
+                    isDenied ? 'revoked' : 'rejected'
+                ]
                 break
         }
     }
@@ -637,22 +751,9 @@ const makeMessagesRecvSocket = (config) => {
         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 'w:gp2':
-                const mode = node.attrs.addressing_mode
-                handleGroupNotification(mode === 'lid' ? node.attrs.participant_pn : node.attrs.participant, child, result, mode)
+                // TODO: HANDLE PARTICIPANT_PN
+                handleGroupNotification(node, child, result)
                 break
             case 'newsletter':
                 handleNewsletterNotification(node.attrs.from, child) 
@@ -686,20 +787,27 @@ const makeMessagesRecvSocket = (config) => {
             case 'picture':
                 const setPicture = getBinaryNodeChild(node, 'set')
                 const delPicture = getBinaryNodeChild(node, 'delete')
-                ev.emit('contacts.update', [{
+                
+                ev.emit('contacts.update', [
+                    {
                         id: jidNormalizedUser(node?.attrs?.from) || (setPicture || delPicture)?.attrs?.hash || '',
                         imgUrl: setPicture ? 'changed' : 'removed'
-                    }])
+                    }
+                ])
+                
                 if (isJidGroup(from)) {
                     const node = setPicture || delPicture
+                    
                     result.messageStubType = WAMessageStubType.GROUP_CHANGE_ICON
+                    
                     if (setPicture) {
                         result.messageStubParameters = [setPicture.attrs.id]
                     }
-                    result.participant = node?.attrs?.author
+                    
+                    result.participant = node?.attrs.author
                     result.key = {
-                        ...result.key || {},
-                        participant: setPicture?.attrs?.author
+                        ...(result.key || {}),
+                        participant: setPicture?.attrs.author
                     }
                 }
                 break
@@ -713,16 +821,17 @@ const makeMessagesRecvSocket = (config) => {
                             ...authState.creds.accountSettings,
                             defaultDisappearingMode: {
                                 ephemeralExpiration: newDuration,
-                                ephemeralSettingTimestamp: timestamp,
-                            },
+                                ephemeralSettingTimestamp: timestamp
+                            }
                         }
                     })
                 }
+                
                 else if (child.tag === 'blocklist') {
                     const blocklists = getBinaryNodeChildren(child, 'item')
                     for (const { attrs } of blocklists) {
                         const blocklist = [attrs.jid]
-                        const type = (attrs.action === 'block') ? 'add' : 'remove'
+                        const type = attrs.action === 'block' ? 'add' : 'remove'
                         ev.emit('blocklist.update', { blocklist, type })
                     }
                 }
@@ -736,13 +845,15 @@ 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, {
                     salt: linkCodeSalt,
                     info: 'link_code_pairing_key_bundle_encryption_key'
                 })
-                
-                const encryptPayload = Buffer.concat([Buffer.from(authState.creds.signedIdentityKey.public), primaryIdentityPublicKey, random])
+                const encryptPayload = Buffer.concat([
+                    Buffer.from(authState.creds.signedIdentityKey.public),
+                    primaryIdentityPublicKey,
+                    random
+                ])
                 const encryptIv = randomBytes(12)
                 const encrypted = aesEncryptGCM(encryptPayload, linkCodePairingExpanded, encryptIv, Buffer.alloc(0))
                 const encryptedPayload = Buffer.concat([linkCodeSalt, encryptIv, encrypted])
@@ -764,7 +875,7 @@ const makeMessagesRecvSocket = (config) => {
                             tag: 'link_code_companion_reg',
                             attrs: {
                                 jid: authState.creds.me.id,
-                                stage: 'companion_finish',
+                                stage: 'companion_finish'
                             },
                             content: [
                                 {
@@ -789,6 +900,10 @@ const makeMessagesRecvSocket = (config) => {
                 
                 authState.creds.registered = true
                 ev.emit('creds.update', authState.creds)
+                break
+            case 'privacy_token':
+                await handlePrivacyTokenNotification(node)
+                break
         }
         
         if (Object.keys(result).length) {
@@ -796,6 +911,33 @@ const makeMessagesRecvSocket = (config) => {
         }
     }
     
+    const handlePrivacyTokenNotification = async (node) => {
+        const tokensNode = getBinaryNodeChild(node, 'tokens')
+        const from = jidNormalizedUser(node.attrs.from)
+        
+        if (!tokensNode) return
+        
+        const tokenNodes = getBinaryNodeChildren(tokensNode, 'token')
+        
+        for (const tokenNode of tokenNodes) {
+            const { attrs, content } = tokenNode
+            const type = attrs.type
+            const timestamp = attrs.t
+            
+            if (type === 'trusted_contact' && content instanceof Buffer) {
+                logger.debug({
+                    from,
+                    timestamp,
+                    tcToken: content
+                }, 'received trusted contact token')
+                
+                await authState.keys.set({
+                    tctoken: { [from]: { token: content, timestamp } }
+                })
+            }
+        }
+    }
+    
     async function decipherLinkPublicKey(data) {
         const buffer = toRequiredBuffer(data)
         const salt = buffer.slice(0, 32)
@@ -838,6 +980,7 @@ const makeMessagesRecvSocket = (config) => {
             // Try to get from retry cache first if enabled
             if (messageRetryManager) {
                 const cachedMsg = messageRetryManager.getRecentMessage(remoteJid, id)
+                
                 if (cachedMsg) {
                     msg = cachedMsg.message
                     logger.debug({ jid: remoteJid, id }, 'found message in retry cache')
@@ -850,15 +993,17 @@ const makeMessagesRecvSocket = (config) => {
             // Fallback to getMessage if not found in cache
             if (!msg) {
                 msg = await getMessage({ ...key, id })
+                
                 if (msg) {
                     logger.debug({ jid: remoteJid, id }, 'found message via getMessage')
                     
                     // Also mark as successful if found via getMessage
                     if (messageRetryManager) {
-                        messageRetryManager.markRetrySuccess(id);
+                        messageRetryManager.markRetrySuccess(id)
                     }
                 }
             }
+            
             msgs.push(msg)
         }
         
@@ -881,41 +1026,45 @@ const makeMessagesRecvSocket = (config) => {
                 recreateReason = result.reason
                 
                 if (shouldRecreateSession) {
-                    logger.info({ participant, retryCount, reason: recreateReason }, 'recreating session for outgoing retry')
-                    await authState.keys.set({ session: { [sessionId]: null } });
+                    logger.debug({ participant, retryCount, reason: recreateReason }, 'recreating session for outgoing retry')
+                    await authState.keys.set({ session: { [sessionId]: null } })
                 }
             }
+            
             catch (error) {
                 logger.warn({ error, participant }, 'failed to check session recreation for outgoing retry')
             }
         }
         
-        await assertSessions([participant], shouldRecreateSession)
+        await assertSessions([participant], true)
         
         if (isJidGroup(remoteJid)) {
-            await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } });
+            await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } })
         }
+        
         logger.debug({ participant, sendToAll, shouldRecreateSession, recreateReason }, 'forced new session for retry recp')
         
         for (const [i, msg] of msgs.entries()) {
-            if (!ids[i])
-                continue
-                
+            if (!ids[i]) continue
+            
             if (msg && (await willSendMessageAgain(ids[i], participant))) {
-                updateSendMessageAgainCount(ids[i], participant)
+                await updateSendMessageAgainCount(ids[i], participant)
                 const msgRelayOpts = { messageId: ids[i] }
                 
                 if (sendToAll) {
                     msgRelayOpts.useUserDevicesCache = false
                 }
+                
                 else {
                     msgRelayOpts.participant = {
                         jid: participant,
                         count: +retryNode.attrs.count
                     }
                 }
+                
                 await relayMessage(key.remoteJid, msg, msgRelayOpts)
             }
+            
             else {
                 logger.debug({ jid: key.remoteJid, id: ids[i] }, 'recv retry request, but message not available')
             }
@@ -928,7 +1077,6 @@ const makeMessagesRecvSocket = (config) => {
         const isNodeFromMe = areJidsSameUser(attrs.participant || attrs.from, isLid ? authState.creds.me?.lid : authState.creds.me?.id)
         const remoteJid = !isNodeFromMe || isJidGroup(attrs.from) ? attrs.from : attrs.recipient
         const fromMe = !attrs.recipient || ((attrs.type === 'retry' || attrs.type === 'sender') && isNodeFromMe)
-        
         const key = {
             remoteJid,
             id: '',
@@ -936,13 +1084,14 @@ const makeMessagesRecvSocket = (config) => {
             participant: attrs.participant
         }
         
-        if (shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
+        if (shouldIgnoreJid(remoteJid) && remoteJid !== S_WHATSAPP_NET) {
             logger.debug({ remoteJid }, 'ignoring receipt from jid')
             await sendMessageAck(node)
             return
         }
         
         const ids = [attrs.id]
+        
         if (Array.isArray(content)) {
             const items = getBinaryNodeChildren(content[0], 'item')
             ids.push(...items.map(i => i.attrs.id))
@@ -950,17 +1099,17 @@ const makeMessagesRecvSocket = (config) => {
         
         try {
             await Promise.all([
-                processingMutex.mutex(async () => {
+                receiptMutex.mutex(async () => {
                     const status = getStatusFromReceiptType(attrs.type)
                     
-                    if (typeof status !== 'undefined' && (
+                    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 ||
-                            !isNodeFromMe)) {
+                        (status >= proto.WebMessageInfo.Status.SERVER_ACK || !isNodeFromMe)) {
                         if (isJidGroup(remoteJid) || isJidStatusBroadcast(remoteJid)) {
                             if (attrs.participant) {
                                 const updateKey = status === proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp'
+                                
                                 ev.emit('message-receipt.update', ids.map(id => ({
                                     key: { ...key, id },
                                     receipt: {
@@ -982,13 +1131,16 @@ const makeMessagesRecvSocket = (config) => {
                     if (attrs.type === 'retry') {
                         // correctly set who is asking for the retry
                         key.participant = key.participant || attrs.from
+                        
                         const retryNode = getBinaryNodeChild(node, 'retry')
                         
                         if (ids[0] && key.participant && (await willSendMessageAgain(ids[0], key.participant))) {
                             if (key.fromMe) {
                                 try {
-                                    updateSendMessageAgainCount(ids[0], key.participant)
+                                    await updateSendMessageAgainCount(ids[0], key.participant)
+                                    
                                     logger.debug({ attrs, key }, 'recv retry request')
+                                    
                                     await sendMessagesAgain(key, ids, retryNode)
                                 }
                                 
@@ -1009,6 +1161,7 @@ const makeMessagesRecvSocket = (config) => {
                 })
             ])
         }
+        
         finally {
             await sendMessageAck(node)
         }
@@ -1016,8 +1169,7 @@ const makeMessagesRecvSocket = (config) => {
     
     const handleNotification = async (node) => {
         const remoteJid = node.attrs.from
-        
-        if (shouldIgnoreJid(remoteJid) && remoteJid !== '@s.whatsapp.net') {
+        if (shouldIgnoreJid(remoteJid) && remoteJid !== S_WHATSAPP_NET) {
             logger.debug({ remoteJid, id: node.attrs.id }, 'ignored notification')
             await sendMessageAck(node)
             return
@@ -1025,40 +1177,46 @@ 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)
+                        const { senderAlt: participantAlt, addressingMode } = extractAddressingContext(node)
+                        
                         msg.key = {
                             remoteJid,
                             fromMe,
                             participant: node.attrs.participant,
+                            participantAlt,
+                            addressingMode,
                             id: node.attrs.id,
                             ...(msg.key || {})
                         }
-                        msg.participant = msg.participant ? msg.participant : node.attrs.participant
+                        
+                        msg.participant ?? (msg.participant = node.attrs.participant)
                         msg.messageTimestamp = +node.attrs.t
+                        
                         const fullMsg = proto.WebMessageInfo.fromObject(msg)
+                        
                         await upsertMessage(fullMsg, 'append')
                     }
                 })
             ])
         }
+        
         finally {
             await sendMessageAck(node)
         }
     }
     
     const handleMessage = async (node) => {
-        if (shouldIgnoreJid(node.attrs.from) && node.attrs.from !== '@s.whatsapp.net') {
+        if (shouldIgnoreJid(node.attrs.from) && node.attrs.from !== S_WHATSAPP_NET) {
             logger.debug({ key: node.attrs.key }, 'ignored message')
-            await sendMessageAck(node)
+            await sendMessageAck(node, NACK_REASONS.UnhandledError)
             return
         }
         
-        let response
-        
         const encNode = getBinaryNodeChild(node, 'enc')
         
         // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
@@ -1068,53 +1226,23 @@ const makeMessagesRecvSocket = (config) => {
             return
         }
         
-        if (getBinaryNodeChild(node, 'unavailable') && !encNode) {
-            await sendMessageAck(node)
-            const { key } = decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '').fullMessage
-            response = await requestPlaceholderResend(key);
-            if (response === 'RESOLVED') {
-                return
-            }
-            logger.debug('received unavailable message, acked and requested resend from phone');
-        }
-        else {
-            if (placeholderResendCache.get(node.attrs.id)) {
-                await placeholderResendCache.del(node.attrs.id)
-            }
-        }
-        
-        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]
-        }
-        
-        if (msg.message?.protocolMessage?.type === proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER &&
-            node.attrs.sender_pn) {
-            const lid = jidNormalizedUser(node.attrs.from), pn = jidNormalizedUser(node.attrs.sender_pn)
-            ev.emit('lid-mapping.update', { lid, pn })
-            await signalRepository.lidMapping.storeLIDPNMappings([{ lid, pn }])
-        }
-        
-        const alt = msg.key.participantAlt || msg.key.remoteJidAlt
-        
+        const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger);
+        const alt = msg.key.participantAlt || msg.key.remoteJidAlt;
         // store new mappings we didn't have before
         if (!!alt) {
             const altServer = jidDecode(alt)?.server
+            const primaryJid = msg.key.participant || msg.key.remoteJid
             
             if (altServer === 'lid') {
-                if (typeof (await signalRepository.lidMapping.getPNForLID(alt)) === 'string') {
-                    await signalRepository.lidMapping.storeLIDPNMappings([
-                        { lid: alt, pn: msg.key.participant || msg.key.remoteJid }
-                    ])
+                if (!(await signalRepository.lidMapping.getPNForLID(alt))) {
+                    await signalRepository.lidMapping.storeLIDPNMappings([{ lid: alt, pn: primaryJid }])
+                    await signalRepository.migrateSession(primaryJid, alt)
                 }
             }
+            
             else {
-                if (typeof (await signalRepository.lidMapping.getLIDForPN(alt)) === 'string') {
-                    await signalRepository.lidMapping.storeLIDPNMappings([
-                        { lid: msg.key.participant || msg.key.remoteJid, pn: alt }
-                    ])
-                }
+                await signalRepository.lidMapping.storeLIDPNMappings([{ lid: primaryJid, pn: alt }])
+                await signalRepository.migrateSession(alt, primaryJid)
             }
         }
         
@@ -1127,70 +1255,83 @@ const makeMessagesRecvSocket = (config) => {
         }
         
         try {
-            await Promise.all([
-                processingMutex.mutex(async () => {
-                    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)
-                        }
-                        
-                        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
-                        retryMutex.mutex(async () => {
-                            try {
-                                if (!ws.isOpen) {
-                                    logger.debug({ node }, 'Connection closed, skipping retry')
-                                    return
-                                }
+            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 ||
+                        msg.messageStubParameters?.[0] === NO_MESSAGE_FOUND_ERROR_TEXT) {
+                        return sendMessageAck(node)
+                    }
+                    
+                    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')
                                 
-                                if (getBinaryNodeChild(node, 'unavailable')) {
-                                    logger.debug('Message unavailable, skipping retry')
-                                    return
+                                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)
                                 }
                                 
-                                // 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')
-                                    }
+                                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 (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)
-                                if (retryRequestDelayMs) {
-                                    await delay(retryRequestDelayMs)
-                                }
                             }
-                            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')
-                                }
+                            
+                            catch (retryErr) {
+                                logger.error({ retryErr }, 'Failed to send retry after error handling')
                             }
-                        })
+                        }
+                        
+                        await sendMessageAck(node, NACK_REASONS.UnhandledError)
+                    })
+                }
+                
+                else {
+                    if (messageRetryManager && msg.key.id) {
+                        messageRetryManager.cancelPendingPhoneRequest(msg.key.id)
                     }
                     
-                    else {
+                    const isNewsletter = isJidNewsletter(msg.key.remoteJid)
+                    
+                    if (!isNewsletter) {
                         // no type in the receipt => message delivered
                         let type = undefined
-                        
                         let participant = msg.key.participant
                         
                         if (category === 'peer') {
@@ -1211,124 +1352,60 @@ const makeMessagesRecvSocket = (config) => {
                         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')
+                            await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync') // TODO: investigate
                         }
                     }
-                    cleanMessage(msg, authState.creds.me.id)
-                    await sendMessageAck(node)
-                    await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify')
-                })
-            ])
+                    
+                    else {
+                        await sendMessageAck(node)
+                        logger.debug({ key: msg.key }, 'processed newsletter message without receipts')
+                    }
+                }
+                
+                cleanMessage(msg, authState.creds.me.id, authState.creds.me.lid)
+                
+                await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify')
+            }) 
         }
         
         catch (error) {
-            logger.error({ error, node }, 'error in handling message')
-        }
-    }
-    
-    const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
-        if (!authState.creds.me?.id) {
-            throw new Boom('Not authenticated')
-        }
-        
-        const pdoMessage = {
-            historySyncOnDemandRequest: {
-                chatJid: oldestMsgKey.remoteJid,
-                oldestMsgFromMe: oldestMsgKey.fromMe,
-                oldestMsgId: oldestMsgKey.id,
-                oldestMsgTimestampMs: oldestMsgTimestamp,
-                onDemandMsgCount: count
-            },
-            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
+            logger.error({ error, node: binaryNodeToString(node) }, 'error in handling message')
         }
-        
-        return sendPeerDataOperationMessage(pdoMessage)
-    }
-    
-    const requestPlaceholderResend = async (messageKey) => {
-        if (!authState.creds.me?.id) {
-            throw new Boom('Not authenticated')
-        }
-        
-        if (placeholderResendCache.get(messageKey?.id)) {
-            logger.debug({ messageKey }, 'already requested resend')
-            return
-        }
-        
-        else {
-            placeholderResendCache.set(messageKey?.id, true)
-        }
-        
-        await delay(5000)
-        
-        if (!placeholderResendCache.get(messageKey?.id)) {
-            logger.debug({ messageKey }, 'message received while resend requested')
-            return 'RESOLVED'
-        }
-        
-        const pdoMessage = {
-            placeholderMessageResendRequest: [{
-                    messageKey
-                }],
-            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
-        }
-        
-        setTimeout(() => {
-            if (placeholderResendCache.get(messageKey?.id)) {
-                logger.debug({ messageKey }, 'PDO message without response after 15 seconds. Phone possibly offline')
-                placeholderResendCache.del(messageKey?.id)
-            }
-        }, 15000)
-        
-        return sendPeerDataOperationMessage(pdoMessage)
     }
     
     const handleCall = async (node) => {
-    	let status
-    
         const { attrs } = node
         const [infoChild] = getAllBinaryNodeChildren(node)
-        const callId = infoChild.attrs['call-id']
-        const from = infoChild.attrs.from || infoChild.attrs['call-creator']
-        status =  getCallStatusFromNode(infoChild)
-        
-        if (isLidUser(from) && infoChild.tag === 'relaylatency') {
-        	const verify = await callOfferCache.get(callId) 
-        
-        	if (!verify) {
-        		status = 'offer'
-        
-        		const callLid = {
-        			chatId: attrs.from, 
-        			from, 
-        			id: callId, 
-        			date: new Date(+attrs.t * 1000), 
-        			offline: !!attrs.offline, 
-        			status
-        		}
-        		await callOfferCache.set(callId, callLid) 
-        	}
+        const status = getCallStatusFromNode(infoChild)
+        
+        if (!infoChild) {
+            throw new Boom('Missing call info in call node')
         }
         
+        const callId = infoChild.attrs['call-id']
+        const from = infoChild.attrs.from || infoChild.attrs['call-creator']
         const call = {
             chatId: attrs.from,
             from,
             id: callId,
             date: new Date(+attrs.t * 1000),
             offline: !!attrs.offline,
-            status,
+            status
         }
         
         if (status === 'offer') {
             call.isVideo = !!getBinaryNodeChild(infoChild, 'video')
             call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid']
             call.groupJid = infoChild.attrs['group-jid']
+            
             await callOfferCache.set(call.id, call)
         }
         
@@ -1351,7 +1428,8 @@ const makeMessagesRecvSocket = (config) => {
     }
     
     const handleBadAck = async ({ attrs }) => {
-        const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id, newsletter_server_id: attrs?.server_id }
+        const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id }
+        
         // WARNING: REFRAIN FROM ENABLING THIS FOR NOW. IT WILL CAUSE A LOOP
         // // current hypothesis is that if pash is sent in the ack
         // // it means -- the message hasn't reached all devices yet
@@ -1374,12 +1452,24 @@ const makeMessagesRecvSocket = (config) => {
                     key,
                     update: {
                         status: WAMessageStatus.ERROR,
-                        messageStubParameters: [
-                            attrs.error
-                        ]
+                        messageStubParameters: [attrs.error]
                     }
                 }
             ])
+            
+            // resend the message with device_fanout=false, use at your own risk
+            // if (attrs.error === '475') {
+            // 	const msg = await getMessage(key)
+            // 	if (msg) {
+            // 		await relayMessage(key.remoteJid!, msg, {
+            // 			messageId: key.id!,
+            // 			useUserDevicesCache: false,
+            // 			additionalAttributes: {
+            // 				device_fanout: 'false'
+            // 			}
+            // 		})
+            // 	}
+            // }
         }
     }
     
@@ -1389,12 +1479,17 @@ const makeMessagesRecvSocket = (config) => {
         ev.buffer()
         await execTask()
         ev.flush()
+        
         function execTask() {
-            return exec(node, false)
-                .catch(err => onUnexpectedError(err, identifier))
+            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],
@@ -1404,8 +1499,12 @@ 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 })
             
@@ -1416,17 +1515,32 @@ 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)
+                    
                     if (!nodeProcessor) {
                         onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node')
                         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
             }
+            
             promise().catch(error => onUnexpectedError(error, 'processing offline nodes'))
         }
         
@@ -1435,7 +1549,7 @@ const makeMessagesRecvSocket = (config) => {
     
     const offlineNodeProcessor = makeOfflineNodeProcessor()
     
-    const processNode = (type, node, identifier, exec) => {
+    const processNode = async (type, node, identifier, exec) => {
         const isOffline = !!node.attrs.offline
         
         if (isOffline) {
@@ -1443,28 +1557,36 @@ const makeMessagesRecvSocket = (config) => {
         }
         
         else {
-            processNodeWithBuffer(node, identifier, exec)
+            await processNodeWithBuffer(node, identifier, exec)
         }
     }
     
     // recv a message
-    ws.on('CB:message', (node) => {
-        processNode('message', node, 'processing message', handleMessage)
+    ws.on('CB:message', async (node) => {
+        await processNode('message', node, 'processing message', handleMessage)
     })
+    
     ws.on('CB:call', async (node) => {
-        processNode('call', node, 'handling call', handleCall)
+        await processNode('call', node, 'handling call', handleCall)
     })
-    ws.on('CB:receipt', node => {
-        processNode('receipt', node, 'handling receipt', handleReceipt)
+    
+    ws.on('CB:receipt', async (node) => {
+        await processNode('receipt', node, 'handling receipt', handleReceipt)
     })
+    
     ws.on('CB:notification', async (node) => {
-        processNode('notification', node, 'handling notification', handleNotification)
+        await processNode('notification', node, 'handling notification', handleNotification)
     })
+    
     ws.on('CB:ack,class:message', (node) => {
-        handleBadAck(node)
-            .catch(error => onUnexpectedError(error, 'handling bad ack'))
+        handleBadAck(node).catch(error => onUnexpectedError(error, 'handling bad ack'))
     })
-    ev.on('call', ([call]) => {
+    
+    ev.on('call', async ([call]) => {
+        if (!call) {
+            return;
+        }
+        
         // missed call + group call notification message generation
         if (call.status === 'timeout' || (call.status === 'offer' && call.isGroup)) {
             const msg = {
@@ -1473,12 +1595,14 @@ const makeMessagesRecvSocket = (config) => {
                     id: call.id,
                     fromMe: false
                 },
-                messageTimestamp: unixTimestampSeconds(call.date),
+                messageTimestamp: unixTimestampSeconds(call.date)
             }
             
             if (call.status === 'timeout') {
                 if (call.isGroup) {
-                    msg.messageStubType = call.isVideo ? WAMessageStubType.CALL_MISSED_GROUP_VIDEO : WAMessageStubType.CALL_MISSED_GROUP_VOICE
+                    msg.messageStubType = call.isVideo
+                        ? WAMessageStubType.CALL_MISSED_GROUP_VIDEO
+                        : WAMessageStubType.CALL_MISSED_GROUP_VOICE
                 }
                 
                 else {
@@ -1487,11 +1611,12 @@ const makeMessagesRecvSocket = (config) => {
             }
             
             else {
-                msg.message = { call: { callKey: Buffer.from(call.id) } }
+                msg.message = { call: { callKey: Buffer.from(call.id) } };
             }
             
             const protoMsg = proto.WebMessageInfo.fromObject(msg)
-            upsertMessage(protoMsg, call.offline ? 'append' : 'notify')
+            
+            await upsertMessage(protoMsg, call.offline ? 'append' : 'notify')
         }
     })