@hansaka02/baileys 7.3.4 → 7.3.6

package/lib/Socket/chats.js

@@ -29,6 +29,7 @@ const {
 } = require("../Utils")
 const { makeMutex } = require("../Utils/make-mutex")
 const {
+  isPnUser, 
   getBinaryNodeChild, 
   getBinaryNodeChildren, 
   jidDecode, 
@@ -44,24 +45,53 @@ const { makeSocket } = require("./socket")
 const MAX_SYNC_ATTEMPTS = 2
 
 const makeChatsSocket = (config) => {
-    const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, } = config
+    const {
+        logger, 
+        markOnlineOnConnect, 
+        fireInitQueries, 
+        appStateMacVerification,
+        shouldIgnoreJid, 
+        shouldSyncHistoryMessage, 
+        getMessage 
+    } = config
+	
     const suki = makeSocket(config)
-    const { ev, ws, authState, generateMessageTag, sendNode, query, signalRepository, onUnexpectedError, groupFetchAllParticipating } = suki
     
+    const { 
+        ev, 
+        ws, 
+        authState, 
+        generateMessageTag, 
+        sendNode, 
+        query, 
+        signalRepository, 
+        onUnexpectedError
+    } = suki
+	
     let privacySettings
     let syncState = SyncState.Connecting
     
-    /** this mutex ensures that the notifications (receipts, messages etc.) are processed in order */
-    const processingMutex = 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 NodeCache({
-        stdTTL: 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
     }
@@ -199,7 +229,7 @@ const makeChatsSocket = (config) => {
             throw new Boom('Please input a jid user')
         }
         
-        if (!isJidUser(jid)) {
+        if (!isPnUser(jid)) {
         	throw new Boom('Invalid JID: Not a user JID!')
         }
         
@@ -240,6 +270,7 @@ const makeChatsSocket = (config) => {
             return result.list
         }
     }
+    
     const fetchDisappearingDuration = async (...jids) => {   	
         const usyncQuery = new USyncQuery().withDisappearingModeProtocol()
         
@@ -248,13 +279,14 @@ const makeChatsSocket = (config) => {
         }
         
         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) {
@@ -265,15 +297,19 @@ const makeChatsSocket = (config) => {
             targetJid = jidNormalizedUser(jid) // in case it is someone other than us
         }
         
-        const { img } = await generateProfilePicture(content)
+        else {
+            targetJid = undefined
+        }
+        
+        const { img } = await generateProfilePicture(content, dimensions)
         
         await query({
             tag: 'iq',
             attrs: {
-                target: targetJid,
                 to: S_WHATSAPP_NET,
                 type: 'set',
-                xmlns: 'w:profile:picture'
+                xmlns: 'w:profile:picture',
+                ...(targetJid ? { target: targetJid } : {})
             },
             content: [
                 {
@@ -297,13 +333,17 @@ const makeChatsSocket = (config) => {
             targetJid = jidNormalizedUser(jid) // in case it is someone other than us
         }
         
+        else {
+            targetJid = undefined
+        }
+        
         await query({
             tag: 'iq',
             attrs: {
-                target: targetJid,
                 to: S_WHATSAPP_NET,
                 type: 'set',
-                xmlns: 'w:profile:picture'
+                xmlns: 'w:profile:picture',
+                ...(targetJid ? { target: targetJid } : {})
             }
         })
     }
@@ -450,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)
@@ -463,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 = newLTHashState()
                     }
+                    
                     states[name] = state
                     logger.info(`resyncing ${name} from v${state.version}`)
                     nodes.push({
@@ -480,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()
                         }
                     })
                 }
@@ -507,57 +554,71 @@ const makeChatsSocket = (config) => {
                 for (const key in decoded) {
                     const name = key
                     const { patches, hasMorePatches, snapshot } = decoded[name]
+                    
                     try {
                         if (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 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) => {
@@ -654,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
         }
         
@@ -670,6 +732,7 @@ const makeChatsSocket = (config) => {
         
         else if (Array.isArray(content)) {
             const [firstChild] = content
+            
             let type = firstChild.tag
             
             if (type === 'paused') {
@@ -703,15 +766,18 @@ const makeChatsSocket = (config) => {
         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 || newLTHashState()
                 encodeResult = await encodeSyncdPatch(patchCreate, myAppStateKeyId, initial, getAppStateSyncKey)
-                const { patch, state } = encodeResult
                 
+                const { patch, state } = encodeResult
                 const node = {
                     tag: 'iq',
                     attrs: {
@@ -729,7 +795,7 @@ const makeChatsSocket = (config) => {
                                     attrs: {
                                         name,
                                         version: (state.version - 1).toString(),
-                                        'return_snapshot': 'false'
+                                        return_snapshot: 'false'
                                     },
                                     content: [
                                         {
@@ -743,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')
@@ -750,7 +817,7 @@ const makeChatsSocket = (config) => {
         
         if (config.emitOwnEvents) {
             const { onMutation } = newAppStateChunkHandler(false)
-            const { mutationMap } = await 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])
@@ -760,18 +827,22 @@ 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: S_WHATSAPP_NET,
                 xmlns: 'w',
-                type: 'get',
+                type: 'get'
             },
             content: [
-                { tag: 'props', attrs: {
+                {
+                    tag: 'props',
+                    attrs: {
                         protocol: '2',
                         hash: authState?.creds?.lastPropHash || ''
-                    } }
+                    }
+                }
             ]
         })
         
@@ -779,7 +850,8 @@ const makeChatsSocket = (config) => {
         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)
             }
@@ -787,6 +859,7 @@ const makeChatsSocket = (config) => {
             props = reduceBinaryNodeToDictionary(propsNode, 'prop')
         }
         logger.debug('fetched props')
+        
         return props
     }
     
@@ -943,8 +1016,10 @@ 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)
+            let jid = msg.key.fromMe ? authState.creds.me.id : msg.key.participant || msg.key.remoteJid
+            
             jid = jidNormalizedUser(jid)
             
             if (!msg.key.fromMe) {
@@ -959,40 +1034,49 @@ const makeChatsSocket = (config) => {
         
         const historyMsg = getHistoryMsg(msg.message)
         const shouldProcessHistoryMsg = historyMsg
-            ? (shouldSyncHistoryMessage(historyMsg)
-                && PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType))
+            ? shouldSyncHistoryMessage(historyMsg) &&
+                PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
             : false
             
+        // 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 = 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() 
+                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 === 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 }) 
-        	}
+            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([
@@ -1002,7 +1086,7 @@ const makeChatsSocket = (config) => {
                 }
             })(),
             processMessage(msg, {
-            	signalRepository, 
+                signalRepository,
                 shouldProcessHistoryMsg,
                 placeholderResendCache,
                 ev,
@@ -1010,13 +1094,14 @@ const makeChatsSocket = (config) => {
                 keyStore: authState.keys,
                 logger,
                 options: config.options,
-                getMessage: config.getMessage,
+                getMessage
             })
         ])
         
+        // 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() 
+            logger.info('App state sync key arrived, triggering app state sync')
+            await doAppStateSync()
         }
     })
     
@@ -1030,16 +1115,18 @@ const makeChatsSocket = (config) => {
             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')
@@ -1050,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 !== SyncState.Connecting) {
-        	return
+            return
         }
         
         syncState = SyncState.AwaitingInitialSync
-        logger.info('Connection is now AwaitingInitialSync, buffering events') 
-        ev.buffer() 
         
-        const willSyncHistory = shouldSyncHistoryMessage(proto.Message.HistorySyncNotification.fromObject({
-        	syncType: proto.HistorySync.HistorySyncType.RECENT
-        })) 
+        logger.info('Connection is now AwaitingInitialSync, buffering events')
+        ev.buffer()
+        
+        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 = 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 === SyncState.AwaitingInitialSync) {
-        		logger.warn('Timeout in AwaitingInitialSync, forcing state to Online and flushing buffer') 
-        		syncState = 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 {
@@ -1096,7 +1184,6 @@ const makeChatsSocket = (config) => {
         star, 
         addOrEditContact, 
         removeContact, 
-        processingMutex,
         fetchPrivacySettings,
         upsertMessage,
         appPatch,
@@ -1104,6 +1191,10 @@ const makeChatsSocket = (config) => {
         sendPresenceUpdate,
         presenceSubscribe, 
         getBotListV2,  
+        messageMutex, 
+        receiptMutex, 
+        appStatePatchMutex, 
+        notificationMutex, 
         getLidUser, 
         fetchBlocklist,
         fetchStatus,