@nexustechpro/baileys 2.0.6 → 2.1.2

package/lib/Socket/chats.js

@@ -1,82 +1,64 @@
 import NodeCache from '@cacheable/node-cache'
 import { Boom } from '@hapi/boom'
 import { proto } from '../../WAProto/index.js'
-import { DEFAULT_CACHE_TTLS, PROCESSABLE_HISTORY_TYPES, PHONENUMBER_MCC, MOBILE_TOKEN, MOBILE_USERAGENT, MOBILE_REGISTRATION_ENDPOINT } from '../Defaults/index.js'
+import { DEFAULT_CACHE_TTLS, HISTORY_SYNC_PAUSED_TIMEOUT_MS, PROCESSABLE_HISTORY_TYPES } from '../Defaults/index.js'
 import { ALL_WA_PATCH_NAMES } from '../Types/index.js'
 import { SyncState } from '../Types/State.js'
-import {
-    chatModificationToAppPatch,
-    decodePatches,
-    decodeSyncdSnapshot,
-    encodeSyncdPatch,
-    ensureLTHashStateVersion,
-    extractSyncdPatches,
-    generateProfilePicture,
-    getHistoryMsg,
-    newLTHashState,
-    processSyncAction
-} from '../Utils/index.js'
+import { chatModificationToAppPatch, decodePatches, decodeSyncdSnapshot, encodeSyncdPatch, ensureLTHashStateVersion, extractSyncdPatches, generateProfilePicture, getHistoryMsg, isAppStateSyncIrrecoverable, isMissingKeyError, MAX_SYNC_ATTEMPTS, newLTHashState, processSyncAction } from '../Utils/index.js'
 import { makeMutex } from '../Utils/make-mutex.js'
 import processMessage from '../Utils/process-message.js'
-import {
-    getBinaryNodeChild,
-    getBinaryNodeChildren,
-    isLidUser,
-    jidDecode,
-    jidNormalizedUser,
-    reduceBinaryNodeToDictionary,
-    S_WHATSAPP_NET,
-    VIOLATION_TYPES
-} from '../WABinary/index.js'
+import { buildTcTokenFromJid } from '../Utils/tc-token-utils.js'
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, reduceBinaryNodeToDictionary, S_WHATSAPP_NET, VIOLATION_TYPES } from '../WABinary/index.js'
 import { USyncQuery, USyncUser } from '../WAUSync/index.js'
 import { makeSocket } from './socket.js'
 
-const MAX_SYNC_ATTEMPTS = 2
-const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120_000
 const APP_STATE_RESYNC_COOLDOWN_MS = 60_000
 
 export const makeChatsSocket = (config) => {
-    const {
-        logger,
-        markOnlineOnConnect,
-        fireInitQueries,
-        appStateMacVerification,
-        shouldIgnoreJid,
-        shouldSyncHistoryMessage,
-        getMessage
-    } = config
+    const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, getMessage } = config
 
     const sock = makeSocket(config)
-    const { ev, ws, authState, generateMessageTag, sendNode, query, signalRepository, onUnexpectedError } = sock
+    const { ev, ws, authState, generateMessageTag, sendNode, query, signalRepository, onUnexpectedError, sendUnifiedSession, registerSocketEndHandler } = sock
+
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping)
 
     let privacySettings
+    /** Server-assigned AB props for protocol behavior. */
+    const serverProps = {
+        /** AB prop 10518: gate tctoken on 1:1 messages. Default true (safe: avoids 463). */
+        privacyTokenOn1to1: true,
+        /** AB prop 9666: gate tctoken on profile picture IQs. WA Web default: true. */
+        profilePicPrivacyToken: true,
+        /** AB prop 14303: issue tctokens to LID instead of PN. WA Web default: false. */
+        lidTrustedTokenIssueToLid: false
+    }
+
     let syncState = SyncState.Connecting
     let awaitingSyncTimeout
     let historySyncPausedTimeout
 
     const historySyncStatus = { initialBootstrapComplete: false, recentSyncComplete: false }
     const blockedCollections = new Set()
+    const appStateResyncCooldown = new Map()
 
+    /** this mutex ensures that processing happens in order */
     const processingMutex = makeMutex()
+    /** this mutex ensures that messages are processed in order */
     const messageMutex = makeMutex()
+    /** this mutex ensures that receipts are processed in order */
     const receiptMutex = makeMutex()
+    /** 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()
 
-    const placeholderResendCache = config.placeholderResendCache || new NodeCache({
-        stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY,
-        useClones: false
-    })
+    const placeholderResendCache = config.placeholderResendCache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, useClones: false })
     if (!config.placeholderResendCache) config.placeholderResendCache = placeholderResendCache
 
-    const profilePictureUrlCache = config.profilePictureUrlCache || new NodeCache({
-        stdTTL: DEFAULT_CACHE_TTLS.PROFILE_PIC,
-        useClones: false
-    })
+    const profilePictureUrlCache = config.profilePictureUrlCache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.PROFILE_PIC, useClones: false })
     if (!config.profilePictureUrlCache) config.profilePictureUrlCache = profilePictureUrlCache
 
     const inFlightProfilePictureUrl = new Map()
-    const appStateResyncCooldown = new Map()
 
     // ─── Key helpers ────────────────────────────────────────────────────────────
 
@@ -85,45 +67,26 @@ export const makeChatsSocket = (config) => {
         return key
     }
 
-
     const interactiveQuery = async (userNodes, queryNode) => {
-        const result = await query({
-            tag: 'iq',
-            attrs: { to: S_WHATSAPP_NET, type: 'get', xmlns: 'usync' },
-            content: [{
-                tag: 'usync',
-                attrs: { sid: generateMessageTag(), mode: 'query', last: 'true', index: '0', context: 'interactive' },
-                content: [
-                    { tag: 'query', attrs: {}, content: [queryNode] },
-                    { tag: 'list', attrs: {}, content: userNodes }
-                ]
-            }]
-        })
+        const result = await query({ tag: 'iq', attrs: { to: S_WHATSAPP_NET, type: 'get', xmlns: 'usync' }, content: [{ tag: 'usync', attrs: { sid: generateMessageTag(), mode: 'query', last: 'true', index: '0', context: 'interactive' }, content: [{ tag: 'query', attrs: {}, content: [queryNode] }, { tag: 'list', attrs: {}, content: userNodes }] }] })
         const usyncNode = getBinaryNodeChild(result, 'usync')
         const listNode = getBinaryNodeChild(usyncNode, 'list')
         return getBinaryNodeChildren(listNode, 'user')
     }
 
-    // ─── Privacy ─────────────────────────────────────────────────────────────────
+    // ─── Privacy ──────────────────────────────────────────────────────────────
 
     const fetchPrivacySettings = async (force = false) => {
         if (!privacySettings || force) {
-            const { content } = await query({
-                tag: 'iq',
-                attrs: { xmlns: 'privacy', to: S_WHATSAPP_NET, type: 'get' },
-                content: [{ tag: 'privacy', attrs: {} }]
-            })
+            const { content } = await query({ tag: 'iq', attrs: { xmlns: 'privacy', to: S_WHATSAPP_NET, type: 'get' }, content: [{ tag: 'privacy', attrs: {} }] })
             privacySettings = 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: S_WHATSAPP_NET, type: 'set' },
-            content: [{ tag: 'privacy', attrs: {}, content: [{ tag: 'category', attrs: { name, value } }] }]
-        })
+        await query({ tag: 'iq', attrs: { xmlns: 'privacy', to: S_WHATSAPP_NET, type: 'set' }, content: [{ tag: 'privacy', attrs: {}, content: [{ tag: 'category', attrs: { name, value } }] }] })
     }
 
     const updateMessagesPrivacy = (value) => privacyQuery('messages', value)
@@ -136,21 +99,13 @@ export const makeChatsSocket = (config) => {
     const updateGroupsAddPrivacy = (value) => privacyQuery('groupadd', value)
 
     const updateDefaultDisappearingMode = async (duration) => {
-        await query({
-            tag: 'iq',
-            attrs: { xmlns: 'disappearing_mode', to: S_WHATSAPP_NET, type: 'set' },
-            content: [{ tag: 'disappearing_mode', attrs: { duration: duration.toString() } }]
-        })
+        await query({ tag: 'iq', attrs: { xmlns: 'disappearing_mode', to: S_WHATSAPP_NET, type: 'set' }, content: [{ tag: 'disappearing_mode', attrs: { duration: duration.toString() } }] })
     }
 
-    // ─── Queries ─────────────────────────────────────────────────────────────────
+    // ─── Queries ──────────────────────────────────────────────────────────────
 
     const getBotListV2 = async () => {
-        const resp = await query({
-            tag: 'iq',
-            attrs: { xmlns: 'bot', to: S_WHATSAPP_NET, type: 'get' },
-            content: [{ tag: 'bot', attrs: { v: '2' } }]
-        })
+        const resp = await query({ tag: 'iq', attrs: { xmlns: 'bot', to: S_WHATSAPP_NET, type: 'get' }, content: [{ tag: 'bot', attrs: { v: '2' } }] })
         const botNode = getBinaryNodeChild(resp, 'bot')
         const botList = []
         for (const section of getBinaryNodeChildren(botNode, 'section')) {
@@ -180,91 +135,84 @@ export const makeChatsSocket = (config) => {
     const onWhatsApp = async (...jids) => {
         const usyncQuery = new USyncQuery()
         let contactEnabled = false
-
-        for (const jid of jids) {
+        for (let jid of jids) {
             if (isLidUser(jid)) {
-                logger.warn('LIDs not supported with onWhatsApp')
-                continue
-            }
-            if (!contactEnabled) {
-                contactEnabled = true
-                usyncQuery.withContactProtocol().withLIDProtocol()
+                const pn = await signalRepository.lidMapping.getPNForLID(jid)
+                if (pn) {
+                    jid = pn
+                } else {
+                    if (!contactEnabled) { contactEnabled = true; usyncQuery.withContactProtocol().withLIDProtocol() }
+                    usyncQuery.withUser(new USyncUser().withId(jid))
+                    continue
+                }
             }
+            if (!contactEnabled) { contactEnabled = true; usyncQuery.withContactProtocol().withLIDProtocol() }
             const phone = `+${jid.replace('+', '').split('@')[0].split(':')[0]}`
             usyncQuery.withUser(new USyncUser().withPhone(phone))
         }
-
         if (usyncQuery.users.length === 0) return []
-
         const results = await sock.executeUSyncQuery(usyncQuery)
         if (!results) return []
-
         return Promise.all(
             results.list
-                .filter(a => a.contact === true)
+                .filter(a => a.contact === true && a.id && a.id !== 'undefined')
                 .map(async ({ id, lid }) => {
                     try {
                         const businessProfile = await getBusinessProfile(id)
                         const isBusiness = businessProfile && Object.keys(businessProfile).length > 0
                         if (isBusiness) {
                             const { wid, ...businessInfo } = businessProfile
-                            return { jid: id, exists: true, lid, status: 'business', businessInfo }
+                            return { jid: id, exists: true, lid: lid || id, status: 'business', businessInfo }
                         }
-                        return { jid: id, exists: true, lid, status: 'regular' }
+                        return { jid: id, exists: true, lid: lid || id, status: 'regular' }
                     } catch (error) {
-                        return { jid: id, exists: true, lid, status: 'error', error: error?.message }
+                        return { jid: id, exists: true, lid: lid || id, status: 'error', error: error?.message }
                     }
                 })
         )
     }
 
-    // ─── Profile ─────────────────────────────────────────────────────────────────
+    // ─── Profile ──────────────────────────────────────────────────────────────
 
-    const updateProfilePicture = async (jid, content) => {
+    /** update the profile picture for yourself or a group */
+    const updateProfilePicture = async (jid, content, dimensions) => {
         if (!jid) throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update')
-        let targetJid
-        if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) targetJid = jidNormalizedUser(jid)
-        const { img } = await generateProfilePicture(content)
-        await query({
-            tag: 'iq',
-            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:profile:picture', ...(targetJid ? { target: targetJid } : {}) },
-            content: [{ tag: 'picture', attrs: { type: 'image' }, content: img }]
-        })
+        const targetJid = jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id) ? jidNormalizedUser(jid) : undefined
+        const { img } = await generateProfilePicture(content, dimensions)
+        await query({ tag: 'iq', attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:profile:picture', ...(targetJid ? { target: targetJid } : {}) }, content: [{ tag: 'picture', attrs: { type: 'image' }, content: img }] })
     }
 
+    /** remove the profile picture for yourself or a group */
     const removeProfilePicture = async (jid) => {
         if (!jid) throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update')
-        let targetJid
-        if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) targetJid = jidNormalizedUser(jid)
-        await query({
-            tag: 'iq',
-            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:profile:picture', ...(targetJid ? { target: targetJid } : {}) }
-        })
+        const targetJid = jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id) ? jidNormalizedUser(jid) : undefined
+        await query({ tag: 'iq', attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'w:profile:picture', ...(targetJid ? { target: targetJid } : {}) } })
     }
 
+    /** update the profile status for yourself */
     const updateProfileStatus = async (status) => {
-        await query({
-            tag: 'iq',
-            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'status' },
-            content: [{ tag: 'status', attrs: {}, content: Buffer.from(status, 'utf-8') }]
-        })
+        await query({ tag: 'iq', attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'status' }, content: [{ tag: 'status', attrs: {}, content: Buffer.from(status, 'utf-8') }] })
     }
 
     const updateProfileName = (name) => chatModify({ pushNameSetting: name }, '')
 
     const profilePictureUrl = async (jid, type = 'preview', timeoutMs) => {
-        jid = jidNormalizedUser(jid)
-        const cacheKey = `${jid}:${type}`
+        const normalizedJid = jidNormalizedUser(jid)
+        const cacheKey = `${normalizedJid}:${type}`
         const cached = profilePictureUrlCache.get(cacheKey)
         if (typeof cached !== 'undefined') return cached || undefined
         const inFlight = inFlightProfilePictureUrl.get(cacheKey)
         if (inFlight) return inFlight
         const fetchPromise = (async () => {
-            const result = await query({
-                tag: 'iq',
-                attrs: { target: jid, to: S_WHATSAPP_NET, type: 'get', xmlns: 'w:profile:picture' },
-                content: [{ tag: 'picture', attrs: { type, query: 'url' } }]
-            }, timeoutMs)
+            const baseContent = [{ tag: 'picture', attrs: { type, query: 'url' } }]
+            const isUserJid = isPnUser(normalizedJid) || isLidUser(normalizedJid)
+            const me = authState.creds.me
+            const isSelf = me && (normalizedJid === jidNormalizedUser(me.id) || (me.lid && normalizedJid === jidNormalizedUser(me.lid)))
+            let content = baseContent
+            if (serverProps.profilePicPrivacyToken && isUserJid && !isSelf) {
+                content = await buildTcTokenFromJid({ authState, jid: normalizedJid, baseContent, getLIDForPN })
+            }
+            const result = await query({ tag: 'iq', attrs: { target: normalizedJid, to: S_WHATSAPP_NET, type: 'get', xmlns: 'w:profile:picture' }, content }, timeoutMs)
             const child = getBinaryNodeChild(result, 'picture')
             const url = child?.attrs?.url
             profilePictureUrlCache.set(cacheKey, url || null)
@@ -278,7 +226,7 @@ export const makeChatsSocket = (config) => {
         }
     }
 
-    // ─── Blocklist ────────────────────────────────────────────────────────────────
+    // ─── Blocklist ────────────────────────────────────────────────────────────
 
     const fetchBlocklist = async () => {
         const result = await query({ tag: 'iq', attrs: { xmlns: 'blocklist', to: S_WHATSAPP_NET, type: 'get' } })
@@ -287,21 +235,36 @@ export const makeChatsSocket = (config) => {
     }
 
     const updateBlockStatus = async (jid, action) => {
-        await query({
-            tag: 'iq',
-            attrs: { xmlns: 'blocklist', to: S_WHATSAPP_NET, type: 'set' },
-            content: [{ tag: 'item', attrs: { action, jid } }]
-        })
+        const normalizedJid = jidNormalizedUser(jid)
+        let lid
+        let pn_jid
+        if (isLidUser(normalizedJid) || isHostedLidUser(normalizedJid)) {
+            lid = normalizedJid
+            if (action === 'block') {
+                const pn = await signalRepository.lidMapping.getPNForLID(normalizedJid)
+                if (!pn) throw new Boom(`Unable to resolve PN JID for LID: ${jid}`, { statusCode: 400 })
+                pn_jid = jidNormalizedUser(pn)
+            }
+        } else if (isPnUser(normalizedJid) || isHostedPnUser(normalizedJid)) {
+            const mapped = await signalRepository.lidMapping.getLIDForPN(normalizedJid)
+            if (!mapped) throw new Boom(`Unable to resolve LID for PN JID: ${jid}`, { statusCode: 400 })
+            lid = mapped
+            if (action === 'block') pn_jid = jidNormalizedUser(normalizedJid)
+        } else {
+            throw new Boom(`Invalid jid: ${jid}`, { statusCode: 400 })
+        }
+        const itemAttrs = { action, jid: lid }
+        if (action === 'block') {
+            if (!pn_jid) throw new Boom(`pn_jid required for block: ${jid}`, { statusCode: 400 })
+            itemAttrs.pn_jid = pn_jid
+        }
+        await query({ tag: 'iq', attrs: { xmlns: 'blocklist', to: S_WHATSAPP_NET, type: 'set' }, content: [{ tag: 'item', attrs: itemAttrs }] })
     }
 
-    // ─── Business ────────────────────────────────────────────────────────────────
+    // ─── Business ─────────────────────────────────────────────────────────────
 
     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 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 = getBinaryNodeChild(results, 'business_profile')
         const profiles = getBinaryNodeChild(profileNode, 'profile')
         if (profiles) {
@@ -325,15 +288,11 @@ export const makeChatsSocket = (config) => {
         }
     }
 
-    // ─── App state ────────────────────────────────────────────────────────────────
+    // ─── App state ────────────────────────────────────────────────────────────
 
     const cleanDirtyBits = async (type, fromTimestamp) => {
         logger.info({ fromTimestamp }, 'clean dirty bits ' + type)
-        await sendNode({
-            tag: 'iq',
-            attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'urn:xmpp:whatsapp:dirty', id: generateMessageTag() },
-            content: [{ tag: 'clean', attrs: { type, ...(fromTimestamp ? { timestamp: fromTimestamp.toString() } : null) } }]
-        })
+        await sendNode({ tag: 'iq', attrs: { to: 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) => ({
@@ -347,7 +306,6 @@ export const makeChatsSocket = (config) => {
         const collectionsToSync = collections.filter(name => (appStateResyncCooldown.get(name) || 0) <= now)
         if (!collectionsToSync.length) return
 
-        // Per-invocation cache to avoid redundant key fetches within a single resync
         const appStateSyncKeyCache = new Map()
         const getCachedAppStateSyncKey = async (keyId) => {
             if (appStateSyncKeyCache.has(keyId)) return appStateSyncKeyCache.get(keyId) ?? undefined
@@ -378,24 +336,15 @@ export const makeChatsSocket = (config) => {
                         state = newLTHashState()
                     }
                     states[name] = state
-
                     const shouldForceSnapshot = forceSnapshotCollections.has(name)
                     if (shouldForceSnapshot) forceSnapshotCollections.delete(name)
-
                     logger.info(`resyncing ${name} from v${state.version}${shouldForceSnapshot ? ' (forcing snapshot)' : ''}`)
-                    nodes.push({
-                        tag: 'collection',
-                        attrs: { name, version: state.version.toString(), return_snapshot: (shouldForceSnapshot || !state.version).toString() }
-                    })
+                    nodes.push({ tag: 'collection', attrs: { name, version: state.version.toString(), return_snapshot: (shouldForceSnapshot || !state.version).toString() } })
                 }
 
-                const result = await query({
-                    tag: 'iq',
-                    attrs: { to: S_WHATSAPP_NET, xmlns: 'w:sync:app:state', type: 'set' },
-                    content: [{ tag: 'sync', attrs: {}, content: nodes }]
-                })
-
+                const result = await query({ tag: 'iq', attrs: { to: S_WHATSAPP_NET, xmlns: 'w:sync:app:state', type: 'set' }, content: [{ tag: 'sync', attrs: {}, content: nodes }] })
                 const decoded = await extractSyncdPatches(result, config?.options)
+
                 for (const key in decoded) {
                     const name = key
                     const { patches, hasMorePatches, snapshot } = decoded[name]
@@ -421,25 +370,20 @@ export const makeChatsSocket = (config) => {
                         }
                     } catch (error) {
                         attemptsMap[name] = (attemptsMap[name] || 0) + 1
-                        const isMissingKey = error.output?.statusCode === 404
-                        const isIrrecoverable = attemptsMap[name] >= MAX_SYNC_ATTEMPTS || error.name === 'TypeError'
-
-                        logger.info({ name, error: error.stack, attempt: attemptsMap[name] }, `failed to sync ${name} from v${states[name].version}`)
-                        if (!isMissingKey) {
-                            await authState.keys.set({ 'app-state-sync-version': { [name]: null } })
-                        }
-
-                        if (isMissingKey) appStateResyncCooldown.set(name, Date.now() + APP_STATE_RESYNC_COOLDOWN_MS)
-
-                        if (isMissingKey && attemptsMap[name] >= MAX_SYNC_ATTEMPTS) {
-                            logger.warn({ name }, `${name} blocked on missing key, parking until key arrives`)
+                        const logData = { name, attempt: attemptsMap[name], version: states[name].version, statusCode: error.output?.statusCode, errorType: error.name, error: error.stack }
+                        if (isMissingKeyError(error) && attemptsMap[name] >= MAX_SYNC_ATTEMPTS) {
+                            logger.warn(logData, `${name} blocked on missing key from v${states[name].version}, parking after ${attemptsMap[name]} attempts`)
                             blockedCollections.add(name)
                             collectionsToHandle.delete(name)
-                        } else if (isMissingKey) {
+                            appStateResyncCooldown.set(name, Date.now() + APP_STATE_RESYNC_COOLDOWN_MS)
+                        } else if (isMissingKeyError(error)) {
+                            logger.info(logData, `${name} blocked on missing key from v${states[name].version}, retrying with snapshot`)
                             forceSnapshotCollections.add(name)
-                        } else if (isIrrecoverable) {
+                        } else if (isAppStateSyncIrrecoverable(error, attemptsMap[name])) {
+                            logger.warn(logData, `failed to sync ${name} from v${states[name].version}, giving up`)
                             collectionsToHandle.delete(name)
                         } else {
+                            logger.info(logData, `failed to sync ${name} from v${states[name].version}, forcing snapshot retry`)
                             forceSnapshotCollections.add(name)
                         }
                     }
@@ -451,33 +395,33 @@ export const makeChatsSocket = (config) => {
         for (const key in globalMutationMap) onMutation(globalMutationMap[key])
     })
 
-    // ─── Presence ─────────────────────────────────────────────────────────────────
+    // ─── Presence ─────────────────────────────────────────────────────────────
 
     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' })
+        const isAvailableType = type === 'available'
+        if (isAvailableType || type === 'unavailable') {
+            if (!me.name) { logger.warn('no name present, ignoring presence update request...'); return }
+            ev.emit('connection.update', { isOnline: isAvailableType })
+            if (isAvailableType) void sendUnifiedSession()
             await sendNode({ tag: 'presence', attrs: { name: me.name.replace(/@/g, ''), type } })
         } else {
             const { server } = jidDecode(toJid)
             const isLid = server === 'lid'
-            await sendNode({
-                tag: 'chatstate',
-                attrs: { from: isLid ? me.lid : me.id, to: toJid },
-                content: [{ tag: type === 'recording' ? 'composing' : type, attrs: type === 'recording' ? { media: 'audio' } : {} }]
-            })
+            await sendNode({ tag: 'chatstate', attrs: { from: isLid ? me.lid : me.id, to: toJid }, content: [{ tag: type === 'recording' ? 'composing' : type, attrs: type === 'recording' ? { media: 'audio' } : {} }] })
         }
     }
 
-    const presenceSubscribe = (toJid, tcToken) => sendNode({
-        tag: 'presence',
-        attrs: { to: toJid, id: generateMessageTag(), type: 'subscribe' },
-        content: tcToken ? [{ tag: 'tctoken', attrs: {}, content: tcToken }] : undefined
-    })
+    /**
+     * @param toJid the jid to subscribe to
+     * @param tcToken token for subscription, use if present
+     */
+    const presenceSubscribe = async (toJid) => {
+        const normalizedToJid = jidNormalizedUser(toJid)
+        const isUserJid = isPnUser(normalizedToJid) || isLidUser(normalizedToJid)
+        const tcTokenContent = isUserJid ? await buildTcTokenFromJid({ authState, jid: normalizedToJid, getLIDForPN }) : undefined
+        return sendNode({ tag: 'presence', attrs: { to: toJid, id: generateMessageTag(), type: 'subscribe' }, content: tcTokenContent })
+    }
 
     const handlePresenceUpdate = ({ tag, attrs, content }) => {
         let presence
@@ -485,10 +429,7 @@ export const makeChatsSocket = (config) => {
         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
-            }
+            presence = { lastKnownPresence: attrs.type === 'unavailable' ? 'unavailable' : 'available', lastSeen: attrs.last && attrs.last !== 'deny' ? +attrs.last : undefined, groupOnlineCount: attrs.count ? +attrs.count : undefined }
         } else if (Array.isArray(content)) {
             const [firstChild] = content
             let type = firstChild.tag
@@ -501,7 +442,7 @@ export const makeChatsSocket = (config) => {
         if (presence) ev.emit('presence.update', { id: jid, presences: { [participant]: presence } })
     }
 
-    // ─── App patch ────────────────────────────────────────────────────────────────
+    // ─── App patch ────────────────────────────────────────────────────────────
 
     const appPatch = async (patchCreate) => {
         const name = patchCreate.type
@@ -519,17 +460,7 @@ export const makeChatsSocket = (config) => {
                 initial = currentSyncVersion ? ensureLTHashStateVersion(currentSyncVersion) : newLTHashState()
                 encodeResult = await encodeSyncdPatch(patchCreate, myAppStateKeyId, initial, getAppStateSyncKey)
                 const { patch, state } = encodeResult
-                await query({
-                    tag: 'iq',
-                    attrs: { to: 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: proto.SyncdPatch.encode(patch).finish() }]
-                        }]
-                    }]
-                })
+                await query({ tag: 'iq', attrs: { to: 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: proto.SyncdPatch.encode(patch).finish() }] }] }] })
                 await authState.keys.set({ 'app-state-sync-version': { [name]: state } })
             }, authState?.creds?.me?.id || 'app-patch')
         })
@@ -541,14 +472,11 @@ export const makeChatsSocket = (config) => {
         }
     }
 
-    // ─── Props ────────────────────────────────────────────────────────────────────
+    // ─── Props ────────────────────────────────────────────────────────────────
 
+    /** fetch AB props */
     const fetchProps = async () => {
-        const resultNode = await query({
-            tag: 'iq',
-            attrs: { to: S_WHATSAPP_NET, xmlns: 'w', type: 'get' },
-            content: [{ tag: 'props', attrs: { protocol: '2', hash: authState?.creds?.lastPropHash || '' } }]
-        })
+        const resultNode = await query({ tag: 'iq', attrs: { to: S_WHATSAPP_NET, xmlns: 'abt', type: 'get' }, content: [{ tag: 'props', attrs: { protocol: '1', ...(authState?.creds?.lastPropHash ? { hash: authState.creds.lastPropHash } : {}) } }] })
         const propsNode = getBinaryNodeChild(resultNode, 'props')
         let props = {}
         if (propsNode) {
@@ -558,41 +486,63 @@ export const makeChatsSocket = (config) => {
             }
             props = reduceBinaryNodeToDictionary(propsNode, 'prop')
         }
-        logger.debug('fetched props')
+        const privacyTokenProp = props['10518'] ?? props['privacy_token_sending_on_all_1_on_1_messages']
+        if (privacyTokenProp !== undefined) serverProps.privacyTokenOn1to1 = privacyTokenProp === 'true' || privacyTokenProp === '1'
+        const profilePicProp = props['9666'] ?? props['profile_scraping_privacy_token_in_photo_iq']
+        if (profilePicProp !== undefined) serverProps.profilePicPrivacyToken = profilePicProp === 'true' || profilePicProp === '1'
+        const lidIssueProp = props['14303'] ?? props['lid_trusted_token_issue_to_lid']
+        if (lidIssueProp !== undefined) serverProps.lidTrustedTokenIssueToLid = lidIssueProp === 'true' || lidIssueProp === '1'
+        logger.debug({ serverProps }, 'fetched props')
         return props
     }
 
-    // ─── Chat modification helpers ────────────────────────────────────────────────
+    // ─── Chat modification helpers ────────────────────────────────────────────
 
+    /**
+     * 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) => appPatch(chatModificationToAppPatch(mod, jid))
+    /** Enable/Disable link preview privacy, not related to baileys link preview generation */
     const updateDisableLinkPreviewsPrivacy = (isPreviewsDisabled) => chatModify({ disableLinkPreviews: { isPreviewsDisabled } }, '')
+    /** Star or Unstar a message */
     const star = (jid, messages, star) => chatModify({ star: { messages, star } }, jid)
+    /** Add or Edit Contact */
     const addOrEditContact = (jid, contact) => chatModify({ contact }, jid)
+    /** Remove Contact */
     const removeContact = (jid) => chatModify({ contact: null }, jid)
+    /** Adds label */
     const addLabel = (jid, labels) => chatModify({ addLabel: { ...labels } }, jid)
+    /** Adds label for the chats */
     const addChatLabel = (jid, labelId) => chatModify({ addChatLabel: { labelId } }, jid)
+    /** Removes label for the chat */
     const removeChatLabel = (jid, labelId) => chatModify({ removeChatLabel: { labelId } }, jid)
+    /** Adds label for the message */
     const addMessageLabel = (jid, messageId, labelId) => chatModify({ addMessageLabel: { messageId, labelId } }, jid)
+    /** Removes label for the message */
     const removeMessageLabel = (jid, messageId, labelId) => chatModify({ removeMessageLabel: { messageId, labelId } }, jid)
+    /** Add or Edit Quick Reply */
     const addOrEditQuickReply = (quickReply) => chatModify({ quickReply }, '')
+    /** Remove Quick Reply */
     const removeQuickReply = (timestamp) => chatModify({ quickReply: { timestamp, deleted: true } }, '')
 
-    // ─── Call link ────────────────────────────────────────────────────────────────
+    // ─── Call link ────────────────────────────────────────────────────────────
 
     const createCallLink = async (type, event, timeoutMs) => {
-        const result = await query({
-            tag: 'call',
-            attrs: { id: generateMessageTag(), to: '@call' },
-            content: [{ tag: 'link_create', attrs: { media: type }, content: event ? [{ tag: 'event', attrs: { start_time: String(event.startTime) } }] : undefined }]
-        }, timeoutMs)
+        const result = await query({ tag: 'call', attrs: { id: generateMessageTag(), to: '@call' }, content: [{ tag: 'link_create', attrs: { media: type }, content: event ? [{ tag: 'event', attrs: { start_time: String(event.startTime) } }] : undefined }] }, timeoutMs)
         return getBinaryNodeChild(result, 'link_create')?.attrs?.token
     }
 
-    // ─── Init ─────────────────────────────────────────────────────────────────────
+    // ─── Init ─────────────────────────────────────────────────────────────────
 
+    /**
+     * queries need to be fired on connection open
+     * help ensure parity with WA Web
+     */
     const executeInitQueries = () => Promise.all([fetchProps(), fetchBlocklist(), fetchPrivacySettings()])
 
-    // ─── Message upsert ───────────────────────────────────────────────────────────
+    // ─── Message upsert ───────────────────────────────────────────────────────
 
     const upsertMessage = ev.createBufferedFunction(async (msg, type) => {
         ev.emit('messages.upsert', { messages: [msg], type })
@@ -600,35 +550,27 @@ export const makeChatsSocket = (config) => {
         if (msg.pushName) {
             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 }])
-            }
-            if (msg.key.fromMe && msg.pushName && authState.creds.me?.name !== msg.pushName) {
-                ev.emit('creds.update', { me: { ...authState.creds.me, name: msg.pushName } })
-            }
+            if (!msg.key.fromMe) ev.emit('contacts.update', [{ id: jid, notify: msg.pushName, verifiedName: msg.verifiedBizName }])
+            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 = getHistoryMsg(msg.message)
         const shouldProcessHistoryMsg = historyMsg
-            ? shouldSyncHistoryMessage(historyMsg) && PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
+            ? !!historyMsg.mediaKey?.length && shouldSyncHistoryMessage(historyMsg) && PROCESSABLE_HISTORY_TYPES.includes(historyMsg.syncType)
             : false
 
-        // History sync progress tracking
         if (historyMsg && shouldProcessHistoryMsg) {
             const syncType = historyMsg.syncType
-
             if (syncType === proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP && !historySyncStatus.initialBootstrapComplete) {
                 historySyncStatus.initialBootstrapComplete = true
                 ev.emit('messaging-history.status', { syncType, status: 'complete', explicit: true })
             }
-
             if (syncType === proto.HistorySync.HistorySyncType.RECENT && historyMsg.progress === 100 && !historySyncStatus.recentSyncComplete) {
                 historySyncStatus.recentSyncComplete = true
                 clearTimeout(historySyncPausedTimeout)
                 historySyncPausedTimeout = undefined
                 ev.emit('messaging-history.status', { syncType, status: 'complete', explicit: true })
             }
-
             if (syncType === proto.HistorySync.HistorySyncType.RECENT && !historySyncStatus.recentSyncComplete) {
                 clearTimeout(historySyncPausedTimeout)
                 historySyncPausedTimeout = setTimeout(() => {
@@ -641,12 +583,8 @@ export const makeChatsSocket = (config) => {
             }
         }
 
-        // SyncState machine
         if (historyMsg && syncState === SyncState.AwaitingInitialSync) {
-            if (awaitingSyncTimeout) {
-                clearTimeout(awaitingSyncTimeout)
-                awaitingSyncTimeout = undefined
-            }
+            if (awaitingSyncTimeout) { clearTimeout(awaitingSyncTimeout); awaitingSyncTimeout = undefined }
             if (shouldProcessHistoryMsg) {
                 syncState = SyncState.Syncing
                 logger.info('Transitioned to Syncing state')
@@ -672,17 +610,7 @@ export const makeChatsSocket = (config) => {
 
         await Promise.all([
             (async () => { if (shouldProcessHistoryMsg) await doAppStateSync() })(),
-            processMessage(msg, {
-                signalRepository,
-                shouldProcessHistoryMsg,
-                placeholderResendCache,
-                ev,
-                creds: authState.creds,
-                keyStore: authState.keys,
-                logger,
-                options: config.options,
-                getMessage
-            })
+            processMessage(msg, { signalRepository, shouldProcessHistoryMsg, placeholderResendCache, ev, creds: authState.creds, keyStore: authState.keys, logger, options: config.options, getMessage })
         ])
 
         if (msg.message?.protocolMessage?.appStateSyncKeyShare) {
@@ -698,7 +626,7 @@ export const makeChatsSocket = (config) => {
         }
     })
 
-    // ─── WS handlers ──────────────────────────────────────────────────────────────
+    // ─── WS handlers ──────────────────────────────────────────────────────────
 
     ws.on('CB:presence', handlePresenceUpdate)
     ws.on('CB:chatstate', handlePresenceUpdate)
@@ -723,7 +651,7 @@ export const makeChatsSocket = (config) => {
         }
     })
 
-    // ─── Event listeners ──────────────────────────────────────────────────────────
+    // ─── Event listeners ──────────────────────────────────────────────────────
 
     ev.on('connection.update', ({ connection, receivedPendingNotifications }) => {
         if (connection === 'close') {
@@ -748,9 +676,7 @@ export const makeChatsSocket = (config) => {
         logger.info('Connection is now AwaitingInitialSync, buffering events')
         ev.buffer()
 
-        const willSyncHistory = shouldSyncHistoryMessage(proto.Message.HistorySyncNotification.create({
-            syncType: 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.')
@@ -759,7 +685,6 @@ export const makeChatsSocket = (config) => {
             return
         }
 
-        // On reconnection the server won't push history sync again — skip the wait
         if (authState.creds.accountSyncCounter > 0) {
             logger.info('Reconnection with existing sync data, skipping history sync wait. Transitioning to Online.')
             syncState = SyncState.Online
@@ -780,13 +705,9 @@ export const makeChatsSocket = (config) => {
         }, 20_000)
     })
 
-    // Re-sync collections that were parked due to a missing app state key
     ev.on('creds.update', ({ myAppStateKeyId }) => {
         if (!myAppStateKeyId || blockedCollections.size === 0) return
-        if (syncState === SyncState.Syncing) {
-            blockedCollections.clear()
-            return
-        }
+        if (syncState === SyncState.Syncing) { blockedCollections.clear(); return }
         const collections = [...blockedCollections]
         blockedCollections.clear()
         logger.info({ collections }, 'app state sync key arrived, re-syncing blocked collections')
@@ -801,10 +722,18 @@ export const makeChatsSocket = (config) => {
         }
     })
 
-    // ─── Return ───────────────────────────────────────────────────────────────────
+    registerSocketEndHandler(() => {
+        if (awaitingSyncTimeout) { clearTimeout(awaitingSyncTimeout); awaitingSyncTimeout = undefined }
+        if (!config.placeholderResendCache && placeholderResendCache.close) placeholderResendCache.close()
+        syncState = SyncState.Connecting
+        privacySettings = undefined
+    })
+
+    // ─── Return ───────────────────────────────────────────────────────────────
 
     return {
         ...sock,
+        serverProps,
         createCallLink,
         getBotListV2,
         processingMutex,
@@ -842,9 +771,9 @@ export const makeChatsSocket = (config) => {
         cleanDirtyBits,
         addOrEditContact,
         removeContact,
+        placeholderResendCache,
         addLabel,
         onWhatsApp,
-        checkStatusWA,
         addChatLabel,
         removeChatLabel,
         addMessageLabel,
@@ -854,6 +783,7 @@ export const makeChatsSocket = (config) => {
         removeQuickReply
     }
 }
+
 export const checkStatusWA = async (phoneNumber) => {
     if (!phoneNumber) throw new Error('Please provide a phone number')
 
@@ -872,40 +802,29 @@ export const checkStatusWA = async (phoneNumber) => {
 
     const state = {
         creds: initAuthCreds(),
-        keys: {
-            get: async () => ({}),
-            set: async () => { },
-            transaction: async (fn) => fn(),
-        }
+        keys: { get: async () => ({}), set: async () => { }, transaction: async (fn) => fn() }
     }
 
-    const build = (status, isBanned, isNeedOfficialWa, banInfo = null) => ({
-        number: formattedNumber, status, isBanned, isNeedOfficialWa, banInfo
-    })
+    const build = (status, isBanned, isNeedOfficialWa, banInfo = null) => ({ number: formattedNumber, status, isBanned, isNeedOfficialWa, banInfo })
 
     try {
-        await mobileRegisterExists({
-            ...state.creds,
-            phoneNumberCountryCode: countryCode,
-            phoneNumberNationalNumber: nationalNumber,
-        })
+        await mobileRegisterExists({ ...state.creds, phoneNumberCountryCode: countryCode, phoneNumberNationalNumber: nationalNumber })
         return build('active', false, false)
     } catch (err) {
         if (err?.appeal_token) {
             const banDetails = await getBanDetails(err.appeal_token)
             const appealStatus = banDetails?.status || null
             const banType = appealStatus === 'BANNED' ? 'permanent' : 'temporary'
-
             return build('banned', true, false, {
                 banType,
                 violationType: err.violation_type || null,
                 violationReason: err.violation_type ? `Type ${err.violation_type}` : 'Unknown',
-                canAppeal: banType !== 'permanent', // ✅ temporary = can appeal, permanent = cannot
+                canAppeal: banType !== 'permanent',
                 appealToken: err.appeal_token,
                 banTime: banDetails?.ban_time || null,
                 banDate: banDetails?.ban_time ? new Date(banDetails.ban_time * 1000).toISOString() : null,
                 appealStatus,
-                appealCreatedAt: banDetails?.appeal_creation_time ? new Date(banDetails.appeal_creation_time * 1000).toISOString() : null,
+                appealCreatedAt: banDetails?.appeal_creation_time ? new Date(banDetails.appeal_creation_time * 1000).toISOString() : null
             })
         }
         if (err?.custom_block_screen) return build('blocked', false, true)
@@ -913,4 +832,4 @@ export const checkStatusWA = async (phoneNumber) => {
         if (err?.reason === 'temporarily_unavailable') return build('rate_limited', false, false)
         return build('error', false, false)
     }
-}
+}