@zervonex/baileys 3.0.3 → 3.0.5

package/lib/Utils/use-multi-file-auth-state.js

@@ -5,74 +5,105 @@ import { proto } from '../../WAProto/index.js'
 import { initAuthCreds } from './auth-utils.js'
 import { BufferJSON } from './generics.js'
 import { PROTOCOL_ADAPTERS } from '../WABinary/index.js'
+import logger from './logger.js'
 
-const CURRENT_VERSION = 1
 const DEFAULT_PREKEY_RETENTION = 150
 const DEFAULT_CLEANUP_THRESHOLD = 50
 const CLEANUP_INTERVAL_MS = 10 * 60 * 1000
 
-const bootstrapCreds = (raw) => {
-    const c = raw ?? initAuthCreds()
-    if (!c.__version || c.__version < CURRENT_VERSION) c.__version = CURRENT_VERSION
-    return c
-}
+// ── Shared helpers ────────────────────────────────────────────────────────────
+
+const bootstrapCreds = raw => raw ?? initAuthCreds()
 
 const patchAppStateKey = (type, v) =>
     type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
 
-// ── File-based ────────────────────────────────────────────────────────────────
+const ser = v => v == null ? null : JSON.parse(JSON.stringify(v, BufferJSON.replacer))
+
+const deser = raw => {
+    if (raw == null) return null
+    let p = typeof raw === 'string'
+        ? (() => { try { return JSON.parse(raw) } catch (e) { logger.warn({ err: e.message }, '[Auth] failed to parse stored value — treating as missing'); return null } })()
+        : raw
+    // unwrap adapter double-wrapping e.g. { value: { value: actual } }
+    while (p && typeof p === 'object' && !Array.isArray(p) && Object.keys(p).length === 1 && 'value' in p) p = p.value
+    if (p == null) return null
+    if (typeof p === 'object' && '__checksum' in p && 'data' in p) p = p.data
+    return JSON.parse(JSON.stringify(p), BufferJSON.reviver)
+}
 
-export const useMultiFileAuthState = async (folder, options = {}) => {
-    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger } = options
+// ── Adapter resolution ────────────────────────────────────────────────────────
 
-    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-')
-    const filePath = (file) => join(folder, fixFileName(file))
-    const tmpPath = (file) => filePath(file) + '.tmp'
+const COLLECTION_KEY = { '@keyv/mongo': 'collection', '@keyv/postgres': 'table', '@keyv/mysql': 'table', '@keyv/sqlite': 'table' }
+const _adapterCache = new Map()
+export const clearAdapterCache = () => _adapterCache.clear()
 
-    const folderInfo = await stat(folder).catch(() => null)
-    if (folderInfo) {
-        if (!folderInfo.isDirectory()) throw new Error(`Path exists but is not a directory: ${folder}`)
-    } else {
-        await mkdir(folder, { recursive: true })
+const resolveAdapter = async (conn, col) => {
+    const ck = col ? `${conn}::${col}` : conn
+    if (_adapterCache.has(ck)) return _adapterCache.get(ck)
+    let protocol
+    try { protocol = new URL(conn).protocol } catch { throw new Error(`[Auth] Invalid connection string: "${conn}"`) }
+    const pkg = PROTOCOL_ADAPTERS[protocol]
+    if (!pkg) throw new Error(`[Auth] Unsupported protocol "${protocol}" — supported: redis, mongodb, postgresql, mysql, sqlite`)
+    let mod
+    try { mod = await import(pkg) } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') throw new Error(`[Auth] "${pkg}" required — npm i ${pkg}`)
+        throw e
     }
+    const Adapter = mod.default ?? mod[Object.keys(mod)[0]]
+    const optKey = COLLECTION_KEY[pkg]
+    const adapter = col && optKey ? new Adapter({ url: conn, uri: conn, [optKey]: col }) : new Adapter(conn)
+    adapter.setMaxListeners?.(0)
+    _adapterCache.set(ck, adapter)
+    return adapter
+}
 
-    const writeData = async (data, file) => {
-        const fp = filePath(file)
-        const tp = tmpPath(file)
-        const payload = JSON.stringify(data, BufferJSON.replacer)
-        await writeFile(tp, payload)
-        try {
-            await rename(tp, fp)
-        } catch {
-            await writeFile(fp, payload)
-            await unlink(tp).catch(() => { })
-        }
+const resolveStore = async (backend, col) => {
+    if (backend == null) return null
+    if (typeof backend === 'string') return resolveAdapter(backend, col)
+    if (backend instanceof Keyv) return backend.opts?.store ?? backend.store ?? null
+    if (backend != null && typeof backend === 'object' && ['get', 'set', 'delete', 'clear'].every(m => typeof backend[m] === 'function')) return backend
+    throw new Error('[Auth] backend must be a connection string, Keyv instance, or KeyvStoreAdapter')
+}
+
+// ── File-based auth state ─────────────────────────────────────────────────────
+
+export const useMultiFileAuthState = async (folder, opts = {}) => {
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD } = opts
+    const fix = f => f?.replace(/\//g, '__')?.replace(/:/g, '-')
+    const fp = f => join(folder, fix(f))
+
+    const info = await stat(folder).catch(() => null)
+    if (info) { if (!info.isDirectory()) throw new Error(`Not a directory: ${folder}`) }
+    else await mkdir(folder, { recursive: true })
+
+    // atomic write: tmp → rename, fallback to direct write
+    const write = async (data, file) => {
+        const [p, t, payload] = [fp(file), fp(file) + '.tmp', JSON.stringify(data, BufferJSON.replacer)]
+        await writeFile(t, payload)
+        try { await rename(t, p) } catch { await writeFile(p, payload); await unlink(t).catch(() => { }) }
     }
 
-    const readData = async (file) => {
-        const raw = await readFile(filePath(file), { encoding: 'utf-8' }).catch(() => null)
+    const read = async file => {
+        const raw = await readFile(fp(file), 'utf-8').catch(() => null)
         if (!raw) return null
         try {
-            const parsed = JSON.parse(raw, BufferJSON.reviver)
-            if (parsed && typeof parsed === 'object' && '__checksum' in parsed && 'data' in parsed) return parsed.data
-            return parsed
-        } catch (err) {
-            logger?.warn({ file, err: err.message }, 'failed to read auth file — reinitializing')
-            await unlink(filePath(file)).catch(() => { })
+            const p = JSON.parse(raw, BufferJSON.reviver)
+            return p && typeof p === 'object' && '__checksum' in p && 'data' in p ? p.data : p
+        } catch (e) {
+            logger.warn({ err: e.message, file }, 'auth file corrupt — reinitializing')
+            await unlink(fp(file)).catch(() => { })
             return null
         }
     }
 
-    const removeData = (file) => unlink(filePath(file)).catch(() => { })
+    const remove = f => unlink(fp(f)).catch(() => { })
 
-    let creds = bootstrapCreds(await readData('creds.json'))
-    let cleanupRunning = false
-    let lastCleanupAt = 0
-    let lastCleanedPreKeyId = creds.nextPreKeyId
+    let creds = bootstrapCreds(await read('creds.json'))
+    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedId = creds.nextPreKeyId
 
     const cleanOldPreKeys = async () => {
-        const now = Date.now()
-        if (cleanupRunning || now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        if (cleanupRunning || Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return
         cleanupRunning = true
         try {
             const minId = creds.nextPreKeyId - preKeyRetention
@@ -81,222 +112,129 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
                 .map(f => f.match(/^pre-key-(\d+)\.json(\.tmp)?$/))
                 .filter(m => m && parseInt(m[1], 10) < minId)
                 .map(m => join(folder, m[0]))
-            if (!targets.length) return
-            await Promise.all(targets.map(f => unlink(f).catch(() => { })))
-            lastCleanupAt = Date.now()
-            lastCleanedPreKeyId = creds.nextPreKeyId
-        } catch (err) {
-            logger?.warn({ err }, 'prekey cleanup failed')
-        } finally {
-            cleanupRunning = false
-        }
+            if (targets.length) await Promise.all(targets.map(f => unlink(f).catch(() => { })))
+            lastCleanupAt = Date.now(); lastCleanedId = creds.nextPreKeyId
+        } catch (e) {
+            logger.warn({ err: e.message }, 'prekey cleanup failed')
+        } finally { cleanupRunning = false }
     }
 
     cleanOldPreKeys().catch(() => { })
 
-    const getStats = async () => {
-        const files = await readdir(folder).catch(() => [])
-        const preKeyFiles = files.filter(f => /^pre-key-\d+\.json$/.test(f))
-        return {
-            totalFiles: files.length,
-            preKeyCount: preKeyFiles.length,
-            nextPreKeyId: creds.nextPreKeyId,
-            lastCleanupAt: lastCleanupAt ? new Date(lastCleanupAt).toISOString() : null,
-        }
-    }
-
     return {
         state: {
             creds,
             keys: {
                 get: async (type, ids) => {
                     const data = {}
-                    await Promise.all(ids.map(async id => {
-                        let value = await readData(`${type}-${id}.json`)
-                        if (type === 'app-state-sync-key' && value) value = proto.Message.AppStateSyncKeyData.fromObject(value)
-                        data[id] = value
-                    }))
+                    await Promise.all(ids.map(async id => { const v = await read(`${type}-${id}.json`); data[id] = patchAppStateKey(type, v) }))
                     return data
                 },
-                set: async (data) => {
+                set: async data => {
                     const tasks = []
-                    for (const category in data) {
-                        for (const id in data[category]) {
-                            const value = data[category][id]
-                            tasks.push(value ? writeData(value, `${category}-${id}.json`) : removeData(`${category}-${id}.json`))
-                        }
-                    }
+                    for (const cat in data)
+                        for (const id in data[cat]) { const v = data[cat][id]; tasks.push(v ? write(v, `${cat}-${id}.json`) : remove(`${cat}-${id}.json`)) }
                     await Promise.all(tasks)
-                },
-            },
+                }
+            }
         },
         saveCreds: async () => {
-            if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
-            return writeData(creds, 'creds.json')
+            if (creds.nextPreKeyId - lastCleanedId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
+            return write(creds, 'creds.json')
         },
-        getStats,
-    }
-}
-
-// ── Keyv-backed ───────────────────────────────────────────────────────────────
-
-const ser = (v) => v == null ? null : JSON.parse(JSON.stringify(v, BufferJSON.replacer))
-
-const unwrapNestedValue = (obj) => {
-    let cur = obj
-    while (cur && typeof cur === 'object' && !Array.isArray(cur) && Object.keys(cur).length === 1 && 'value' in cur) cur = cur.value
-    return cur
-}
-
-const deser = (raw, logger) => {
-    if (raw == null) return null
-    let parsed
-    if (typeof raw === 'string') {
-        try { parsed = JSON.parse(raw) } catch (err) {
-            logger?.warn?.({ err: err.message }, '[Auth] failed to parse stored value — treating as missing')
-            return null
+        getStats: async () => {
+            const files = await readdir(folder).catch(() => [])
+            return { totalFiles: files.length, preKeyCount: files.filter(f => /^pre-key-\d+\.json$/.test(f)).length, nextPreKeyId: creds.nextPreKeyId, lastCleanupAt: lastCleanupAt ? new Date(lastCleanupAt).toISOString() : null }
         }
-    } else {
-        parsed = raw
     }
-    parsed = unwrapNestedValue(parsed)
-    if (parsed == null) return null
-    if (typeof parsed === 'object' && '__checksum' in parsed && 'data' in parsed) parsed = parsed.data
-    return JSON.parse(JSON.stringify(parsed), BufferJSON.reviver)
 }
 
-const COLLECTION_OPTION_KEY = {
-    '@keyv/mongo': 'collection',
-    '@keyv/postgres': 'table',
-    '@keyv/mysql': 'table',
-    '@keyv/sqlite': 'table',
-}
-
-const _adapterCache = new Map()
-export const clearAdapterCache = () => _adapterCache.clear()
-
-const resolveAdapter = async (connectionString, collectionName) => {
-    const cacheKey = collectionName ? `${connectionString}::${collectionName}` : connectionString
-    if (_adapterCache.has(cacheKey)) return _adapterCache.get(cacheKey)
-
-    let protocol
-    try { protocol = new URL(connectionString).protocol } catch { throw new Error(`[Auth] Invalid connection string: "${connectionString}"`) }
-
-    const pkg = PROTOCOL_ADAPTERS[protocol]
-    if (!pkg) throw new Error(`[Auth] Unsupported protocol "${protocol}" — supported: redis, mongodb, postgresql, mysql, sqlite, etcd, memcache. Pass a pre-built KeyvStoreAdapter instance for anything else.`)
-
-    let mod
-    try { mod = await import(pkg) } catch (e) {
-        if (e.code === 'ERR_MODULE_NOT_FOUND') throw new Error(`[Auth] "${pkg}" is required for this backend — install it: npm i ${pkg}`)
-        throw e
-    }
-
-    const Adapter = mod.default ?? mod[Object.keys(mod)[0]]
-    const optionKey = COLLECTION_OPTION_KEY[pkg]
-    const adapter = (collectionName && optionKey)
-        ? new Adapter({ url: connectionString, uri: connectionString, [optionKey]: collectionName })
-        : new Adapter(connectionString)
-    adapter.setMaxListeners?.(0)
-    _adapterCache.set(cacheKey, adapter)
-    return adapter
-}
-
-const isAdapterLike = (v) =>
-    v != null &&
-    typeof v === 'object' &&
-    typeof v.get === 'function' &&
-    typeof v.set === 'function' &&
-    typeof v.delete === 'function' &&
-    typeof v.clear === 'function'
-
-const resolveStore = async (backend, collectionName) => {
-    if (backend == null) return null
-    if (typeof backend === 'string') return resolveAdapter(backend, collectionName)
-    if (backend instanceof Keyv) return backend.opts?.store ?? backend.store ?? null
-    if (isAdapterLike(backend)) return backend
-    throw new Error('[Auth] backend must be a connection string, Keyv instance, or KeyvStoreAdapter')
-}
+// ── Keyv-backed auth state ────────────────────────────────────────────────────
 
 export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
-    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger, collectionName } = opts
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, collectionName } = opts
 
     const store = await resolveStore(backend, collectionName)
-    const keyv = store ? new Keyv({ store, namespace: sessionId }) : new Keyv({ namespace: sessionId })
-    keyv.on('error', (err) => logger?.warn?.({ err: err?.message }, '[Auth] store error'))
+    const keyv = store ? new Keyv({ store }) : new Keyv()
+    keyv.setMaxListeners?.(0)
+    keyv.on('error', err => logger.warn({ err: err?.message, sessionId }, '[Auth] store error'))
 
-    const keyName = (type, id) => `${type}-${id}`
+    // all keys prefixed sessionId:: to isolate sessions on a shared store
+    const kn = (type, id) => `${sessionId}::${type}-${id}`
+    const credsKey = `${sessionId}::creds`
 
-    let creds = bootstrapCreds(deser(await keyv.get('creds'), logger))
-    let cleanupRunning = false
-    let lastCleanupAt = 0
-    let lastCleanedPreKeyId = creds.nextPreKeyId
+    let creds = bootstrapCreds(deser(await keyv.get(credsKey)))
+    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedId = creds.nextPreKeyId
+    // tracks every key ever written — fallback clearSession uses this to wipe all types including JID-based IDs
+    const _writtenKeys = new Set([credsKey])
 
     const cleanOldPreKeys = async () => {
-        const now = Date.now()
-        if (cleanupRunning || now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        if (cleanupRunning || Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return
         cleanupRunning = true
         try {
             const minId = creds.nextPreKeyId - preKeyRetention
             if (minId <= 0) return
             const ids = []
-            for (let id = Math.max(0, lastCleanedPreKeyId - preKeyRetention); id < minId; id++) ids.push(keyName('pre-key', id))
-            if (!ids.length) return
-            await Promise.all(ids.map(k => keyv.delete(k).catch(() => { })))
-            lastCleanupAt = Date.now()
-            lastCleanedPreKeyId = creds.nextPreKeyId
+            for (let id = Math.max(0, lastCleanedId - preKeyRetention); id < minId; id++) ids.push(kn('pre-key', id))
+            if (ids.length) await Promise.all(ids.map(k => keyv.delete(k).catch(() => { })))
+            lastCleanupAt = Date.now(); lastCleanedId = creds.nextPreKeyId
         } catch (e) {
-            logger?.warn?.({ err: e.message }, '[Auth] prekey cleanup failed')
-        } finally {
-            cleanupRunning = false
-        }
+            logger.warn({ err: e.message, sessionId }, '[Auth] prekey cleanup failed')
+        } finally { cleanupRunning = false }
     }
 
     cleanOldPreKeys().catch(() => { })
 
     const keys = {
         get: async (type, ids) => {
-            const data = {}
-            if (!ids.length) return data
-            const rawKeys = ids.map(id => keyName(type, id))
-            const rawValues = await keyv.getMany(rawKeys)
-            const rewrites = []
-            ids.forEach((id, i) => {
-                data[id] = patchAppStateKey(type, deser(rawValues[i], logger))
-            })
-            if (rewrites.length) await Promise.all(rewrites).catch(() => { })
-            return data
+            if (!ids.length) return {}
+            const raws = await keyv.getMany(ids.map(id => kn(type, id)))
+            return Object.fromEntries(ids.map((id, i) => [id, patchAppStateKey(type, deser(raws[i]))]))
         },
-        set: async (data) => {
-            const setEntries = []
-            const delKeys = []
-            for (const type in data) {
+        set: async data => {
+            const sets = [], dels = []
+            for (const type in data)
                 for (const id in data[type]) {
-                    const value = data[type][id]
-                    const key = keyName(type, id)
-                    if (value != null) setEntries.push({ key, value: ser(value) })
-                    else delKeys.push(key)
+                    const v = data[type][id], k = kn(type, id)
+                    if (v != null) { sets.push({ key: k, value: ser(v) }); _writtenKeys.add(k) }
+                    else { dels.push(k); _writtenKeys.delete(k) }
                 }
-            }
             await Promise.all([
-                setEntries.length ? keyv.setMany(setEntries) : null,
-                delKeys.length ? keyv.deleteMany(delKeys) : null,
+                sets.length ? keyv.setMany(sets) : null,
+                dels.length ? keyv.deleteMany(dels) : null
             ])
-        },
+        }
     }
 
     const saveCreds = async () => {
-        if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
-        await keyv.set('creds', ser(creds))
+        if (creds.nextPreKeyId - lastCleanedId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
+        _writtenKeys.add(credsKey)
+        await keyv.set(credsKey, ser(creds))
     }
 
     const clearSession = async () => {
-        const s = keyv.opts?.store ?? keyv.store
-        if (s && typeof s.deleteMany === 'function' && typeof s.iterator === 'function') {
-            const toDelete = []
-            for await (const [key] of s.iterator(sessionId)) toDelete.push(key)
-            if (toDelete.length) await s.deleteMany(toDelete)
-        } else {
-            await keyv.clear()
+        const prefix = `${sessionId}::`
+        let done = false
+        if (store) {
+            // Redis: KEYS pattern scan
+            const rc = store.client
+            if (rc && typeof rc.keys === 'function') {
+                try { await store.set('__probe__', 1); const m = await rc.keys(`${prefix}*`); if (m.length) await rc.del(m); done = true } catch { }
+            }
+            // Mongo/Postgres/SQLite: iterator scan
+            if (!done && typeof store.iterator === 'function') {
+                try {
+                    const targets = []
+                    for await (const [k] of store.iterator(prefix)) if (k.startsWith(prefix)) targets.push(k)
+                    if (targets.length) await store.deleteMany(targets)
+                    done = true
+                } catch { }
+            }
+        }
+        if (!done) {
+            // fallback (in-memory): delete every key ever written — covers all types + JID-based IDs
+            await Promise.all([..._writtenKeys].map(k => keyv.delete(k).catch(() => { })))
+            _writtenKeys.clear()
         }
         keyv.removeAllListeners?.()
     }
@@ -304,4 +242,14 @@ export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
     return { state: { creds, keys }, saveCreds, clearSession }
 }
 
+// check if valid creds exist for a session without fully loading it
+export const hasKeyvAuth = async (sessionId, backend, opts = {}) => {
+    try {
+        const store = await resolveStore(backend, opts.collectionName)
+        const keyv = store ? new Keyv({ store }) : new Keyv()
+        const parsed = deser(await keyv.get(`${sessionId}::creds`))
+        return !!(parsed?.noiseKey && parsed?.signedIdentityKey)
+    } catch { return false }
+}
+
 export { Keyv }

package/lib/Utils/validate-connection.js

@@ -6,10 +6,12 @@ import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index
 import { Curve, hmacSign } from './crypto.js'
 import { encodeBigEndian } from './generics.js'
 import { createSignalIdentity } from './signal.js'
+import { getPlatformType } from './browser-utils.js'
 
 const PLATFORM_MAP = {
     'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32,
+    'Windows': proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID,
+    'WindowsStore': proto.ClientPayload.WebInfo.WebSubPlatform.WIN_STORE,
 }
 
 const getUserAgent = (config) => ({
@@ -18,12 +20,11 @@ const getUserAgent = (config) => ({
         secondary: config.version[1],
         tertiary: config.version[2],
     },
-    platform: config.browser[1].toLocaleLowerCase().includes('android')
-        ? proto.ClientPayload.UserAgent.Platform.MACOS
-        : proto.ClientPayload.UserAgent.Platform.WEB,
+    platform: proto.ClientPayload.UserAgent.Platform.WEB,
     releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
     osVersion: '0.1',
     device: 'Desktop',
+    deviceType: proto.ClientPayload.UserAgent.DeviceType.DESKTOP,
     osBuildNumber: '0.1',
     localeLanguageIso6391: 'en',
     mnc: '000',
@@ -48,10 +49,16 @@ const getClientPayload = (config) => {
     return payload
 }
 
-const getPlatformType = (platform) => {
-    const platformType = platform.toUpperCase()
-    if (platformType === 'ANDROID') return proto.DeviceProps.PlatformType.ANDROID_PHONE
-    return proto.DeviceProps.PlatformType[platformType] ?? proto.DeviceProps.PlatformType.CHROME
+const buildHistorySyncConfig = () => {
+    const fields = proto.DeviceProps.HistorySyncConfig.fields
+    const config = {}
+    for (const [name, field] of Object.entries(fields)) {
+        if (field.type === 'bool') config[name] = true
+    }
+    config.storageQuotaMb = 569150
+    config.supportCallLogHistory = false
+    config.supportGroupHistory = false
+    return config
 }
 
 export const generateLoginNode = (userJid, config) => {
@@ -72,24 +79,8 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
         os: config.browser[0],
         platformType: getPlatformType(config.browser[1]),
         requireFullSync: config.syncFullHistory,
-        historySyncConfig: {
-            storageQuotaMb: 569150,
-            inlineInitialPayloadInE2EeMsg: true,
-            recentSyncDaysLimit: undefined,
-            supportCallLogHistory: false,
-            supportBotUserAgentChatHistory: true,
-            supportCagReactionsAndPolls: true,
-            supportBizHostedMsg: true,
-            supportRecentSyncChunkMessageCountTuning: true,
-            supportHostedGroupMsg: true,
-            supportFbidBotChatHistory: true,
-            supportAddOnHistorySyncMigration: undefined,
-            supportMessageAssociation: true,
-            supportGroupHistory: false,
-            onDemandReady: undefined,
-            supportGuestChat: undefined,
-        },
-        version: { primary: 10, secondary: 15, tertiary: 7 },
+        historySyncConfig: buildHistorySyncConfig(),
+        version: { primary: config.version[0], secondary: config.version[1], tertiary: config.version[2] },
     }).finish()
 
     return proto.ClientPayload.fromObject({
@@ -97,14 +88,14 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
         passive: false,
         pull: false,
         devicePairingData: {
-            buildHash: appVersionBuf,
-            deviceProps: companionProto,
             eRegid: encodeBigEndian(registrationId),
             eKeytype: KEY_BUNDLE_TYPE,
             eIdent: signedIdentityKey.public,
             eSkeyId: encodeBigEndian(signedPreKey.keyId, 3),
             eSkeyVal: signedPreKey.keyPair.public,
             eSkeySig: signedPreKey.signature,
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
         },
     })
 }