@hansaka02/baileys 7.3.2 → 7.3.4

package/lib/Socket/messages-recv.js

@@ -1,43 +1,90 @@
 "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, 
+  isJidStatusBroadcast, 
+  isLidUser,
+  isJidUser, 
+  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 suki = makeMessagesSocket(config)
     const { ev, authState, ws, processingMutex, 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 node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY,
+    const msgRetryCache = config.msgRetryCounterCache || new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY,
         useClones: false
     })
     
-    const callOfferCache = config.callOfferCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.CALL_OFFER,
+    const callOfferCache = config.callOfferCache || new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.CALL_OFFER,
         useClones: false
     })
     
-    const placeholderResendCache = config.placeholderResendCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY,
+    const placeholderResendCache = config.placeholderResendCache || new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY,
         useClones: false
     })
     
@@ -65,11 +112,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 +125,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 +141,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 +156,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 +206,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
         
@@ -245,7 +292,7 @@ const makeMessagesRecvSocket = (config) => {
             }
         }
         
-        const deviceIdentity = Utils_1.encodeSignedDeviceIdentity(account, true)
+        const deviceIdentity = encodeSignedDeviceIdentity(account, true)
         await authState.keys.transaction(async () => {
             const receipt = {
                 tag: 'receipt',
@@ -267,7 +314,7 @@ const makeMessagesRecvSocket = (config) => {
                     {
                         tag: 'registration',
                         attrs: {},
-                        content: Utils_1.encodeBigEndian(authState.creds.registrationId)
+                        content: encodeBigEndian(authState.creds.registrationId)
                     }
                 ]
             }
@@ -281,7 +328,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,10 +337,10 @@ 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 }
                     ]
                 });
@@ -306,10 +353,10 @@ const makeMessagesRecvSocket = (config) => {
     
     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,7 +365,7 @@ 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
@@ -332,13 +379,13 @@ 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
+        let participantJid = mode === 'lid' ? getBinaryNodeChild(child, 'participant')?.attrs?.phone_number : getBinaryNodeChild(child, 'participant')?.attrs?.jid || participant
         
         // TODO: Add participant LID
         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', [{
@@ -352,22 +399,22 @@ const makeMessagesRecvSocket = (config) => {
                     }])
                 break
             case 'delete':
-                msg.messageStubType = Types_1.WAMessageStubType.COMMUNITY_PARENT_GROUP_DELETED
+                msg.messageStubType = WAMessageStubType.COMMUNITY_PARENT_GROUP_DELETED
                 msg.messageStubParameters = [participantJid, 'delete']
                 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 = mode === 'lid' ? getBinaryNodeChildren(child, 'participant').map(p => p.attrs.phone_number) : 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':
@@ -378,97 +425,97 @@ const makeMessagesRecvSocket = (config) => {
                 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)
+                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)
                 if (participants.length === 1 &&
                     // if recv. "remove" message and sender removed themselves
                     // mark as left
-                    WABinary_1.areJidsSameUser(participants[0], participant) &&
+                    areJidsSameUser(participants[0], participant) &&
                     child.tag === 'remove') {
-                    msg.messageStubType = Types_1.WAMessageStubType.GROUP_PARTICIPANT_LEAVE
+                    msg.messageStubType = WAMessageStubType.GROUP_PARTICIPANT_LEAVE
                 }
                 msg.messageStubParameters = participants
                 break
             case 'subject':
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_SUBJECT
+                msg.messageStubType = WAMessageStubType.GROUP_CHANGE_SUBJECT
                 msg.messageStubParameters = [participantJid, 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.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.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
                 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
+            participantJid = mode === 'lid' ? getBinaryNodeChild(child, 'requested_user')?.attrs?.phone_number : getBinaryNodeChild(child, 'requested_user')?.attrs?.jid || participant
             
-                msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
+                msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
                 msg.messageStubParameters = [participantJid, '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
+            participantJid = mode === 'lid' ? getBinaryNodeChild(child, 'requested_user')?.attrs?.phone_number : 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
+                const isDenied = areJidsSameUser(participantJid, participant)
+                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: 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`]
+                	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 = WABinary_1.getBinaryNodeChildren(child, 'group')
+                const groups = 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.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' ? 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]
+                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 = Types_1.WAMessageStubType.SUGGESTED_SUBGROUP_ANNOUNCE
+                msg.messageStubType = WAMessageStubType.SUGGESTED_SUBGROUP_ANNOUNCE
                 msg.messageStubParameters = [participantJid, 'add']
                 break
             case 'revoked_sub_group_suggestions':
-                const res = WABinary_1.getBinaryNodeChildren(child, 'sub_group_suggestions')
+                const res = 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
+                if (reason === 'approved') msg.messageStubType = WAMessageStubType.GROUP_CREATE
+                else msg.messageStubType = WAMessageStubType.GENERIC_NOTIFICATION
                 msg.messageStubParameters = [participantJid, reason]
                 break
             default:
@@ -478,15 +525,15 @@ const makeMessagesRecvSocket = (config) => {
     }
     
     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 +575,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 +600,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 +612,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,13 +632,13 @@ 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')
+                const tokenList = getBinaryNodeChildren(child, 'token')
                 for (const { attrs, content } of tokenList) {
                     const jid = attrs.jid
                     ev.emit('chats.update', [
@@ -614,38 +661,38 @@ 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')
+                const setPicture = getBinaryNodeChild(node, 'set')
+                const delPicture = getBinaryNodeChild(node, 'delete')
                 ev.emit('contacts.update', [{
-                        id: WABinary_1.jidNormalizedUser(node?.attrs?.from) || (setPicture || delPicture)?.attrs?.hash || '',
+                        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]
                     }
@@ -672,7 +719,7 @@ const makeMessagesRecvSocket = (config) => {
                     })
                 }
                 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'
@@ -681,33 +728,33 @@ const makeMessagesRecvSocket = (config) => {
                 }
                 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 companionSharedKey = Curve.sharedKey(authState.creds.pairingEphemeralKeyPair.private, codePairingPublicKey)
+                const random = randomBytes(32)
+                const linkCodeSalt = randomBytes(32)
                 
-                const linkCodePairingExpanded = await Utils_1.hkdf(companionSharedKey, 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 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'
@@ -752,15 +799,15 @@ const makeMessagesRecvSocket = (config) => {
     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)
     }
@@ -818,7 +865,7 @@ const makeMessagesRecvSocket = (config) => {
         // 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
@@ -845,7 +892,7 @@ const makeMessagesRecvSocket = (config) => {
         
         await assertSessions([participant], shouldRecreateSession)
         
-        if (WABinary_1.isJidGroup(remoteJid)) {
+        if (isJidGroup(remoteJid)) {
             await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } });
         }
         logger.debug({ participant, sendToAll, shouldRecreateSession, recreateReason }, 'forced new session for retry recp')
@@ -878,8 +925,8 @@ 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 = {
@@ -897,27 +944,27 @@ const makeMessagesRecvSocket = (config) => {
         
         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)
+                    const status = getStatusFromReceiptType(attrs.type)
                     
                     if (typeof status !== 'undefined' && (
                         // basically, we only want to know when a message from us has been delivered to/read by the other person
                         // or another device of ours has read some messages
-                        status >= WAProto_1.proto.WebMessageInfo.Status.SERVER_ACK ||
+                        status >= proto.WebMessageInfo.Status.SERVER_ACK ||
                             !isNodeFromMe)) {
-                        if (WABinary_1.isJidGroup(remoteJid) || WABinary_1.isJidStatusBroadcast(remoteJid)) {
+                        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,7 +982,7 @@ 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) {
@@ -982,7 +1029,7 @@ const makeMessagesRecvSocket = (config) => {
                     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)
                         msg.key = {
                             remoteJid,
                             fromMe,
@@ -992,7 +1039,7 @@ const makeMessagesRecvSocket = (config) => {
                         }
                         msg.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')
                     }
                 })
@@ -1012,18 +1059,18 @@ const makeMessagesRecvSocket = (config) => {
         
         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) {
+        if (getBinaryNodeChild(node, 'unavailable') && !encNode) {
             await sendMessageAck(node)
-            const { key } = Utils_1.decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '').fullMessage
+            const { key } = decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '').fullMessage
             response = await requestPlaceholderResend(key);
             if (response === 'RESOLVED') {
                 return
@@ -1036,15 +1083,15 @@ const makeMessagesRecvSocket = (config) => {
             }
         }
         
-        const { fullMessage: msg, category, author, decrypt } = Utils_1.decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger)
+        const { fullMessage: msg, category, author, decrypt } = 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 (response && msg?.messageStubParameters?.[0] === NO_MESSAGE_FOUND_ERROR_TEXT) {
+            msg.messageStubParameters = [NO_MESSAGE_FOUND_ERROR_TEXT, response]
         }
         
-        if (msg.message?.protocolMessage?.type === WAProto_1.proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER &&
+        if (msg.message?.protocolMessage?.type === 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)
+            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 }])
         }
@@ -1053,7 +1100,7 @@ const makeMessagesRecvSocket = (config) => {
         
         // store new mappings we didn't have before
         if (!!alt) {
-            const altServer = WABinary_1.jidDecode(alt)?.server
+            const altServer = jidDecode(alt)?.server
             
             if (altServer === 'lid') {
                 if (typeof (await signalRepository.lidMapping.getPNForLID(alt)) === 'string') {
@@ -1084,9 +1131,9 @@ const makeMessagesRecvSocket = (config) => {
                 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)
+                    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] || ''
@@ -1101,7 +1148,7 @@ const makeMessagesRecvSocket = (config) => {
                                     return
                                 }
                                 
-                                if (WABinary_1.getBinaryNodeChild(node, 'unavailable')) {
+                                if (getBinaryNodeChild(node, 'unavailable')) {
                                     logger.debug('Message unavailable, skipping retry')
                                     return
                                 }
@@ -1113,24 +1160,24 @@ const makeMessagesRecvSocket = (config) => {
                                         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)
+                                        await delay(1000)
                                     }
                                     catch (uploadErr) {
                                         logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway')
                                     }
                                 }
                                 
-                                const encNode = WABinary_1.getBinaryNodeChild(node, 'enc')
+                                const encNode = getBinaryNodeChild(node, 'enc')
                                 await sendRetryRequest(node, !encNode)
                                 if (retryRequestDelayMs) {
-                                    await Utils_1.delay(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 = WABinary_1.getBinaryNodeChild(node, 'enc')
+                                    const encNode = getBinaryNodeChild(node, 'enc')
                                     await sendRetryRequest(node, !encNode)
                                 }
                                 catch (retryErr) {
@@ -1156,7 +1203,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
                             }
                         }
@@ -1167,13 +1214,13 @@ const makeMessagesRecvSocket = (config) => {
                         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)
+                            const jid = jidNormalizedUser(msg.key.remoteJid)
                             await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync')
                         }
                     }
-                    Utils_1.cleanMessage(msg, authState.creds.me.id)
+                    cleanMessage(msg, authState.creds.me.id)
                     await sendMessageAck(node)
                     await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify')
                 })
@@ -1187,7 +1234,7 @@ const makeMessagesRecvSocket = (config) => {
     
     const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
         if (!authState.creds.me?.id) {
-            throw new boom_1.Boom('Not authenticated')
+            throw new Boom('Not authenticated')
         }
         
         const pdoMessage = {
@@ -1198,7 +1245,7 @@ const makeMessagesRecvSocket = (config) => {
                 oldestMsgTimestampMs: oldestMsgTimestamp,
                 onDemandMsgCount: count
             },
-            peerDataOperationRequestType: WAProto_1.proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
+            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
         }
         
         return sendPeerDataOperationMessage(pdoMessage)
@@ -1206,7 +1253,7 @@ const makeMessagesRecvSocket = (config) => {
     
     const requestPlaceholderResend = async (messageKey) => {
         if (!authState.creds.me?.id) {
-            throw new boom_1.Boom('Not authenticated')
+            throw new Boom('Not authenticated')
         }
         
         if (placeholderResendCache.get(messageKey?.id)) {
@@ -1218,7 +1265,7 @@ const makeMessagesRecvSocket = (config) => {
             placeholderResendCache.set(messageKey?.id, true)
         }
         
-        await Utils_1.delay(5000)
+        await delay(5000)
         
         if (!placeholderResendCache.get(messageKey?.id)) {
             logger.debug({ messageKey }, 'message received while resend requested')
@@ -1229,7 +1276,7 @@ const makeMessagesRecvSocket = (config) => {
             placeholderMessageResendRequest: [{
                     messageKey
                 }],
-            peerDataOperationRequestType: WAProto_1.proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
+            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
         }
         
         setTimeout(() => {
@@ -1246,12 +1293,12 @@ const makeMessagesRecvSocket = (config) => {
     	let status
     
         const { attrs } = node
-        const [infoChild] = WABinary_1.getAllBinaryNodeChildren(node)
+        const [infoChild] = getAllBinaryNodeChildren(node)
         const callId = infoChild.attrs['call-id']
         const from = infoChild.attrs.from || infoChild.attrs['call-creator']
-        status =  Utils_1.getCallStatusFromNode(infoChild)
+        status =  getCallStatusFromNode(infoChild)
         
-        if (WABinary_1.isLidUser(from) && infoChild.tag === 'relaylatency') {
+        if (isLidUser(from) && infoChild.tag === 'relaylatency') {
         	const verify = await callOfferCache.get(callId) 
         
         	if (!verify) {
@@ -1279,7 +1326,7 @@ const makeMessagesRecvSocket = (config) => {
         }
         
         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)
@@ -1326,7 +1373,7 @@ const makeMessagesRecvSocket = (config) => {
                 {
                     key,
                     update: {
-                        status: Types_1.WAMessageStatus.ERROR,
+                        status: WAMessageStatus.ERROR,
                         messageStubParameters: [
                             attrs.error
                         ]
@@ -1426,16 +1473,16 @@ 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
                 }
             }
             
@@ -1443,7 +1490,7 @@ const makeMessagesRecvSocket = (config) => {
                 msg.message = { call: { callKey: Buffer.from(call.id) } }
             }
             
-            const protoMsg = WAProto_1.proto.WebMessageInfo.fromObject(msg)
+            const protoMsg = proto.WebMessageInfo.fromObject(msg)
             upsertMessage(protoMsg, call.offline ? 'append' : 'notify')
         }
     })