@hansaka02/baileys 7.3.2 → 7.3.6

package/lib/Socket/chats.js

@@ -1,42 +1,97 @@
 "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 WAProto_1 = require("../../WAProto")
-const Defaults_1 = require("../Defaults")
-const Types_1 = require("../Types")
-const Utils_1 = require("../Utils")
-const make_mutex_1 = require("../Utils/make-mutex")
-const WABinary_1 = require("../WABinary")
-const WAUSync_1 = require("../WAUSync")
-const socket_1 = require("./socket")
+const { default: NodeCache } = require("@cacheable/node-cache")
+const { Boom } = require("@hapi/boom")
+const { proto } = require("../../WAProto")
+const {
+  CALL_VIDEO_PREFIX, 
+  CALL_AUDIO_PREFIX
+} = require("../Defaults/prefix")
+const { DEFAULT_CACHE_TTLS } = require("../Defaults/constants")
+const { PROCESSABLE_HISTORY_TYPES } = require("../Defaults/history") 
+const {
+  SyncState, 
+  ALL_WA_PATCH_NAMES
+} = require("../Types")
+const {
+  newLTHashState, 
+  processSyncAction, 
+  extractSyncdPatches, 
+  generateProfilePicture, 
+  decodeSyncdSnapshot, 
+  decodePatches, 
+  encodeSyncdPatch, 
+  chatModificationToAppPatch, 
+  getHistoryMsg, 
+  processMessage
+} = require("../Utils")
+const { makeMutex } = require("../Utils/make-mutex")
+const {
+  isPnUser, 
+  getBinaryNodeChild, 
+  getBinaryNodeChildren, 
+  jidDecode, 
+  jidNormalizedUser, 
+  reduceBinaryNodeToDictionary, 
+  S_WHATSAPP_NET 
+} = require("../WABinary")
+const {
+  USyncUser, 
+  USyncQuery
+} = require("../WAUSync")
+const { makeSocket } = require("./socket")
 const MAX_SYNC_ATTEMPTS = 2
 
 const makeChatsSocket = (config) => {
-    const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, } = config
-    const suki = socket_1.makeSocket(config)
-    const { ev, ws, authState, generateMessageTag, sendNode, query, signalRepository, onUnexpectedError, groupFetchAllParticipating } = suki
+    const {
+        logger, 
+        markOnlineOnConnect, 
+        fireInitQueries, 
+        appStateMacVerification,
+        shouldIgnoreJid, 
+        shouldSyncHistoryMessage, 
+        getMessage 
+    } = config
+	
+    const suki = makeSocket(config)
     
+    const { 
+        ev, 
+        ws, 
+        authState, 
+        generateMessageTag, 
+        sendNode, 
+        query, 
+        signalRepository, 
+        onUnexpectedError
+    } = suki
+	
     let privacySettings
-    let syncState = Types_1.SyncState.Connecting
+    let syncState = SyncState.Connecting
     
-    /** this mutex ensures that the notifications (receipts, messages etc.) are processed in order */
-    const processingMutex = make_mutex_1.makeMutex()
+    /** this mutex ensures that messages are processed in order */
+    const messageMutex = makeMutex()
     
-    // Timeout for AwaitingInitialSync State
-    let awaitingSyncTimeout
+    /** this mutex ensures that receipts are processed in order */
+    const receiptMutex = makeMutex()
     
-    const placeholderResendCache = config.placeholderResendCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY,
-        useClones: false
-    })
+    /** this mutex ensures that app state patches are processed in order */
+    const appStatePatchMutex = makeMutex()
+    
+    /** this mutex ensures that notifications are processed in order */
+    const notificationMutex = makeMutex()
+    
+    // Timeout for AwaitingInitialSync state
+    let awaitingSyncTimeout
     
+    const placeholderResendCache = config.placeholderResendCache ||
+        new NodeCache({
+            stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
+            useClones: false
+        })
+        
     if (!config.placeholderResendCache) {
         config.placeholderResendCache = placeholderResendCache
     }
@@ -53,14 +108,14 @@ const makeChatsSocket = (config) => {
                 tag: 'iq',
                 attrs: {
                     xmlns: 'privacy',
-                    to: WABinary_1.S_WHATSAPP_NET,
+                    to: S_WHATSAPP_NET,
                     type: 'get'
                 },
                 content: [
                     { tag: 'privacy', attrs: {} }
                 ]
             })
-            privacySettings = WABinary_1.reduceBinaryNodeToDictionary(content?.[0], 'category')
+            privacySettings = reduceBinaryNodeToDictionary(content?.[0], 'category')
         }
         return privacySettings
     }
@@ -71,7 +126,7 @@ const makeChatsSocket = (config) => {
             tag: 'iq',
             attrs: {
                 xmlns: 'privacy',
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set'
             },
             content: [{
@@ -124,7 +179,7 @@ const makeChatsSocket = (config) => {
             tag: 'iq',
             attrs: {
                 xmlns: 'disappearing_mode',
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set'
             },
             content: [{
@@ -141,7 +196,7 @@ const makeChatsSocket = (config) => {
     		tag: 'iq',
     		attrs: {
      			xmlns: 'bot',
-     			to: WABinary_1.S_WHATSAPP_NET,
+     			to: S_WHATSAPP_NET,
      			type: 'get'
     		},
     		content: [{
@@ -152,13 +207,13 @@ const makeChatsSocket = (config) => {
     		}]
    	})
    
-		const botNode = WABinary_1.getBinaryNodeChild(resp, 'bot')
+		const botNode = getBinaryNodeChild(resp, 'bot')
 		
 		const botList = []
 		
-		for(const section of WABinary_1.getBinaryNodeChildren(botNode, 'section')) {
+		for(const section of getBinaryNodeChildren(botNode, 'section')) {
 		  if(section.attrs.type === 'all') {
-				for(const bot of WABinary_1.getBinaryNodeChildren(section, 'bot')) {
+				for(const bot of getBinaryNodeChildren(section, 'bot')) {
 				  botList.push({
 						jid: bot.attrs.jid,
 						personaId: bot.attrs['persona_id']
@@ -171,16 +226,16 @@ const makeChatsSocket = (config) => {
 	
 	const getLidUser = async (jid) => {
         if (!jid) {
-            throw new boom_1.Boom('Please input a jid user')
+            throw new Boom('Please input a jid user')
         }
         
-        if (!WABinary_1.isJidUser(jid)) {
-        	throw new boom_1.Boom('Invalid JID: Not a user JID!')
+        if (!isPnUser(jid)) {
+        	throw new Boom('Invalid JID: Not a user JID!')
         }
         
-        const targetJid = WABinary_1.jidNormalizedUser(jid)
+        const targetJid = jidNormalizedUser(jid)
         
-        const usyncQuery = new WAUSync_1.USyncQuery() 
+        const usyncQuery = new USyncQuery() 
         usyncQuery.protocols.push({
         	name: 'lid', 
             getQueryElement: () => ({
@@ -203,10 +258,10 @@ const makeChatsSocket = (config) => {
     }
     
     const fetchStatus = async (...jids) => {
-        const usyncQuery = new WAUSync_1.USyncQuery().withStatusProtocol()
+        const usyncQuery = new USyncQuery().withStatusProtocol()
         
         for (const jid of jids) {
-            usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid))
+            usyncQuery.withUser(new USyncUser().withId(jid))
         }
         
         const result = await suki.executeUSyncQuery(usyncQuery)
@@ -215,40 +270,46 @@ const makeChatsSocket = (config) => {
             return result.list
         }
     }
+    
     const fetchDisappearingDuration = async (...jids) => {   	
-        const usyncQuery = new WAUSync_1.USyncQuery().withDisappearingModeProtocol()
+        const usyncQuery = new USyncQuery().withDisappearingModeProtocol()
         
         for (const jid of jids) {
-            usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid))
+            usyncQuery.withUser(new USyncUser().withId(jid))
         }
         
         const result = await suki.executeUSyncQuery(usyncQuery)
+        
         if (result) {
             return result.list
         }
     }
     
     /** update the profile picture for yourself or a group */
-    const updateProfilePicture = async (jid, content) => {
+    const updateProfilePicture = async (jid, content, dimensions) => {
         let targetJid
         
         if (!jid) {
-            throw new boom_1.Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update')
+            throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update')
+        }
+        
+        if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) {
+            targetJid = jidNormalizedUser(jid) // in case it is someone other than us
         }
         
-        if (WABinary_1.jidNormalizedUser(jid) !== WABinary_1.jidNormalizedUser(authState.creds.me.id)) {
-            targetJid = WABinary_1.jidNormalizedUser(jid) // in case it is someone other than us
+        else {
+            targetJid = undefined
         }
         
-        const { img } = await Utils_1.generateProfilePicture(content)
+        const { img } = await generateProfilePicture(content, dimensions)
         
         await query({
             tag: 'iq',
             attrs: {
-                target: targetJid,
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
-                xmlns: 'w:profile:picture'
+                xmlns: 'w:profile:picture',
+                ...(targetJid ? { target: targetJid } : {})
             },
             content: [
                 {
@@ -265,20 +326,24 @@ const makeChatsSocket = (config) => {
         let targetJid
         
         if (!jid) {
-            throw new boom_1.Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update')
+            throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update')
         }
         
-        if (WABinary_1.jidNormalizedUser(jid) !== WABinary_1.jidNormalizedUser(authState.creds.me.id)) {
-            targetJid = WABinary_1.jidNormalizedUser(jid) // in case it is someone other than us
+        if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) {
+            targetJid = jidNormalizedUser(jid) // in case it is someone other than us
+        }
+        
+        else {
+            targetJid = undefined
         }
         
         await query({
             tag: 'iq',
             attrs: {
-                target: targetJid,
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
-                xmlns: 'w:profile:picture'
+                xmlns: 'w:profile:picture',
+                ...(targetJid ? { target: targetJid } : {})
             }
         })
     }
@@ -288,7 +353,7 @@ const makeChatsSocket = (config) => {
         await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'status'
             },
@@ -311,14 +376,14 @@ const makeChatsSocket = (config) => {
             tag: 'iq',
             attrs: {
                 xmlns: 'blocklist',
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'get'
             }
         })
         
-        const listNode = WABinary_1.getBinaryNodeChild(result, 'list')
+        const listNode = getBinaryNodeChild(result, 'list')
         
-        return WABinary_1.getBinaryNodeChildren(listNode, 'item').map((n) => n.attrs.jid)
+        return getBinaryNodeChildren(listNode, 'item').map((n) => n.attrs.jid)
     }
     
     const updateBlockStatus = async (jid, action) => {
@@ -326,7 +391,7 @@ const makeChatsSocket = (config) => {
             tag: 'iq',
             attrs: {
                 xmlns: 'blocklist',
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set'
             },
             content: [
@@ -359,19 +424,19 @@ const makeChatsSocket = (config) => {
                 }]
         })
         
-        const profileNode = WABinary_1.getBinaryNodeChild(results, 'business_profile')
+        const profileNode = getBinaryNodeChild(results, 'business_profile')
         
-        const profiles = WABinary_1.getBinaryNodeChild(profileNode, 'profile')
+        const profiles = getBinaryNodeChild(profileNode, 'profile')
         
         if (profiles) {
-            const address = WABinary_1.getBinaryNodeChild(profiles, 'address')
-            const description = WABinary_1.getBinaryNodeChild(profiles, 'description')
-            const website = WABinary_1.getBinaryNodeChild(profiles, 'website')
-            const email = WABinary_1.getBinaryNodeChild(profiles, 'email')
-            const category = WABinary_1.getBinaryNodeChild(WABinary_1.getBinaryNodeChild(profiles, 'categories'), 'category')
-            const businessHours = WABinary_1.getBinaryNodeChild(profiles, 'business_hours')
+            const address = getBinaryNodeChild(profiles, 'address')
+            const description = getBinaryNodeChild(profiles, 'description')
+            const website = getBinaryNodeChild(profiles, 'website')
+            const email = getBinaryNodeChild(profiles, 'email')
+            const category = getBinaryNodeChild(getBinaryNodeChild(profiles, 'categories'), 'category')
+            const businessHours = getBinaryNodeChild(profiles, 'business_hours')
             const businessHoursConfig = businessHours
-                ? WABinary_1.getBinaryNodeChildren(businessHours, 'business_hours_config')
+                ? getBinaryNodeChildren(businessHours, 'business_hours_config')
                 : undefined
             const websiteStr = website?.content?.toString()
             
@@ -395,7 +460,7 @@ const makeChatsSocket = (config) => {
         await sendNode({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'urn:xmpp:whatsapp:dirty',
                 id: generateMessageTag(),
@@ -415,7 +480,7 @@ const makeChatsSocket = (config) => {
     const newAppStateChunkHandler = (isInitialSync) => {
         return {
             onMutation(mutation) {
-                Utils_1.processSyncAction(mutation, ev, authState.creds.me, isInitialSync ? { accountSettings: authState.creds.accountSettings } : undefined, logger)
+                processSyncAction(mutation, ev, authState.creds.me, isInitialSync ? { accountSettings: authState.creds.accountSettings } : undefined, logger)
             }
         }
     }
@@ -425,10 +490,13 @@ const makeChatsSocket = (config) => {
         // otherwise when we resync from scratch -- all notifications will fire
         const initialVersionMap = {}
         const globalMutationMap = {}
+        
         await authState.keys.transaction(async () => {
             const collectionsToHandle = new Set(collections)
+            
             // in case something goes wrong -- ensure we don't enter a loop that cannot be exited from
             const attemptsMap = {}
+            
             // keep executing till all collections are done
             // sometimes a single patch request will not return all the patches (God knows why)
             // so we fetch till they're all done (this is determined by the "has_more_patches" flag)
@@ -438,15 +506,19 @@ const makeChatsSocket = (config) => {
                 
                 for (const name of collectionsToHandle) {
                     const result = await authState.keys.get('app-state-sync-version', [name])
+                    
                     let state = result[name]
+                    
                     if (state) {
                         if (typeof initialVersionMap[name] === 'undefined') {
                             initialVersionMap[name] = state.version
                         }
                     }
+                    
                     else {
-                        state = Utils_1.newLTHashState()
+                        state = newLTHashState()
                     }
+                    
                     states[name] = state
                     logger.info(`resyncing ${name} from v${state.version}`)
                     nodes.push({
@@ -455,7 +527,7 @@ const makeChatsSocket = (config) => {
                             name,
                             version: state.version.toString(),
                             // return snapshot if being synced from scratch
-                            'return_snapshot': (!state.version).toString()
+                            return_snapshot: (!state.version).toString()
                         }
                     })
                 }
@@ -463,7 +535,7 @@ const makeChatsSocket = (config) => {
                 const result = await query({
                     tag: 'iq',
                     attrs: {
-                        to: WABinary_1.S_WHATSAPP_NET,
+                        to: S_WHATSAPP_NET,
                         xmlns: 'w:sync:app:state',
                         type: 'set'
                     },
@@ -477,62 +549,76 @@ const makeChatsSocket = (config) => {
                 })
                 
                 // extract from binary node
-                const decoded = await Utils_1.extractSyncdPatches(result, config?.options)
+                const decoded = await extractSyncdPatches(result, config?.options)
                 
                 for (const key in decoded) {
                     const name = key
                     const { patches, hasMorePatches, snapshot } = decoded[name]
+                    
                     try {
                         if (snapshot) {
-                            const { state: newState, mutationMap } = await Utils_1.decodeSyncdSnapshot(name, snapshot, getAppStateSyncKey, initialVersionMap[name], appStateMacVerification.snapshot)
+                            const { state: newState, mutationMap } = await decodeSyncdSnapshot(name, snapshot, getAppStateSyncKey, initialVersionMap[name], appStateMacVerification.snapshot)
+                            
                             states[name] = newState
+                            
                             Object.assign(globalMutationMap, mutationMap)
+                            
                             logger.info(`restored state of ${name} from snapshot to v${newState.version} with mutations`)
+                            
                             await authState.keys.set({ 'app-state-sync-version': { [name]: newState } })
                         }
                         
                         // only process if there are syncd patches
                         if (patches.length) {
-                            const { state: newState, mutationMap } = await Utils_1.decodePatches(name, patches, states[name], getAppStateSyncKey, config.options, initialVersionMap[name], logger, appStateMacVerification.patch)
+                            const { state: newState, mutationMap } = await decodePatches(name, patches, states[name], getAppStateSyncKey, config.options, initialVersionMap[name], logger, appStateMacVerification.patch)
+                            
                             await authState.keys.set({ 'app-state-sync-version': { [name]: newState } })
+                            
                             logger.info(`synced ${name} to v${newState.version}`)
+                            
                             initialVersionMap[name] = newState.version
+                            
                             Object.assign(globalMutationMap, mutationMap)
                         }
                         
                         if (hasMorePatches) {
                             logger.info(`${name} has more patches...`)
-                        }                        
-                        else { // collection is done with sync
+                        }
+                        
+                        else {
+                            // collection is done with sync
                             collectionsToHandle.delete(name)
                         }
-                    }                     
+                    }
+                    
                     catch (error) {
                         // if retry attempts overshoot
                         // or key not found
-                        const isIrrecoverableError = attemptsMap[name] >= MAX_SYNC_ATTEMPTS
-                            || error.output?.statusCode === 404
-                            || error.name === 'TypeError'
+                        const isIrrecoverableError = attemptsMap[name] >= MAX_SYNC_ATTEMPTS ||
+                            error.output?.statusCode === 404 ||
+                            error.name === 'TypeError'
+                            
                         logger.info({ name, error: error.stack }, `failed to sync state from version${isIrrecoverableError ? '' : ', removing and trying from scratch'}`)
+                        
                         await authState.keys.set({ 'app-state-sync-version': { [name]: null } })
+                        
                         // increment number of retries
                         attemptsMap[name] = (attemptsMap[name] || 0) + 1
                         
                         if (isIrrecoverableError) {
                             // stop retrying
-                            collectionsToHandle.delete(name)
+                            collectionsToHandle.delete(name);
                         }
                     }
                 }
             }
         }, authState?.creds?.me?.id || 'resync-app-state')
-        
         const { onMutation } = newAppStateChunkHandler(isInitialSync)
         
         for (const key in globalMutationMap) {
             onMutation(globalMutationMap[key])
         }
-    })    
+    })
     
     // source: https://github.com/WhiskeySockets/Baileys/pull/1677
     const createCallLink = async (type, event, timeoutMs) => {
@@ -562,10 +648,10 @@ const makeChatsSocket = (config) => {
     		}]
     	}, timeoutMs) 
     
-    	const child = WABinary_1.getBinaryNodeChild(result, 'link_create') 
+    	const child = getBinaryNodeChild(result, 'link_create') 
     	const token = child?.attrs?.token
     
-    	return type === 'audio' ? Defaults_1.CALL_AUDIO_PREFIX + token : Defaults_1.CALL_VIDEO_PREFIX + token
+    	return type === 'audio' ? CALL_AUDIO_PREFIX + token : CALL_VIDEO_PREFIX + token
     }
     
     const sendPresenceUpdate = async (type, toJid) => {
@@ -587,7 +673,7 @@ const makeChatsSocket = (config) => {
             })
         }
         else {
-        	const { server } = WABinary_1.jidDecode(toJid) 
+        	const { server } = jidDecode(toJid) 
         
             await sendNode({
                 tag: 'chatstate',
@@ -629,10 +715,11 @@ const makeChatsSocket = (config) => {
     
     const handlePresenceUpdate = ({ tag, attrs, content }) => {
         let presence
+        
         const jid = attrs.from
         const participant = attrs.participant || attrs.from
         
-        if (shouldIgnoreJid(jid) && jid !== '@s.whatsapp.net') {
+        if (shouldIgnoreJid(jid) && jid !== S_WHATSAPP_NET) {
             return
         }
         
@@ -645,6 +732,7 @@ const makeChatsSocket = (config) => {
         
         else if (Array.isArray(content)) {
             const [firstChild] = content
+            
             let type = firstChild.tag
             
             if (type === 'paused') {
@@ -672,25 +760,28 @@ const makeChatsSocket = (config) => {
         const myAppStateKeyId = authState.creds.myAppStateKeyId
         
         if (!myAppStateKeyId) {
-            throw new boom_1.Boom('App state key not present!', { statusCode: 400 })
+            throw new Boom('App state key not present!', { statusCode: 400 })
         }
         
         let initial
         let encodeResult
         
-        await processingMutex.mutex(async () => {
+        await appStatePatchMutex.mutex(async () => {
             await authState.keys.transaction(async () => {
                 logger.debug({ patch: patchCreate }, 'applying app patch')
+                
                 await resyncAppState([name], false)
+                
                 const { [name]: currentSyncVersion } = await authState.keys.get('app-state-sync-version', [name])
-                initial = currentSyncVersion || Utils_1.newLTHashState()
-                encodeResult = await Utils_1.encodeSyncdPatch(patchCreate, myAppStateKeyId, initial, getAppStateSyncKey)
-                const { patch, state } = encodeResult
                 
+                initial = currentSyncVersion || newLTHashState()
+                encodeResult = await encodeSyncdPatch(patchCreate, myAppStateKeyId, initial, getAppStateSyncKey)
+                
+                const { patch, state } = encodeResult
                 const node = {
                     tag: 'iq',
                     attrs: {
-                        to: WABinary_1.S_WHATSAPP_NET,
+                        to: S_WHATSAPP_NET,
                         type: 'set',
                         xmlns: 'w:sync:app:state'
                     },
@@ -704,13 +795,13 @@ const makeChatsSocket = (config) => {
                                     attrs: {
                                         name,
                                         version: (state.version - 1).toString(),
-                                        'return_snapshot': 'false'
+                                        return_snapshot: 'false'
                                     },
                                     content: [
                                         {
                                             tag: 'patch',
                                             attrs: {},
-                                            content: WAProto_1.proto.SyncdPatch.encode(patch).finish()
+                                            content: proto.SyncdPatch.encode(patch).finish()
                                         }
                                     ]
                                 }
@@ -718,6 +809,7 @@ const makeChatsSocket = (config) => {
                         }
                     ]
                 }
+                
                 await query(node)
                 await authState.keys.set({ 'app-state-sync-version': { [name]: state } })
             }, authState?.creds?.me?.id || 'app-patch')
@@ -725,7 +817,7 @@ const makeChatsSocket = (config) => {
         
         if (config.emitOwnEvents) {
             const { onMutation } = newAppStateChunkHandler(false)
-            const { mutationMap } = await Utils_1.decodePatches(name, [{ ...encodeResult.patch, version: { version: encodeResult.state.version }, }], initial, getAppStateSyncKey, config.options, undefined, logger)
+            const { mutationMap } = await decodePatches(name, [{ ...encodeResult.patch, version: { version: encodeResult.state.version } }], initial, getAppStateSyncKey, config.options, undefined, logger)
             
             for (const key in mutationMap) {
                 onMutation(mutationMap[key])
@@ -735,33 +827,39 @@ const makeChatsSocket = (config) => {
     
     /** sending non-abt props may fix QR scan fail if server expects */
     const fetchProps = async () => {
+        //TODO: implement both protocol 1 and protocol 2 prop fetching, specially for abKey for WM
         const resultNode = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: S_WHATSAPP_NET,
                 xmlns: 'w',
-                type: 'get',
+                type: 'get'
             },
             content: [
-                { tag: 'props', attrs: {
+                {
+                    tag: 'props',
+                    attrs: {
                         protocol: '2',
                         hash: authState?.creds?.lastPropHash || ''
-                    } }
+                    }
+                }
             ]
         })
         
-        const propsNode = WABinary_1.getBinaryNodeChild(resultNode, 'props')
+        const propsNode = getBinaryNodeChild(resultNode, 'props')
         let props = {}
         
         if (propsNode) {
-            if (propsNode.attrs?.hash) { // on some clients, the hash is returning as undefined
+            if (propsNode.attrs?.hash) {
+                // on some clients, the hash is returning as undefined
                 authState.creds.lastPropHash = propsNode?.attrs?.hash
                 ev.emit('creds.update', authState.creds)
             }
             
-            props = WABinary_1.reduceBinaryNodeToDictionary(propsNode, 'prop')
+            props = reduceBinaryNodeToDictionary(propsNode, 'prop')
         }
         logger.debug('fetched props')
+        
         return props
     }
     
@@ -771,7 +869,7 @@ const makeChatsSocket = (config) => {
      * requires the last messages till the last message received required for archive & unread
     */
     const chatModify = (mod, jid) => {
-        const patch = Utils_1.chatModificationToAppPatch(mod, jid)
+        const patch = chatModificationToAppPatch(mod, jid)
         return appPatch(patch)
     }
     
@@ -918,9 +1016,11 @@ const makeChatsSocket = (config) => {
     
     const upsertMessage = ev.createBufferedFunction(async (msg, type) => {
         ev.emit('messages.upsert', { messages: [msg], type })
+        
         if (!!msg.pushName) {
-            let jid = msg.key.fromMe ? authState.creds.me.id : (msg.key.participant || msg.key.remoteJid)
-            jid = WABinary_1.jidNormalizedUser(jid)
+            let jid = msg.key.fromMe ? authState.creds.me.id : msg.key.participant || msg.key.remoteJid
+            
+            jid = jidNormalizedUser(jid)
             
             if (!msg.key.fromMe) {
                 ev.emit('contacts.update', [{ id: jid, notify: msg.pushName, verifiedName: msg.verifiedBizName }])
@@ -932,42 +1032,51 @@ const makeChatsSocket = (config) => {
             }
         }
         
-        const historyMsg = Utils_1.getHistoryMsg(msg.message)
+        const historyMsg = getHistoryMsg(msg.message)
         const shouldProcessHistoryMsg = historyMsg
-            ? (shouldSyncHistoryMessage(historyMsg)
-                && Defaults_1.PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType))
+            ? shouldSyncHistoryMessage(historyMsg) &&
+                PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
             : false
             
-        if (historyMsg && syncState === Types_1.SyncState.AwaitingInitialSync) {
+        // State machine: decide on sync and flush
+        if (historyMsg && syncState === SyncState.AwaitingInitialSync) {
             if (awaitingSyncTimeout) {
-            	clearTimeout(awaitingSyncTimeout) 
-            	awaitingSyncTimeout = undefined
+                clearTimeout(awaitingSyncTimeout)
+                awaitingSyncTimeout = undefined
             }
             
             if (shouldProcessHistoryMsg) {
-            	syncState = Types_1.SyncState.Syncing
-            	logger.info('Transitioned to Syncing state') 
-            	// Let doAppStateSync handle the final flush after it`s done
-            } else {
-            	syncState = Types_1.SyncState.Online
-            	logger.info('History sync skipped, transitioning to Online state and flushing buffer') 
-            	ev.flush() 
+                syncState = SyncState.Syncing
+                logger.info('Transitioned to Syncing state')
+                // Let doAppStateSync handle the final flush after it's done
+            }
+            
+            else {
+                syncState = SyncState.Online
+                
+                logger.info('History sync skipped, transitioning to Online state and flushing buffer')
+                
+                ev.flush()
             }
         }
         
         const doAppStateSync = async () => {
-        	if (syncState === Types_1.SyncState.Syncing) {
-        		logger.info('Doing app state sync') 
-        		await resyncAppState(Types_1.ALL_WA_PATCH_NAMES, true)
-        
-        		// Sync is complete, go online and flush everything
-        		syncState = Types_1.SyncState.Online
-        		logger.info('App state sync complete, transitioning to Online state and flushing buffer') 
-        		ev.flush() 
-        
-        		const accountSyncCounter = (authState.creds.accountSyncCounter || 0) + 1
-        		ev.emit('creds.update', { accountSyncCounter }) 
-        	}
+            if (syncState === SyncState.Syncing) {
+                logger.info('Doing app state sync')
+                
+                await resyncAppState(ALL_WA_PATCH_NAMES, true)
+                
+                // Sync is complete, go online and flush everything
+                syncState = SyncState.Online
+                
+                logger.info('App state sync complete, transitioning to Online state and flushing buffer')
+                
+                ev.flush()
+                
+                const accountSyncCounter = (authState.creds.accountSyncCounter || 0) + 1
+                
+                ev.emit('creds.update', { accountSyncCounter })
+            }
         }
         
         await Promise.all([
@@ -976,8 +1085,8 @@ const makeChatsSocket = (config) => {
                     await doAppStateSync()
                 }
             })(),
-            Utils_1.processMessage(msg, {
-            	signalRepository, 
+            processMessage(msg, {
+                signalRepository,
                 shouldProcessHistoryMsg,
                 placeholderResendCache,
                 ev,
@@ -985,36 +1094,39 @@ const makeChatsSocket = (config) => {
                 keyStore: authState.keys,
                 logger,
                 options: config.options,
-                getMessage: config.getMessage,
+                getMessage
             })
         ])
         
-        if (msg.message?.protocolMessage?.appStateSyncKeyShare && syncState === Types_1.SyncState.Syncing) {
-        	logger.info('App state sync key arrived, triggering app state sync') 
-        	await doAppStateSync() 
+        // If the app state key arrives and we are waiting to sync, trigger the sync now.
+        if (msg.message?.protocolMessage?.appStateSyncKeyShare && syncState === SyncState.Syncing) {
+            logger.info('App state sync key arrived, triggering app state sync')
+            await doAppStateSync()
         }
     })
     
     ws.on('CB:presence', handlePresenceUpdate)
     ws.on('CB:chatstate', handlePresenceUpdate)
     ws.on('CB:ib,,dirty', async (node) => {
-        const { attrs } = WABinary_1.getBinaryNodeChild(node, 'dirty')
+        const { attrs } = getBinaryNodeChild(node, 'dirty')
         const type = attrs.type
         
         switch (type) {
             case 'account_sync':
                 if (attrs.timestamp) {
                     let { lastAccountSyncTimestamp } = authState.creds
+                    
                     if (lastAccountSyncTimestamp) {
                         await cleanDirtyBits('account_sync', lastAccountSyncTimestamp)
                     }
+                    
                     lastAccountSyncTimestamp = +attrs.timestamp
+                    
                     ev.emit('creds.update', { lastAccountSyncTimestamp })
                 }
                 break
             case 'groups':
-                await groupFetchAllParticipating()
-                await cleanDirtyBits('groups')
+                // handled in groups.js
                 break
             default:
                 logger.info({ node }, 'received unknown sync')
@@ -1025,45 +1137,46 @@ const makeChatsSocket = (config) => {
     ev.on('connection.update', ({ connection, receivedPendingNotifications }) => {
         if (connection === 'open') {
             if (fireInitQueries) {
-                executeInitQueries()
-                    .catch(error => onUnexpectedError(error, 'init queries'))
+                executeInitQueries().catch(error => onUnexpectedError(error, 'init queries'))
             }
-            sendPresenceUpdate(markOnlineOnConnect ? 'available' : 'unavailable')
-                .catch(error => onUnexpectedError(error, 'presence update requests'))
+            
+            sendPresenceUpdate(markOnlineOnConnect ? 'available' : 'unavailable').catch(error => onUnexpectedError(error, 'presence update requests'))
         }
         
-        if (!receivedPendingNotifications || syncState !== Types_1.SyncState.Connecting) {
-        	return
+        if (!receivedPendingNotifications || syncState !== SyncState.Connecting) {
+            return
         }
         
-        syncState = Types_1.AwaitingInitialSync
-        logger.info('Connection is now AwaitingInitialSync, buffering events') 
-        ev.buffer() 
+        syncState = SyncState.AwaitingInitialSync
+        
+        logger.info('Connection is now AwaitingInitialSync, buffering events')
+        ev.buffer()
         
-        const willSyncHistory = shouldSyncHistoryMessage(WAProto_1.proto.Message.HistorySyncNotification.fromObject({
-        	syncType: WAProto_1.proto.HistorySync.HistorySyncType.RECENT
-        })) 
+        const willSyncHistory = shouldSyncHistoryMessage(proto.Message.HistorySyncNotification.create({
+            syncType: proto.HistorySync.HistorySyncType.RECENT
+        }))
         
         if (!willSyncHistory) {
-        	logger.info('History sync is disabled by config, not waiting for notification. Transitioning to Online.') 
-        	syncState = Types_1.SyncState.Online
-        	setTimeout(() => ev.flush(), 0) 
-        	return 
+            logger.info('History sync is disabled by config, not waiting for notification. Transitioning to Online.')
+            syncState = SyncState.Online
+            setTimeout(() => ev.flush(), 0)
+            return
         }
         
-        logger.info('History sync is enabled, awaiting notification with a 20s timeout.') 
+        logger.info('History sync is enabled, awaiting notification with a 20s timeout.')
         
         if (awaitingSyncTimeout) {
-        	clearTimeout(awaitingSyncTimeout) 
+            clearTimeout(awaitingSyncTimeout);
         }
         
         awaitingSyncTimeout = setTimeout(() => {
-        	if (syncState === Types_1.SyncState.AwaitingInitialSync) {
-        		logger.warn('Timeout in AwaitingInitialSync, forcing state to Online and flushing buffer') 
-        		syncState = Types_1.SyncState.Online
-        		ev.flush() 
-        	}
-        }, 20_000) 
+            if (syncState === SyncState.AwaitingInitialSync) {
+                // TODO: investigate
+                logger.warn('Timeout in AwaitingInitialSync, forcing state to Online and flushing buffer')
+                syncState = SyncState.Online
+                ev.flush()
+            }
+        }, 20000)
     })
     
     return {
@@ -1071,7 +1184,6 @@ const makeChatsSocket = (config) => {
         star, 
         addOrEditContact, 
         removeContact, 
-        processingMutex,
         fetchPrivacySettings,
         upsertMessage,
         appPatch,
@@ -1079,6 +1191,10 @@ const makeChatsSocket = (config) => {
         sendPresenceUpdate,
         presenceSubscribe, 
         getBotListV2,  
+        messageMutex, 
+        receiptMutex, 
+        appStatePatchMutex, 
+        notificationMutex, 
         getLidUser, 
         fetchBlocklist,
         fetchStatus,