neroxbailx/lib/Socket/chats.js

baileys whatsapp-api

"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 usync_1 = require("./usync")
const MAX_SYNC_ATTEMPTS = 2
const makeChatsSocket = (config) => {
const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, } = config
const sock = usync_1.makeUSyncSocket(config)
const { ev, ws, authState, generateMessageTag, sendNode, query, onUnexpectedError, groupFetchAllParticipating } = sock
let privacySettings
let needToFlushWithAppStateSync = false
let pendingAppStateSync = false
/** this mutex ensures that the notifications (receipts, messages etc.) are processed in order */
const processingMutex = make_mutex_1.makeMutex()
const placeholderResendCache = config.placeholderResendCache || new node_cache_1.default({
stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY,
useClones: false
})
if (!config.placeholderResendCache) {
config.placeholderResendCache = placeholderResendCache
}
/** helper function to fetch the given app state sync key */
const getAppStateSyncKey = async (keyId) => {
const { [keyId]: key } = await authState.keys.get('app-state-sync-key', [keyId])
return key
}
const fetchPrivacySettings = async (force = false) => {
if (!privacySettings || force) {
const { content } = await query({
tag: 'iq',
attrs: {
xmlns: 'privacy',
to: WABinary_1.S_WHATSAPP_NET,
type: 'get'
},
content: [
{ tag: 'privacy', attrs: {} }
]
})
privacySettings = WABinary_1.reduceBinaryNodeToDictionary(content?.[0], 'category')
}
return privacySettings
}
/** helper function to run a privacy IQ query */
const privacyQuery = async (name, value) => {
await query({
tag: 'iq',
attrs: {
xmlns: 'privacy',
to: WABinary_1.S_WHATSAPP_NET,
type: 'set'
},
content: [{
tag: 'privacy',
attrs: {},
content: [
{
tag: 'category',
attrs: { name, value }
}
]
}]
})
}
const updateMessagesPrivacy = async (value) => {
await privacyQuery('messages', value)
}
const updateCallPrivacy = async (value) => {
await privacyQuery('calladd', value)
}
const updateLastSeenPrivacy = async (value) => {
await privacyQuery('last', value)
}
const updateOnlinePrivacy = async (value) => {
await privacyQuery('online', value)
}
const updateProfilePicturePrivacy = async (value) => {
await privacyQuery('profile', value)
}
const updateStatusPrivacy = async (value) => {
await privacyQuery('status', value)
}
const updateReadReceiptsPrivacy = async (value) => {
await privacyQuery('readreceipts', value)
}
const updateGroupsAddPrivacy = async (value) => {
await privacyQuery('groupadd', value)
}
const updateDefaultDisappearingMode = async (duration) => {
await query({
tag: 'iq',
attrs: {
xmlns: 'disappearing_mode',
to: WABinary_1.S_WHATSAPP_NET,
type: 'set'
},
content: [{
tag: 'disappearing_mode',
attrs: {
duration: duration.toString()
}
}]
})
}
const getBotListV2 = async () => {
const resp = await query({
tag: 'iq',
attrs: {
xmlns: 'bot',
to: WABinary_1.S_WHATSAPP_NET,
type: 'get'
},
content: [{
tag: 'bot',
attrs: {
v: '2'
}
}]
})
const botNode = WABinary_1.getBinaryNodeChild(resp, 'bot')
const botList = []
for(const section of WABinary_1.getBinaryNodeChildren(botNode, 'section')) {
if(section.attrs.type === 'all') {
for(const bot of WABinary_1.getBinaryNodeChildren(section, 'bot')) {
botList.push({
jid: bot.attrs.jid,
personaId: bot.attrs['persona_id']
})
}
}
}
return botList
}
const getLidUser = async (jid) => {
if (!jid) {
throw new boom_1.Boom('Please input a jid user')
}
if (!WABinary_1.isJidUser(jid)) {
throw new boom_1.Boom('Invalid JID: Not a user JID!')
}
const targetJid = WABinary_1.jidNormalizedUser(jid)
const usyncQuery = new WAUSync_1.USyncQuery() 
usyncQuery.protocols.push({
name: 'lid', 
getQueryElement: () => ({
tag: 'lid', 
attrs: {}, 
content: undefined
}), 
getUserElement: () => null, 
parser: (node) => node.attrs.val
}) 
usyncQuery.users.push({
id: targetJid
})
const result = await sock.executeUSyncQuery(usyncQuery)
if (result) {
return result.list
}
}
const onWhatsApp = async (...jids) => {
const usyncQuery = new WAUSync_1.USyncQuery().withContactProtocol().withLIDProtocol() 
for (const jid of jids) {
const phone = `+${jid.replace('+', '').split('@')[0].split(':')[0]}`
usyncQuery.withUser(new WAUSync_1.USyncUser().withPhone(phone))
}
const results = await sock.executeUSyncQuery(usyncQuery)
if (results) {
return results.list.filter((a) => !!a.contact).map(({ contact, id, lid }) => ({ jid: id, exists: contact, lid }))
}
}
const fetchStatus = async (...jids) => {
const usyncQuery = new WAUSync_1.USyncQuery().withStatusProtocol()
for (const jid of jids) {
usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid))
}
const result = await sock.executeUSyncQuery(usyncQuery)
if (result) {
return result.list
}
}
const fetchDisappearingDuration = async (...jids) => {   	
const usyncQuery = new WAUSync_1.USyncQuery().withDisappearingModeProtocol()
for (const jid of jids) {
usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid))
}
const result = await sock.executeUSyncQuery(usyncQuery)
if (result) {
return result.list
}
}
/** update the profile picture for yourself or a group */
const updateProfilePicture = async (jid, content) => {
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')
}
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
}
const { img } = await Utils_1.generateProfilePicture(content)
await query({
tag: 'iq',
attrs: {
target: targetJid,
to: WABinary_1.S_WHATSAPP_NET,
type: 'set',
xmlns: 'w:profile:picture'
},
content: [
{
tag: 'picture',
attrs: { type: 'image' },
content: img
}
]
})
}
/** remove the profile picture for yourself or a group */
const removeProfilePicture = async (jid) => {
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')
}
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
}
await query({
tag: 'iq',
attrs: {
target: targetJid,
to: WABinary_1.S_WHATSAPP_NET,
type: 'set',
xmlns: 'w:profile:picture'
}
})
}
/** update the profile status for yourself */
const updateProfileStatus = async (status) => {
await query({
tag: 'iq',
attrs: {
to: WABinary_1.S_WHATSAPP_NET,
type: 'set',
xmlns: 'status'
},
content: [
{
tag: 'status',
attrs: {},
content: Buffer.from(status, 'utf-8')
}
]
})
}
const updateProfileName = async (name) => {
await chatModify({ pushNameSetting: name }, '')
}
const fetchBlocklist = async () => {
const result = await query({
tag: 'iq',
attrs: {
xmlns: 'blocklist',
to: WABinary_1.S_WHATSAPP_NET,
type: 'get'
}
})
const listNode = WABinary_1.getBinaryNodeChild(result, 'list')
return WABinary_1.getBinaryNodeChildren(listNode, 'item').map((n) => n.attrs.jid)
}
const updateBlockStatus = async (jid, action) => {
await query({
tag: 'iq',
attrs: {
xmlns: 'blocklist',
to: WABinary_1.S_WHATSAPP_NET,
type: 'set'
},
content: [
{
tag: 'item',
attrs: {
action,
jid
}
}
]
})
}
const getBusinessProfile = async (jid) => {
const results = await query({
tag: 'iq',
attrs: {
to: 's.whatsapp.net',
xmlns: 'w:biz',
type: 'get'
},
content: [{
tag: 'business_profile',
attrs: { v: '244' },
content: [{
tag: 'profile',
attrs: { jid }
}]
}]
})
const profileNode = WABinary_1.getBinaryNodeChild(results, 'business_profile')
const profiles = WABinary_1.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 businessHoursConfig = businessHours
? WABinary_1.getBinaryNodeChildren(businessHours, 'business_hours_config')
: undefined
const websiteStr = website?.content?.toString()
return {
wid: profiles?.attrs?.jid,
address: address?.content?.toString(),
description: description?.content?.toString() || '',
website: websiteStr ? [websiteStr] : [],
email: email?.content?.toString(),
category: category?.content?.toString(),
'business_hours': {
timezone: businessHours?.attrs?.timezone,
'business_config': businessHoursConfig?.map(({ attrs }) => attrs)
}
}
}
}
const cleanDirtyBits = async (type, fromTimestamp) => {
logger.info({ fromTimestamp }, 'clean dirty bits ' + type)
await sendNode({
tag: 'iq',
attrs: {
to: WABinary_1.S_WHATSAPP_NET,
type: 'set',
xmlns: 'urn:xmpp:whatsapp:dirty',
id: generateMessageTag(),
},
content: [
{
tag: 'clean',
attrs: {
type,
...(fromTimestamp ? { timestamp: fromTimestamp.toString() } : null),
}
}
]
})
}
const newAppStateChunkHandler = (isInitialSync) => {
return {
onMutation(mutation) {
Utils_1.processSyncAction(mutation, ev, authState.creds.me, isInitialSync ? { accountSettings: authState.creds.accountSettings } : undefined, logger)
}
}
}
const resyncAppState = ev.createBufferedFunction(async (collections, isInitialSync) => {
// we use this to determine which events to fire
// 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)
while (collectionsToHandle.size) {
const states = {}
const nodes = []
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()
}
states[name] = state
logger.info(`resyncing ${name} from v${state.version}`)
nodes.push({
tag: 'collection',
attrs: {
name,
version: state.version.toString(),
// return snapshot if being synced from scratch
'return_snapshot': (!state.version).toString()
}
})
}
const result = await query({
tag: 'iq',
attrs: {
to: WABinary_1.S_WHATSAPP_NET,
xmlns: 'w:sync:app:state',
type: 'set'
},
content: [
{
tag: 'sync',
attrs: {},
content: nodes
}
]
})
// extract from binary node
const decoded = await Utils_1.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)
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)
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
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'
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)
}
}
}
}
})
const { onMutation } = newAppStateChunkHandler(isInitialSync)
for (const key in globalMutationMap) {
onMutation(globalMutationMap[key])
}
})    
const sendPresenceUpdate = async (type, toJid) => {
const me = authState.creds.me
if (type === 'available' || type === 'unavailable') {
if (!me.name) {
logger.warn('no name present, ignoring presence update request...')
return
}
ev.emit('connection.update', { isOnline: type === 'available' })
await sendNode({
tag: 'presence',
attrs: {
name: me.name,
type
}
})
}
else {
await sendNode({
tag: 'chatstate',
attrs: {
from: me.id,
to: toJid,
},
content: [
{
tag: type === 'recording' ? 'composing' : type,
attrs: type === 'recording' ? { media: 'audio' } : {}
}
]
})
}
}
/**
* @param toJid the jid to subscribe to
* @param tcToken token for subscription, use if present
*/
const presenceSubscribe = (toJid, tcToken) => (sendNode({
tag: 'presence',
attrs: {
to: toJid,
id: generateMessageTag(),
type: 'subscribe'
},
content: tcToken
? [
{
tag: 'tctoken',
attrs: {},
content: tcToken
}
]
: undefined
}))
const handlePresenceUpdate = ({ tag, attrs, content }) => {
let presence
const jid = attrs.from
const participant = attrs.participant || attrs.from
if (shouldIgnoreJid(jid) && jid !== '@s.whatsapp.net') {
return
}
if (tag === 'presence') {
presence = {
lastKnownPresence: attrs.type === 'unavailable' ? 'unavailable' : 'available',
lastSeen: attrs.last && attrs.last !== 'deny' ? +attrs.last : undefined
}
}
else if (Array.isArray(content)) {
const [firstChild] = content
let type = firstChild.tag
if (type === 'paused') {
type = 'available'
}
if (firstChild.attrs?.media === 'audio') {
type = 'recording'
}
presence = { lastKnownPresence: type }
}
else {
logger.error({ tag, attrs, content }, 'recv invalid presence node')
}
if (presence) {
ev.emit('presence.update', { id: jid, presences: { [participant]: presence } })
}
}
const appPatch = async (patchCreate) => {
const name = patchCreate.type
const myAppStateKeyId = authState.creds.myAppStateKeyId
if (!myAppStateKeyId) {
throw new boom_1.Boom('App state key not present!', { statusCode: 400 })
}
let initial
let encodeResult
await processingMutex.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
const node = {
tag: 'iq',
attrs: {
to: WABinary_1.S_WHATSAPP_NET,
type: 'set',
xmlns: 'w:sync:app:state'
},
content: [
{
tag: 'sync',
attrs: {},
content: [
{
tag: 'collection',
attrs: {
name,
version: (state.version - 1).toString(),
'return_snapshot': 'false'
},
content: [
{
tag: 'patch',
attrs: {},
content: WAProto_1.proto.SyncdPatch.encode(patch).finish()
}
]
}
]
}
]
}
await query(node)
await authState.keys.set({ 'app-state-sync-version': { [name]: state } })
})
})
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)
for (const key in mutationMap) {
onMutation(mutationMap[key])
}
}
}
/** sending non-abt props may fix QR scan fail if server expects */
const fetchProps = async () => {
const resultNode = await query({
tag: 'iq',
attrs: {
to: WABinary_1.S_WHATSAPP_NET,
xmlns: 'w',
type: 'get',
},
content: [
{ tag: 'props', attrs: {
protocol: '2',
hash: authState?.creds?.lastPropHash || ''
} }
]
})
const propsNode = WABinary_1.getBinaryNodeChild(resultNode, 'props')
let props = {}
if (propsNode) {
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')
}
logger.debug('fetched props')
return props
}
/**
* modify a chat -- mark unread, read etc.
* lastMessages must be sorted in reverse chronologically
* requires the last messages till the last message received required for archive & unread
*/
const chatModify = (mod, jid) => {
const patch = Utils_1.chatModificationToAppPatch(mod, jid)
return appPatch(patch)
}
/**
* Star or Unstar a message
*/
const star = (jid, messages, star) => {
return chatModify({
star: {
messages,
star
}
}, jid)
}
/**
* Add Or Edit Contact
*/
const addOrEditContact = (jid, contact) => {
return chatModify({
contact
}, jid) 
}
/**
* Remove Contact
*/
const removeContact = (jid) => {
return chatModify({
contact: null
}, jid) 
}
/**
* Adds label
*/
const addLabel = (jid, labels) => {
return chatModify({
addLabel: {
...labels
}
}, jid)
}
/**
* Adds label for the chats
*/
const addChatLabel = (jid, labelId) => {
return chatModify({
addChatLabel: {
labelId
}
}, jid)
}
/**
* Removes label for the chat
*/
const removeChatLabel = (jid, labelId) => {
return chatModify({
removeChatLabel: {
labelId
}
}, jid)
}
/**
* Adds label for the message
*/
const addMessageLabel = (jid, messageId, labelId) => {
return chatModify({
addMessageLabel: {
messageId,
labelId
}
}, jid)
}
/**
* Removes label for the message
*/
const removeMessageLabel = (jid, messageId, labelId) => {
return chatModify({
removeMessageLabel: {
messageId,
labelId
}
}, jid)
}
/**
* Removes Chats 
*/
const clearMessage = (jid, key, timeStamp) => {
return chatModify({
delete: true,
lastMessages: [{
key: key,
messageTimestamp: timeStamp
}],
}, jid)
}
/**
* queries need to be fired on connection open
* help ensure parity with WA Web
* */
const executeInitQueries = async () => {
await Promise.all([
fetchProps(),
fetchBlocklist(),
fetchPrivacySettings(),
])
}
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)
if (!msg.key.fromMe) {
ev.emit('contacts.update', [{ id: jid, notify: msg.pushName, verifiedName: msg.verifiedBizName }])
}
// update our pushname too
if (msg.key.fromMe && msg.pushName && authState.creds.me?.name !== msg.pushName) {
ev.emit('creds.update', { me: { ...authState.creds.me, name: msg.pushName } })
}
}
const historyMsg = Utils_1.getHistoryMsg(msg.message)
const shouldProcessHistoryMsg = historyMsg
? (shouldSyncHistoryMessage(historyMsg)
&& Defaults_1.PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType))
: false
if (historyMsg && !authState.creds.myAppStateKeyId) {
logger.warn('skipping app state sync, as myAppStateKeyId is not set')
pendingAppStateSync = true
}
await Promise.all([
(async () => {
if (historyMsg
&& authState.creds.myAppStateKeyId) {
pendingAppStateSync = false
await doAppStateSync()
}
})(),
Utils_1.processMessage(msg, {
shouldProcessHistoryMsg,
placeholderResendCache,
ev,
creds: authState.creds,
keyStore: authState.keys,
logger,
options: config.options,
getMessage: config.getMessage,
})
])
if (msg.message?.protocolMessage?.appStateSyncKeyShare
&& pendingAppStateSync) {
await doAppStateSync()
pendingAppStateSync = false
}
async function doAppStateSync() {
if (!authState.creds.accountSyncCounter) {
logger.info('doing initial app state sync')
await resyncAppState(Types_1.ALL_WA_PATCH_NAMES, true)
const accountSyncCounter = (authState.creds.accountSyncCounter || 0) + 1
ev.emit('creds.update', { accountSyncCounter })
if (needToFlushWithAppStateSync) {
logger.debug('flushing with app state sync')
ev.flush()
}
}
}
})
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 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')
break
default:
logger.info({ node }, 'received unknown sync')
break
}
})
ev.on('connection.update', ({ connection, receivedPendingNotifications }) => {
if (connection === 'open') {
if (fireInitQueries) {
executeInitQueries()
.catch(error => onUnexpectedError(error, 'init queries'))
}
sendPresenceUpdate(markOnlineOnConnect ? 'available' : 'unavailable')
.catch(error => onUnexpectedError(error, 'presence update requests'))
}
if (receivedPendingNotifications && // if we don't have the app state key
// we keep buffering events until we finally have
// the key and can sync the messages
// todo scrutinize
!authState.creds?.myAppStateKeyId) {
ev.buffer()
needToFlushWithAppStateSync = true
}
})
return {
...sock, 
star, 
addOrEditContact, 
removeContact, 
processingMutex,
fetchPrivacySettings,
upsertMessage,
appPatch,
sendPresenceUpdate,
presenceSubscribe, 
getBotListV2,  
getLidUser, 
onWhatsApp,
fetchBlocklist,
fetchStatus,
fetchDisappearingDuration,
updateProfilePicture,
removeProfilePicture,
updateProfileStatus,
updateProfileName,
updateBlockStatus,
updateCallPrivacy,
updateMessagesPrivacy, 
updateLastSeenPrivacy,
updateOnlinePrivacy,
updateProfilePicturePrivacy,
updateStatusPrivacy,
updateReadReceiptsPrivacy,
updateGroupsAddPrivacy,
updateDefaultDisappearingMode,
getBusinessProfile,
resyncAppState,
chatModify,
cleanDirtyBits,
addLabel,
addChatLabel,
removeChatLabel,
addMessageLabel,
removeMessageLabel,
clearMessage
}
}
module.exports = {
makeChatsSocket
}