@hansaka02/baileys 7.3.2 → 7.3.6

package/lib/Socket/messages-recv.js

@@ -1,48 +1,192 @@
 "use strict"
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod }
-}
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const node_cache_1 = __importDefault(require("@cacheable/node-cache"))
-const boom_1 = require("@hapi/boom")
-const crypto_1 = require("crypto")
-const WAProto_1 = require("../../WAProto")
-const Defaults_1 = require("../Defaults")
-const Types_1 = require("../Types")
-const Utils_1 = require("../Utils")
-const WABinary_1 = require("../WABinary")
-const groups_1 = require("./groups")
-const make_mutex_1 = require("../Utils/make-mutex")
-const messages_send_1 = require("./messages-send")
+const { default: NodeCache } = require("@cacheable/node-cache")
+const { Boom } = require("@hapi/boom")
+const { randomBytes } = require("crypto")
+const { proto } = require("../../WAProto")
+const {
+  KEY_BUNDLE_TYPE, 
+  MIN_PREKEY_COUNT, 
+  DEFAULT_CACHE_TTLS
+} = require("../Defaults/constants")
+const {
+  XWAPaths, 
+  XWAPathsMexUpdates, 
+  MexOperations, 
+  MexUpdatesOperations, 
+  WAMessageStubType,
+  WAMessageStatus
+} = require("../Types")
+const { 
+  aesDecryptCTR, 
+  aesEncryptGCM, 
+  cleanMessage, 
+  Curve, 
+  decodeMediaRetryNode, 
+  decodeMessageNode, 
+  decryptMessageNode, 
+  delay, 
+  derivePairingCodeKey, 
+  encodeBigEndian, 
+  encodeSignedDeviceIdentity, 
+  extractAddressingContext,
+  getCallStatusFromNode,
+  getHistoryMsg, 
+  getNextPreKeys, 
+  getStatusFromReceiptType, 
+  hkdf,
+  NO_MESSAGE_FOUND_ERROR_TEXT, 
+  MISSING_KEYS_ERROR_TEXT, 
+  NACK_REASONS, 
+  unixTimestampSeconds, 
+  xmppPreKey, 
+  xmppSignedPreKey, 
+  generateMessageID
+} = require("../Utils")
+const { 
+  areJidsSameUser,
+  binaryNodeToString, 
+  getAllBinaryNodeChildren, 
+  getBinaryNodeChild, 
+  getBinaryNodeChildBuffer, 
+  getBinaryNodeChildren, 
+  getBinaryNodeChildString, 
+  isJidGroup, 
+  isJidNewsletter, 
+  isJidStatusBroadcast, 
+  isLidUser,
+  isPnUser, 
+  jidDecode, 
+  jidNormalizedUser, 
+  S_WHATSAPP_NET 
+} = require("../WABinary")
+const { extractGroupMetadata } = require("./groups")
+const { makeMutex } = require("../Utils/make-mutex")
+const { makeMessagesSocket } = require("./messages-send")
 
 const makeMessagesRecvSocket = (config) => {
-    const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid, enableAutoSessionRecreation } = config
-    const suki = messages_send_1.makeMessagesSocket(config)
-    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, groupMetadata, getUSyncDevices, createParticipantNodes, messageRetryManager, sendPeerDataOperationMessage } = suki
+    const { 
+        logger, 
+        retryRequestDelayMs,
+        maxMsgRetryCount, 
+        getMessage, 
+        shouldIgnoreJid, 
+        enableAutoSessionRecreation 
+    } = config
+	
+    const suki = makeMessagesSocket(config)
+    
+    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 = make_mutex_1.makeMutex()
+    const retryMutex = makeMutex()
+    
+    const msgRetryCache = config.msgRetryCounterCache || new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY,
+        useClones: false
+    })
     
-    const msgRetryCache = config.msgRetryCounterCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY,
+    const callOfferCache = config.callOfferCache || new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.CALL_OFFER,
         useClones: false
     })
     
-    const callOfferCache = config.callOfferCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.CALL_OFFER,
+    const placeholderResendCache = config.placeholderResendCache || new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY,
         useClones: false
     })
     
-    const placeholderResendCache = config.placeholderResendCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY,
+    // 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',
@@ -65,11 +209,11 @@ const makeMessagesRecvSocket = (config) => {
             stanza.attrs.recipient = attrs.recipient
         }
         
-        if (!!attrs.type && (tag !== 'message' || WABinary_1.getBinaryNodeChild({ tag, attrs, content }, 'unavailable') || errorCode !== 0)) {
+        if (!!attrs.type && (tag !== 'message' || getBinaryNodeChild({ tag, attrs, content }, 'unavailable') || errorCode !== 0)) {
             stanza.attrs.type = attrs.type
         }
         
-        if (tag === 'message' && WABinary_1.getBinaryNodeChild({ tag, attrs, content }, 'unavailable')) {
+        if (tag === 'message' && getBinaryNodeChild({ tag, attrs, content }, 'unavailable')) {
             stanza.attrs.from = authState.creds.me.id
         }
         
@@ -78,7 +222,7 @@ const makeMessagesRecvSocket = (config) => {
     }
     
     const offerCall = async (toJid, isVideo = false) => {
-        const callId = crypto_1.randomBytes(16).toString('hex').toUpperCase().substring(0, 64)
+        const callId = randomBytes(16).toString('hex').toUpperCase().substring(0, 64)
         const offerContent = []
         offerContent.push({ tag: 'audio', attrs: { enc: 'opus', rate: '16000' }, content: undefined })
         offerContent.push({ tag: 'audio', attrs: { enc: 'opus', rate: '8000' }, content: undefined })
@@ -94,8 +238,8 @@ const makeMessagesRecvSocket = (config) => {
         offerContent.push({ tag: 'capability', attrs: { ver: '1' }, content: new Uint8Array([1, 4, 255, 131, 207, 4]) })
         offerContent.push({ tag: 'encopt', attrs: { keygen: '2' }, content: undefined })
         
-        const encKey = crypto_1.randomBytes(32)
-        const devices = (await getUSyncDevices([toJid], true, false)).map(({ user, device }) => WABinary_1.jidEncode(user, 's.whatsapp.net', device))
+        const encKey = randomBytes(32)
+        const devices = (await getUSyncDevices([toJid], true, false)).map(({ user, device }) => jidEncode(user, 's.whatsapp.net', device))
         await assertSessions(devices, true)
         
         const { nodes: destinations, shouldIncludeDeviceIdentity } = await createParticipantNodes(devices, {
@@ -109,14 +253,14 @@ const makeMessagesRecvSocket = (config) => {
             offerContent.push({
                 tag: 'device-identity',
                 attrs: {},
-                content: Utils_1.encodeSignedDeviceIdentity(authState.creds.account, true)
+                content: encodeSignedDeviceIdentity(authState.creds.account, true)
             })
         }
         
         const stanza = ({
             tag: 'call',
             attrs: {
-                id: Utils_1.generateMessageID(),
+                id: generateMessageID(),
                 to: toJid,
             },
             content: [{
@@ -159,7 +303,7 @@ const makeMessagesRecvSocket = (config) => {
     }
     
     const sendRetryRequest = async (node, forceIncludeKeys = false) => {
-        const { fullMessage } = Utils_1.decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '')
+        const { fullMessage } = decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '')
         const { key: msgKey } = fullMessage
         const msgId = msgKey.id
         
@@ -176,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)
         }
         
@@ -213,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')
             }
@@ -230,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 = Utils_1.encodeSignedDeviceIdentity(account, true)
+        const deviceIdentity = encodeSignedDeviceIdentity(account, true)
+        
         await authState.keys.transaction(async () => {
             const receipt = {
                 tag: 'receipt',
@@ -261,13 +418,15 @@ const makeMessagesRecvSocket = (config) => {
                             count: retryCount.toString(),
                             id: node.attrs.id,
                             t: node.attrs.t,
-                            v: '1'
+                            v: '1',
+                            // ADD ERROR FIELD
+                            error: '0'
                         }
                     },
                     {
                         tag: 'registration',
                         attrs: {},
-                        content: Utils_1.encodeBigEndian(authState.creds.registrationId)
+                        content: encodeBigEndian(authState.creds.registrationId)
                     }
                 ]
             }
@@ -281,7 +440,7 @@ const makeMessagesRecvSocket = (config) => {
             }
             
             if (retryCount > 1 || forceIncludeKeys || shouldRecreateSession) {
-                const { update, preKeys } = await Utils_1.getNextPreKeys(authState, 1)
+                const { update, preKeys } = await getNextPreKeys(authState, 1)
                 const [keyId] = Object.keys(preKeys)
                 const key = preKeys[+keyId]
                 const content = receipt.content
@@ -290,26 +449,31 @@ const makeMessagesRecvSocket = (config) => {
                     tag: 'keys',
                     attrs: {},
                     content: [
-                        { tag: 'type', attrs: {}, content: Buffer.from(Defaults_1.KEY_BUNDLE_TYPE) },
+                        { tag: 'type', attrs: {}, content: Buffer.from(KEY_BUNDLE_TYPE) },
                         { tag: 'identity', attrs: {}, content: identityKey.public },
-                        Utils_1.xmppPreKey(key, +keyId),
-                        Utils_1.xmppSignedPreKey(signedPreKey),
+                        xmppPreKey(key, +keyId),
+                        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 === WABinary_1.S_WHATSAPP_NET) {
-            const countChild = WABinary_1.getBinaryNodeChild(node, 'count')
+        
+        if (from === S_WHATSAPP_NET) {
+            const countChild = getBinaryNodeChild(node, 'count')
             const count = +countChild.attrs.value
-            const shouldUploadMorePreKeys = count < Defaults_1.MIN_PREKEY_COUNT
+            const shouldUploadMorePreKeys = count < MIN_PREKEY_COUNT
+            
             logger.debug({ count, shouldUploadMorePreKeys }, 'recv pre-key count')
             
             if (shouldUploadMorePreKeys) {
@@ -318,11 +482,25 @@ const makeMessagesRecvSocket = (config) => {
         }
         
         else {
-            const identityNode = WABinary_1.getBinaryNodeChild(node, 'identity')
+            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 {
@@ -331,162 +509,145 @@ const makeMessagesRecvSocket = (config) => {
         }
     }
     
-    const handleGroupNotification = (participant, child, msg, mode) => {
-        let participantJid = mode === 'lid' ? WABinary_1.getBinaryNodeChild(child, 'participant')?.attrs?.phone_number : WABinary_1.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 = groups_1.extractGroupMetadata(child)
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_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 = Types_1.WAMessageStubType.COMMUNITY_PARENT_GROUP_DELETED
-                msg.messageStubParameters = [participantJid, 'delete']
+                        author: actingParticipantLid,
+                        authorPn: actingParticipantPn
+                    }
+                ])
                 break
             case 'ephemeral':
             case 'not_ephemeral':
                 msg.message = {
                     protocolMessage: {
-                        type: WAProto_1.proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
+                        type: proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
                         ephemeralExpiration: +(child.attrs.expiration || 0)
                     }
                 }
                 break
             case 'modify':
-                const oldNumber = mode === 'lid' ? WABinary_1.getBinaryNodeChildren(child, 'participant').map(p => p.attrs.phone_number) : WABinary_1.getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
+                const oldNumber = getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
                 msg.messageStubParameters = oldNumber || []
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER
+                msg.messageStubType = WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER
                 break
             case 'promote':
             case 'demote':
             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
-                }
-                msg.messageStubType = Types_1.WAMessageStubType[stubType]
-                const participants =  mode === 'lid' ? WABinary_1.getBinaryNodeChildren(child, 'participant').map(p => p.attrs.phone_number) : WABinary_1.getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
+                const stubType = `GROUP_PARTICIPANT_${child.tag.toUpperCase()}`
+                msg.messageStubType = WAMessageStubType[stubType]
+                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
-                    WABinary_1.areJidsSameUser(participants[0], participant) &&
+                    (areJidsSameUser(participants[0].id, actingParticipantLid) ||
+                        areJidsSameUser(participants[0].id, actingParticipantPn)) &&
                     child.tag === 'remove') {
-                    msg.messageStubType = Types_1.WAMessageStubType.GROUP_PARTICIPANT_LEAVE
+                    msg.messageStubType = WAMessageStubType.GROUP_PARTICIPANT_LEAVE
                 }
-                msg.messageStubParameters = participants
+                
+                msg.messageStubParameters = participants.map(a => JSON.stringify(a))
                 break
             case 'subject':
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_SUBJECT
-                msg.messageStubParameters = [participantJid, child.attrs.subject]
+                msg.messageStubType = WAMessageStubType.GROUP_CHANGE_SUBJECT
+                msg.messageStubParameters = [child.attrs.subject]
                 break
             case 'description':
-                const description = WABinary_1.getBinaryNodeChild(child, 'body')?.content?.toString()
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_DESCRIPTION
+                const description = getBinaryNodeChild(child, 'body')?.content?.toString()
+                msg.messageStubType = WAMessageStubType.GROUP_CHANGE_DESCRIPTION
                 msg.messageStubParameters = description ? [description] : undefined
                 break
             case 'announcement':
             case 'not_announcement':
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_ANNOUNCE
-                msg.messageStubParameters = [(child.tag === 'announcement') ? 'on' : 'off']
+                msg.messageStubType = WAMessageStubType.GROUP_CHANGE_ANNOUNCE
+                msg.messageStubParameters = [child.tag === 'announcement' ? 'on' : 'off']
                 break
             case 'locked':
             case 'unlocked':
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_RESTRICT
-                msg.messageStubParameters = [(child.tag === 'locked') ? 'on' : 'off']
+                msg.messageStubType = WAMessageStubType.GROUP_CHANGE_RESTRICT
+                msg.messageStubParameters = [child.tag === 'locked' ? 'on' : 'off']
                 break
             case 'invite':
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_INVITE_LINK
+                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 = Types_1.WAMessageStubType.GROUP_MEMBER_ADD_MODE
+                    msg.messageStubType = WAMessageStubType.GROUP_MEMBER_ADD_MODE
                     msg.messageStubParameters = [addMode.toString()]
                 }
                 break
             case 'membership_approval_mode':
-                const approvalMode = WABinary_1.getBinaryNodeChild(child, 'group_join')
+                const approvalMode = getBinaryNodeChild(child, 'group_join')
                 if (approvalMode) {
-                    msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE
+                    msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE
                     msg.messageStubParameters = [approvalMode.attrs.state]
                 }
                 break
             case 'created_membership_requests':
-            participantJid = mode === 'lid' ? WABinary_1.getBinaryNodeChild(child, 'requested_user')?.attrs?.phone_number : WABinary_1.getBinaryNodeChild(child, 'requested_user')?.attrs?.jid || participant
-            
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
-                msg.messageStubParameters = [participantJid, 'created', child.attrs.request_method]
+                msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
+                msg.messageStubParameters = [
+                    JSON.stringify({ lid: affectedParticipantLid, pn: affectedParticipantPn }),
+                    'created',
+                    child.attrs.request_method
+                ]
                 break
             case 'revoked_membership_requests':
-            participantJid = mode === 'lid' ? WABinary_1.getBinaryNodeChild(child, 'requested_user')?.attrs?.phone_number : WABinary_1.getBinaryNodeChild(child, 'requested_user')?.attrs?.jid || participant
-            
-                const isDenied = WABinary_1.areJidsSameUser(participantJid, participant)
-                msg.messageStubType = Types_1.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: Types_1.WAMessageStubType[`COMMUNITY_${child.tag.toUpperCase()}_PARENT_GROUP`],
-                    sibling_group: Types_1.WAMessageStubType[`COMMUNITY_${child.tag.toUpperCase()}_SIBLING_GROUP`],
-                    sub_group: Types_1.WAMessageStubType[`COMMUNITY_${child.tag.toUpperCase()}_SUB_GROUP`]
-                }
-                const groups = WABinary_1.getBinaryNodeChildren(child, 'group')
-                    .map(g => g.attrs?.jid || g.attrs?.subject || '')
-                    .filter(x => x)
-                msg.messageStubType = stubMap?.[type] || Types_1.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' ? WABinary_1.getBinaryNodeChildren(child, 'participant').map(p => p.attrs.phone_number) : WABinary_1.getBinaryNodeChildren(child, 'participant').map(p => p.attrs.jid)
-                msg.messageStubType = Types_1.WAMessageStubType[stubtype]
-                msg.messageStubParameters = participantS
-                break
-            case 'created_sub_group_suggestion':    
-                msg.messageStubType = Types_1.WAMessageStubType.SUGGESTED_SUBGROUP_ANNOUNCE
-                msg.messageStubParameters = [participantJid, 'add']
-                break
-            case 'revoked_sub_group_suggestions':
-                const res = WABinary_1.getBinaryNodeChildren(child, 'sub_group_suggestions')
-                const reason = res.attrs?.reason 
-                if (reason === 'approved') msg.messageStubType = Types_1.WAMessageStubType.GROUP_CREATE
-                else msg.messageStubType = Types_1.WAMessageStubType.GENERIC_NOTIFICATION
-                msg.messageStubParameters = [participantJid, reason]
-                break
-            default:
-                logger.warn(child.tag, 'Unhandled group node') 
+                const isDenied = areJidsSameUser(affectedParticipantLid, actingParticipantLid)
+                // TODO: LIDMAPPING SUPPORT
+                msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
+                msg.messageStubParameters = [
+                    JSON.stringify({ lid: affectedParticipantLid, pn: affectedParticipantPn }),
+                    isDenied ? 'revoked' : 'rejected'
+                ]
                 break
         }
     }
     
     const handleNewsletterNotification = (id, node) => {
-        const messages = WABinary_1.getBinaryNodeChild(node, 'messages')
-        const message = WABinary_1.getBinaryNodeChild(node, 'message')
+        const messages = getBinaryNodeChild(node, 'messages')
+        const message = getBinaryNodeChild(node, 'message')
         const serverId = node.attrs.server_id
 
-        const reactionsList = WABinary_1.getBinaryNodeChild(node, 'reactions')
-        const viewsList = WABinary_1.getBinaryNodeChild(node, 'views_count')
+        const reactionsList = getBinaryNodeChild(node, 'reactions')
+        const viewsList = getBinaryNodeChild(node, 'views_count')
 
         if (reactionsList) {
-            const reactions = WABinary_1.getBinaryNodeChild(reactionsList, 'reaction')
+            const reactions = getBinaryNodeChild(reactionsList, 'reaction')
 
             if (reactions.length === 0) {
                 ev.emit('newsletter.reaction', {
@@ -528,23 +689,23 @@ const makeMessagesRecvSocket = (config) => {
         let contentPath
         let action
         
-        if (operation === Types_1.MexOperations.UPDATE) {
-        	contentPath = content.data[Types_1.XWAPaths.METADATA_UPDATE]
+        if (operation === MexOperations.UPDATE) {
+        	contentPath = content.data[XWAPaths.METADATA_UPDATE]
             
             ev.emit('newsletter-settings.update', {
             	id, 
                 update: contentPath.thread_metadata.settings
             }) 
-        } else if (operation === Types_1.MexUpdatesOperations.GROUP_MEMBER_LINK) {
-        	contentPath = content.data[Types_1.XWAPathsMexUpdates.GROUP_SHARING_CHANGE]
+        } else if (operation === MexUpdatesOperations.GROUP_MEMBER_LINK) {
+        	contentPath = content.data[XWAPathsMexUpdates.GROUP_SHARING_CHANGE]
         	
         	ev.emit('groups.update', [{
             	id, 
             	author: contentPath.updated_by.id, 
             	member_link_mode: contentPath.properties.member_link_mode
             }]) 
-        } else if (operation === Types_1.MexUpdatesOperations.GROUP_LIMIT_SHARING) {
-        	contentPath = content.data[Types_1.XWAPathsMexUpdates.GROUP_SHARING_CHANGE]
+        } else if (operation === MexUpdatesOperations.GROUP_LIMIT_SHARING) {
+        	contentPath = content.data[XWAPathsMexUpdates.GROUP_SHARING_CHANGE]
             
             ev.emit('limit-sharing.update', {
             	id, 
@@ -553,8 +714,8 @@ const makeMessagesRecvSocket = (config) => {
                 trigger: contentPath.properties.limit_sharing.limit_sharing_trigger, 
                 update_time: contentPath.update_time 
             }) 
-        } else if (operation === Types_1.MexUpdatesOperations.OWNER_COMMUNITY) {
-        	contentPath = content.data[Types_1.XWAPathsMexUpdates.COMMUNITY_OWNER_CHANGE]
+        } else if (operation === MexUpdatesOperations.OWNER_COMMUNITY) {
+        	contentPath = content.data[XWAPathsMexUpdates.COMMUNITY_OWNER_CHANGE]
             
             ev.emit('community-owner.update', {
             	id, 
@@ -565,12 +726,12 @@ const makeMessagesRecvSocket = (config) => {
             }) 
         } else {
             
-            if (operation === Types_1.MexOperations.PROMOTE) {
+            if (operation === MexOperations.PROMOTE) {
             	action = 'promote'
-                contentPath = content.data[Types_1.XWAPaths.PROMOTE]
+                contentPath = content.data[XWAPaths.PROMOTE]
             } else {
             	action = 'demote'
-                contentPath = content.data[Types_1.XWAPaths.DEMOTE]
+                contentPath = content.data[XWAPaths.DEMOTE]
             }
             
             ev.emit('newsletter-participants.update', {
@@ -585,27 +746,14 @@ const makeMessagesRecvSocket = (config) => {
 
     const processNotification = async (node) => {
         const result = {}
-        const [child] = WABinary_1.getAllBinaryNodeChildren(node)
+        const [child] = getAllBinaryNodeChildren(node)
         const nodeType = node.attrs.type
-        const from = WABinary_1.jidNormalizedUser(node.attrs.from)
+        const from = jidNormalizedUser(node.attrs.from)
         
         switch (nodeType) {
-            case 'privacy_token':
-                const tokenList = WABinary_1.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) 
@@ -614,45 +762,52 @@ const makeMessagesRecvSocket = (config) => {
                 handleMexNotification(node.attrs.from, child, result) 
                 break
             case 'mediaretry':
-                const event = Utils_1.decodeMediaRetryNode(node)
+                const event = decodeMediaRetryNode(node)
                 ev.emit('messages.media-update', [event])
                 break
             case 'encrypt':
                 await handleEncryptNotification(node)
                 break
             case 'devices':
-                const devices = WABinary_1.getBinaryNodeChildren(child, 'device')
-                if (WABinary_1.areJidsSameUser(child.attrs.jid, authState.creds.me.id) ||
-                    WABinary_1.areJidsSameUser(child.attrs.lid, authState.creds.me.lid)) {
+                const devices = getBinaryNodeChildren(child, 'device')
+                if (areJidsSameUser(child.attrs.jid, authState.creds.me.id) ||
+                    areJidsSameUser(child.attrs.lid, authState.creds.me.lid)) {
                     const deviceData = devices.map(d => ({ id: d.attrs.jid, lid: d.attrs.lid }))
                     logger.info({ deviceData }, 'my own devices changed')
                 }
                 //TODO: drop a new event, add hashes
                 break
             case 'server_sync':
-                const update = WABinary_1.getBinaryNodeChild(node, 'collection')
+                const update = getBinaryNodeChild(node, 'collection')
                 if (update) {
                     const name = update.attrs.name
                     await resyncAppState([name], false)
                 }
                 break
             case 'picture':
-                const setPicture = WABinary_1.getBinaryNodeChild(node, 'set')
-                const delPicture = WABinary_1.getBinaryNodeChild(node, 'delete')
-                ev.emit('contacts.update', [{
-                        id: WABinary_1.jidNormalizedUser(node?.attrs?.from) || (setPicture || delPicture)?.attrs?.hash || '',
+                const setPicture = getBinaryNodeChild(node, 'set')
+                const delPicture = getBinaryNodeChild(node, 'delete')
+                
+                ev.emit('contacts.update', [
+                    {
+                        id: jidNormalizedUser(node?.attrs?.from) || (setPicture || delPicture)?.attrs?.hash || '',
                         imgUrl: setPicture ? 'changed' : 'removed'
-                    }])
-                if (WABinary_1.isJidGroup(from)) {
+                    }
+                ])
+                
+                if (isJidGroup(from)) {
                     const node = setPicture || delPicture
-                    result.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_ICON
+                    
+                    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
@@ -666,48 +821,51 @@ const makeMessagesRecvSocket = (config) => {
                             ...authState.creds.accountSettings,
                             defaultDisappearingMode: {
                                 ephemeralExpiration: newDuration,
-                                ephemeralSettingTimestamp: timestamp,
-                            },
+                                ephemeralSettingTimestamp: timestamp
+                            }
                         }
                     })
                 }
+                
                 else if (child.tag === 'blocklist') {
-                    const blocklists = WABinary_1.getBinaryNodeChildren(child, 'item')
+                    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 })
                     }
                 }
                 break
             case 'link_code_companion_reg':
-                const linkCodeCompanionReg = WABinary_1.getBinaryNodeChild(node, 'link_code_companion_reg')
-                const ref = toRequiredBuffer(WABinary_1.getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_ref'))
-                const primaryIdentityPublicKey = toRequiredBuffer(WABinary_1.getBinaryNodeChildBuffer(linkCodeCompanionReg, 'primary_identity_pub'))
-                const primaryEphemeralPublicKeyWrapped = toRequiredBuffer(WABinary_1.getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_wrapped_primary_ephemeral_pub'))
+                const linkCodeCompanionReg = getBinaryNodeChild(node, 'link_code_companion_reg')
+                const ref = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_ref'))
+                const primaryIdentityPublicKey = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'primary_identity_pub'))
+                const primaryEphemeralPublicKeyWrapped = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_wrapped_primary_ephemeral_pub'))
                 const codePairingPublicKey = await decipherLinkPublicKey(primaryEphemeralPublicKeyWrapped)
-                const companionSharedKey = Utils_1.Curve.sharedKey(authState.creds.pairingEphemeralKeyPair.private, codePairingPublicKey)
-                const random = crypto_1.randomBytes(32)
-                const linkCodeSalt = crypto_1.randomBytes(32)
-                
-                const linkCodePairingExpanded = await Utils_1.hkdf(companionSharedKey, 32, {
+                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 encryptIv = crypto_1.randomBytes(12)
-                const encrypted = Utils_1.aesEncryptGCM(encryptPayload, linkCodePairingExpanded, encryptIv, Buffer.alloc(0))
+                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])
-                const identitySharedKey = Utils_1.Curve.sharedKey(authState.creds.signedIdentityKey.private, primaryIdentityPublicKey)
+                const identitySharedKey = Curve.sharedKey(authState.creds.signedIdentityKey.private, primaryIdentityPublicKey)
                 const identityPayload = Buffer.concat([companionSharedKey, identitySharedKey, random])
                 
-                authState.creds.advSecretKey = (await Utils_1.hkdf(identityPayload, 32, { info: 'adv_secret' })).toString('base64')
+                authState.creds.advSecretKey = (await hkdf(identityPayload, 32, { info: 'adv_secret' })).toString('base64')
                 
                 await query({
                     tag: 'iq',
                     attrs: {
-                        to: WABinary_1.S_WHATSAPP_NET,
+                        to: S_WHATSAPP_NET,
                         type: 'set',
                         id: suki.generateMessageTag(),
                         xmlns: 'md'
@@ -717,7 +875,7 @@ const makeMessagesRecvSocket = (config) => {
                             tag: 'link_code_companion_reg',
                             attrs: {
                                 jid: authState.creds.me.id,
-                                stage: 'companion_finish',
+                                stage: 'companion_finish'
                             },
                             content: [
                                 {
@@ -742,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) {
@@ -749,18 +911,45 @@ 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)
-        const secretKey = await Utils_1.derivePairingCodeKey(authState.creds.pairingCode, salt)
+        const secretKey = await derivePairingCodeKey(authState.creds.pairingCode, salt)
         const iv = buffer.slice(32, 48)
         const payload = buffer.slice(48, 80)
-        return Utils_1.aesDecryptCTR(payload, secretKey, iv)
+        return aesDecryptCTR(payload, secretKey, iv)
     }
     
     function toRequiredBuffer(data) {
         if (data === undefined) {
-            throw new boom_1.Boom('Invalid buffer', { statusCode: 400 })
+            throw new Boom('Invalid buffer', { statusCode: 400 })
         }
         return data instanceof Buffer ? data : Buffer.from(data)
     }
@@ -791,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')
@@ -803,22 +993,24 @@ 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)
         }
         
         // if it's the primary jid sending the request
         // just re-send the message to everyone
         // prevents the first message decryption failure
-        const sendToAll = !WABinary_1.jidDecode(participant)?.device
+        const sendToAll = !jidDecode(participant)?.device
         
         // Check if we should recreate session for this retry
         let shouldRecreateSession = false
@@ -834,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 (WABinary_1.isJidGroup(remoteJid)) {
-            await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } });
+        if (isJidGroup(remoteJid)) {
+            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')
             }
@@ -878,10 +1074,9 @@ const makeMessagesRecvSocket = (config) => {
     const handleReceipt = async (node) => {
         const { attrs, content } = node
         const isLid = attrs.from.includes('lid')
-        const isNodeFromMe = WABinary_1.areJidsSameUser(attrs.participant || attrs.from, isLid ? authState.creds.me?.lid : authState.creds.me?.id)
-        const remoteJid = !isNodeFromMe || WABinary_1.isJidGroup(attrs.from) ? attrs.from : attrs.recipient
+        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: '',
@@ -889,35 +1084,36 @@ 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 = WABinary_1.getBinaryNodeChildren(content[0], 'item')
+            const items = getBinaryNodeChildren(content[0], 'item')
             ids.push(...items.map(i => i.attrs.id))
         }
         
         try {
             await Promise.all([
-                processingMutex.mutex(async () => {
-                    const status = Utils_1.getStatusFromReceiptType(attrs.type)
+                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 >= WAProto_1.proto.WebMessageInfo.Status.SERVER_ACK ||
-                            !isNodeFromMe)) {
-                        if (WABinary_1.isJidGroup(remoteJid) || WABinary_1.isJidStatusBroadcast(remoteJid)) {
+                        (status >= proto.WebMessageInfo.Status.SERVER_ACK || !isNodeFromMe)) {
+                        if (isJidGroup(remoteJid) || isJidStatusBroadcast(remoteJid)) {
                             if (attrs.participant) {
-                                const updateKey = status === WAProto_1.proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp'
+                                const updateKey = status === proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp'
+                                
                                 ev.emit('message-receipt.update', ids.map(id => ({
                                     key: { ...key, id },
                                     receipt: {
-                                        userJid: WABinary_1.jidNormalizedUser(attrs.participant),
+                                        userJid: jidNormalizedUser(attrs.participant),
                                         [updateKey]: +attrs.t
                                     }
                                 })))
@@ -935,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 = WABinary_1.getBinaryNodeChild(node, 'retry')
+                        
+                        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)
                                 }
                                 
@@ -962,6 +1161,7 @@ const makeMessagesRecvSocket = (config) => {
                 })
             ])
         }
+        
         finally {
             await sendMessageAck(node)
         }
@@ -969,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
@@ -978,96 +1177,72 @@ const makeMessagesRecvSocket = (config) => {
         
         try {
             await Promise.all([
-                processingMutex.mutex(async () => {
+                notificationMutex.mutex(async () => {
                     const msg = await processNotification(node)
                     
                     if (msg) {
-                        const fromMe = WABinary_1.areJidsSameUser(node.attrs.participant || remoteJid, authState.creds.me.id)
+                        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 = WAProto_1.proto.WebMessageInfo.fromObject(msg)
+                        
+                        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 = WABinary_1.getBinaryNodeChild(node, 'enc')
+        const encNode = getBinaryNodeChild(node, 'enc')
         
         // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
         if (encNode && encNode.attrs.type === 'msmsg') {
             logger.debug({ key: node.attrs.key }, 'ignored msmsg')
-            await sendMessageAck(node, Utils_1.NACK_REASONS.MissingMessageSecret)
+            await sendMessageAck(node, NACK_REASONS.MissingMessageSecret)
             return
         }
         
-        if (WABinary_1.getBinaryNodeChild(node, 'unavailable') && !encNode) {
-            await sendMessageAck(node)
-            const { key } = Utils_1.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 } = Utils_1.decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger)
-        
-        if (response && msg?.messageStubParameters?.[0] === Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT) {
-            msg.messageStubParameters = [Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT, response]
-        }
-        
-        if (msg.message?.protocolMessage?.type === WAProto_1.proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER &&
-            node.attrs.sender_pn) {
-            const lid = WABinary_1.jidNormalizedUser(node.attrs.from), pn = WABinary_1.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 = WABinary_1.jidDecode(alt)?.server
+            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)
             }
         }
         
@@ -1080,70 +1255,83 @@ const makeMessagesRecvSocket = (config) => {
         }
         
         try {
-            await Promise.all([
-                processingMutex.mutex(async () => {
-                    await decrypt()
-                    // message failed to decrypt
-                    if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
-                        if (msg?.messageStubParameters?.[0] === Utils_1.MISSING_KEYS_ERROR_TEXT) {
-                            return sendMessageAck(node, Utils_1.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 (WABinary_1.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 Utils_1.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')
                                 
-                                const encNode = WABinary_1.getBinaryNodeChild(node, 'enc')
                                 await sendRetryRequest(node, !encNode)
-                                if (retryRequestDelayMs) {
-                                    await Utils_1.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 = WABinary_1.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') {
@@ -1156,7 +1344,7 @@ const makeMessagesRecvSocket = (config) => {
                             type = 'sender'
                             
                             // need to specially handle this case
-                            if (WABinary_1.isLidUser(msg.key.remoteJid) || WABinary_1.isLidUser(msg.key.remoteJidAlt)) {
+                            if (isLidUser(msg.key.remoteJid) || isLidUser(msg.key.remoteJidAlt)) {
                                 participant = author // TODO: investigate sending receipts to LIDs and not PNs
                             }
                         }
@@ -1164,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 = Utils_1.getHistoryMsg(msg.message)
+                        const isAnyHistoryMsg = getHistoryMsg(msg.message)
+                        
                         if (isAnyHistoryMsg) {
-                            const jid = WABinary_1.jidNormalizedUser(msg.key.remoteJid)
-                            await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync')
+                            const jid = jidNormalizedUser(msg.key.remoteJid)
+                            await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync') // TODO: investigate
                         }
                     }
-                    Utils_1.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')
+            logger.error({ error, node: binaryNodeToString(node) }, 'error in handling message')
         }
     }
     
-    const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
-        if (!authState.creds.me?.id) {
-            throw new boom_1.Boom('Not authenticated')
-        }
-        
-        const pdoMessage = {
-            historySyncOnDemandRequest: {
-                chatJid: oldestMsgKey.remoteJid,
-                oldestMsgFromMe: oldestMsgKey.fromMe,
-                oldestMsgId: oldestMsgKey.id,
-                oldestMsgTimestampMs: oldestMsgTimestamp,
-                onDemandMsgCount: count
-            },
-            peerDataOperationRequestType: WAProto_1.proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
-        }
-        
-        return sendPeerDataOperationMessage(pdoMessage)
-    }
-    
-    const requestPlaceholderResend = async (messageKey) => {
-        if (!authState.creds.me?.id) {
-            throw new boom_1.Boom('Not authenticated')
-        }
-        
-        if (placeholderResendCache.get(messageKey?.id)) {
-            logger.debug({ messageKey }, 'already requested resend')
-            return
-        }
-        
-        else {
-            placeholderResendCache.set(messageKey?.id, true)
-        }
-        
-        await Utils_1.delay(5000)
-        
-        if (!placeholderResendCache.get(messageKey?.id)) {
-            logger.debug({ messageKey }, 'message received while resend requested')
-            return 'RESOLVED'
-        }
+    const handleCall = async (node) => {
+        const { attrs } = node
+        const [infoChild] = getAllBinaryNodeChildren(node)
+        const status = getCallStatusFromNode(infoChild)
         
-        const pdoMessage = {
-            placeholderMessageResendRequest: [{
-                    messageKey
-                }],
-            peerDataOperationRequestType: WAProto_1.proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
+        if (!infoChild) {
+            throw new Boom('Missing call info in call node')
         }
         
-        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] = WABinary_1.getAllBinaryNodeChildren(node)
         const callId = infoChild.attrs['call-id']
         const from = infoChild.attrs.from || infoChild.attrs['call-creator']
-        status =  Utils_1.getCallStatusFromNode(infoChild)
-        
-        if (WABinary_1.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 call = {
             chatId: attrs.from,
             from,
             id: callId,
             date: new Date(+attrs.t * 1000),
             offline: !!attrs.offline,
-            status,
+            status
         }
         
         if (status === 'offer') {
-            call.isVideo = !!WABinary_1.getBinaryNodeChild(infoChild, 'video')
+            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)
         }
         
@@ -1304,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
@@ -1326,13 +1451,25 @@ const makeMessagesRecvSocket = (config) => {
                 {
                     key,
                     update: {
-                        status: Types_1.WAMessageStatus.ERROR,
-                        messageStubParameters: [
-                            attrs.error
-                        ]
+                        status: WAMessageStatus.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'
+            // 			}
+            // 		})
+            // 	}
+            // }
         }
     }
     
@@ -1342,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],
@@ -1357,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 })
             
@@ -1369,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'))
         }
         
@@ -1388,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) {
@@ -1396,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 = {
@@ -1426,25 +1595,28 @@ const makeMessagesRecvSocket = (config) => {
                     id: call.id,
                     fromMe: false
                 },
-                messageTimestamp: Utils_1.unixTimestampSeconds(call.date),
+                messageTimestamp: unixTimestampSeconds(call.date)
             }
             
             if (call.status === 'timeout') {
                 if (call.isGroup) {
-                    msg.messageStubType = call.isVideo ? Types_1.WAMessageStubType.CALL_MISSED_GROUP_VIDEO : Types_1.WAMessageStubType.CALL_MISSED_GROUP_VOICE
+                    msg.messageStubType = call.isVideo
+                        ? WAMessageStubType.CALL_MISSED_GROUP_VIDEO
+                        : WAMessageStubType.CALL_MISSED_GROUP_VOICE
                 }
                 
                 else {
-                    msg.messageStubType = call.isVideo ? Types_1.WAMessageStubType.CALL_MISSED_VIDEO : Types_1.WAMessageStubType.CALL_MISSED_VOICE
+                    msg.messageStubType = call.isVideo ? WAMessageStubType.CALL_MISSED_VIDEO : WAMessageStubType.CALL_MISSED_VOICE
                 }
             }
             
             else {
-                msg.message = { call: { callKey: Buffer.from(call.id) } }
+                msg.message = { call: { callKey: Buffer.from(call.id) } };
             }
             
-            const protoMsg = WAProto_1.proto.WebMessageInfo.fromObject(msg)
-            upsertMessage(protoMsg, call.offline ? 'append' : 'notify')
+            const protoMsg = proto.WebMessageInfo.fromObject(msg)
+            
+            await upsertMessage(protoMsg, call.offline ? 'append' : 'notify')
         }
     })