@zervonex/baileys 3.0.3 → 3.0.4

package/lib/Socket/messages-recv.js

@@ -458,7 +458,7 @@ export const makeMessagesRecvSocket = (config) => {
         break
       case 'membership_approval_mode':
         const approvalMode = getBinaryNodeChild(child, 'group_join')
-        if (approvalMode) { msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE; msg.messageStubParameters = [approvalMode.attrs.state] }
+        if (approvalMode) { msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE; msg.messageStubParameters = [approvalMode?.attrs?.state] }
         break
       case 'created_membership_requests':
         msg.messageStubType = WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD

package/lib/Socket/messages-send.js

@@ -674,7 +674,7 @@ export const makeMessagesSocket = (config) => {
                 const isPrivate = isJidUser(normalizedId)
                 const type = isPrivate ? 'statusMentionMessage' : 'groupStatusMentionMessage'
                 const protocolMessage = { [type]: { message: { protocolMessage: { key: msg.key, type: 25 } } }, messageContextInfo: { messageSecret: randomBytes(32) } }
-                const statusMsg = await generateWAMessageFromContent(normalizedId, protocolMessage, {})
+                const statusMsg = await await generateWAMessageFromContent(normalizedId, protocolMessage, {})
                 await relayMessage(normalizedId, statusMsg.message, { additionalNodes: [{ tag: 'meta', attrs: isPrivate ? { is_status_mention: 'true' } : { is_group_status_mention: 'true' } }] })
                 await delay(2000)
             } catch (error) { logger.error({ id, error }, 'failed to send status mention') }

package/lib/Socket/socket.js

@@ -16,7 +16,7 @@ import {
   bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode,
   generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getCompanionPlatformId,
   getErrorCodeFromStreamError, getNextPreKeysNode, makeEventBuffer, makeNoiseHandler,
-  promiseTimeout, signedKeyPair, xmppSignedPreKey, getPlatformId, isAndroidBrowser
+  promiseTimeout, signedKeyPair, xmppSignedPreKey
 } from '../Utils/index.js'
 import {
   assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getAllBinaryNodeChildren,
@@ -530,6 +530,7 @@ export const makeSocket = (config) => {
   // ─── Pairing ─────────────────────────────────────────────────────────────────
 
   const requestPairingCode = async (phoneNumber, customPairingCode) => {
+    if (authState.creds.pairingCode && !customPairingCode) return authState.creds.pairingCode
     await waitForSocketOpen()
     await new Promise((resolve) => setTimeout(resolve, 500))
     const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5))
@@ -547,8 +548,8 @@ export const makeSocket = (config) => {
         content: [
           { tag: 'link_code_pairing_wrapped_companion_ephemeral_pub', attrs: {}, content: await generatePairingKey() },
           { tag: 'companion_server_auth_key_pub', attrs: {}, content: authState.creds.noiseKey.public },
-          { tag: 'companion_platform_id', attrs: {}, content: isAndroidBrowser(browser) ? getPlatformId('Chrome') : getCompanionPlatformId(browser) },
-          { tag: 'companion_platform_display', attrs: {}, content: isAndroidBrowser(browser) ? 'Chrome (Mac OS)' : `${browser[1]} (${browser[0]})` },
+          { tag: 'companion_platform_id', attrs: {}, content: getCompanionPlatformId(browser) },
+          { tag: 'companion_platform_display', attrs: {}, content: `${browser[1]} (${browser[0]})` },
           { tag: 'link_code_pairing_nonce', attrs: {}, content: '0' }
         ]
       }]

package/lib/Socket/zervonex-handler.js

@@ -35,7 +35,7 @@ export const makeMessageBuilderSocket = (config) => {
         if (content.nativeFlow && !content.interactiveMessage) {
             const buttons = Array.isArray(content.nativeFlow) ? content.nativeFlow : [content.nativeFlow]
             const { generateWAMessageFromContent } = await import('../Utils/index.js')
-            const msg = await generateWAMessageFromContent(jid, {
+            const msg = await await generateWAMessageFromContent(jid, {
                 interactiveMessage: { body: { text: content.text || '' }, footer: { text: content.footer || '' }, header: { hasMediaAttachment: false }, nativeFlowMessage: { buttons } }
             }, { userJid: sock.user?.id })
             await result.relayMessage(jid, msg.message, { messageId: msg.key.id, aiLabel: !!(content.ai ?? content.aiLabel ?? options.aiLabel ?? options.ai ?? config.aiLabel ?? config.ai) })

package/lib/Utils/browser-utils.js

@@ -13,14 +13,18 @@ export const Browsers = {
     baileys: browser => ['Baileys', browser, '6.5.0'],
     windows: browser => ['Windows', browser, '10.0.26100'],
     android: browser => [browser, 'Android', ''],
+    ios: browser => ['Mac OS', browser, '18.4'],
+    ipad: browser => ['iPadOS', browser, '18.4'],
     appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
 }
 
-export const getPlatformId = browser => {
+export const getPlatformType = (browser) => {
     const upper = browser.toUpperCase()
-    if (upper === 'ANDROID') return proto.DeviceProps.PlatformType.ANDROID_PHONE.toString()
-    const type = proto.DeviceProps.PlatformType[upper]
-    return (type ?? proto.DeviceProps.PlatformType.CHROME).toString()
+    if (upper === 'ANDROID') return proto.DeviceProps.PlatformType.ANDROID_PHONE
+    if (upper === 'IPAD') return proto.DeviceProps.PlatformType.IPAD
+    if (upper === 'IOS') return proto.DeviceProps.PlatformType.IOS_PHONE
+    if (upper === 'DESKTOP') return proto.DeviceProps.PlatformType.DESKTOP
+    return proto.DeviceProps.PlatformType[upper] ?? proto.DeviceProps.PlatformType.CHROME
 }
 
 export const isAndroidBrowser = browser => browser[1]?.toUpperCase() === 'ANDROID'

package/lib/Utils/chat-utils.js

@@ -117,7 +117,7 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
             const hmac = hmacSign(syncAction.index, key.indexKey)
             if (Buffer.compare(hmac, record.index.blob) !== 0) throw new Boom('HMAC index verification failed')
         }
-        onMutation({ syncAction, index: JSON.parse(Buffer.from(syncAction.index).toString()) })
+        if (syncAction.index) onMutation({ syncAction, index: JSON.parse(Buffer.from(syncAction.index).toString()) })
         ltGenerator.mix({ indexMac: record.index.blob, valueMac: ogValueMac, operation })
     }
     return ltGenerator.finish()

package/lib/Utils/messages.js

@@ -30,11 +30,20 @@ if (ffmpegStatic) process.env.FFMPEG_PATH = ffmpegStatic
 const MIMETYPE_DEFAULTS = { image: 'image/jpeg', video: 'video/mp4', document: 'application/pdf', audio: 'audio/ogg; codecs=opus', sticker: 'image/webp', 'product-catalog-image': 'image/jpeg' }
 
 // High-level user-facing send keys that are NOT proto field names — used only to detect pass-through
-const HIGH_LEVEL_KEYS = new Set(['text', 'image', 'video', 'audio', 'document', 'sticker', 'contacts', 'location', 'react', 'delete', 'forward', 'disappearingMessagesInChat', 'groupInvite', 'stickerPack', 'pin', 'buttonReply', 'ptv', 'product', 'listReply', 'event', 'poll', 'inviteAdmin', 'requestPayment', 'sharePhoneNumber', 'requestPhoneNumber', 'limitSharing', 'viewOnce', 'mentions', 'edit', 'buttons', 'templateButtons', 'sections', 'interactiveButtons', 'album', 'call', 'paymentInvite', 'order', 'keep', 'shop', 'payment', 'collection'])
+const HIGH_LEVEL_KEYS = new Set(['text', 'image', 'video', 'audio', 'document', 'sticker', 'contacts', 'location',
+    'react', 'delete', 'forward', 'disappearingMessagesInChat', 'groupInvite', 'stickerPack', 'pin', 'buttonReply',
+    'ptv', 'product', 'listReply', 'event', 'poll', 'inviteAdmin', 'requestPayment', 'sharePhoneNumber',
+    'requestPhoneNumber', 'limitSharing', 'viewOnce', 'mentions', 'edit', 'buttons', 'templateButtons',
+    'sections', 'interactiveButtons', 'album', 'call', 'paymentInvite', 'order', 'keep', 'shop', 'payment', 'collection'])
 
 // Wrapper field names for normalizeMessageContent — derived from what WA wraps messages in
-const WRAPPER_KEYS = ['ephemeralMessage', 'viewOnceMessage', 'documentWithCaptionMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension', 'editedMessage', 'groupMentionedMessage', 'botInvokeMessage', 'lottieStickerMessage', 'eventCoverImage', 'statusMentionMessage', 'pollCreationOptionImageMessage', 'associatedChildMessage', 'groupStatusMentionMessage', 'pollCreationMessageV4', 'pollCreationMessageV5', 'statusAddYours', 'groupStatusMessage', 'limitSharingMessage', 'botTaskMessage', 'questionMessage', 'botForwardedMessage']
-
+const WRAPPER_KEYS = ['ephemeralMessage', 'viewOnceMessage', 'documentWithCaptionMessage', 'viewOnceMessageV2', 'editedMessage',
+    'groupMentionedMessage', 'botInvokeMessage', 'lottieStickerMessage', 'eventCoverImage', 'viewOnceMessageV2Extension',
+    'statusMentionMessage', 'pollCreationOptionImageMessage', 'associatedChildMessage', 'groupStatusMentionMessage',
+    'pollCreationMessageV4', 'pollCreationMessageV5', 'statusAddYours', 'groupStatusMessage', 'limitSharingMessage',
+    'botTaskMessage', 'questionMessage', 'botForwardedMessage', 'commentMessage', 'groupStatusMessageV2', 'questionReplyMessage',
+    'newsletterAdminProfileMessage', 'spoilerMessage', 'newsletterAdminProfileStatusMessage', 'botPlatformRegistrationSuccessMessage',
+    'newsletterScheduledMessage', 'acp2SettingMessage', 'audioStickerMessage', 'botGroupParticipantMessage']
 const REUPLOAD_REQUIRED_STATUS = [410, 404]
 const STICKER_MAX_BYTES = 1_000_000
 const CIRCLE_GEQ = `clip(256-hypot(X-W/2\\,Y-H/2)\\,0\\,1)*255`
@@ -156,6 +165,32 @@ export const generateLinkPreviewIfRequired = async (text, getUrlInfo, logger) =>
     try { return await getUrlInfo(url) } catch (e) { logger?.warn({ trace: e.stack }, 'url generation failed') }
 }
 
+// ─── MEDIA RESOLUTION ─────────────────────────────────────────────────────────
+const MEDIA_MESSAGE_TYPES = ['Image', 'Video', 'Audio', 'Document', 'Sticker']
+const RESOLVABLE_MEDIA = [
+    ...MEDIA_MESSAGE_TYPES.map(t => ({ key: `${t.toLowerCase()}Message`, type: t.toLowerCase() })),
+    // raw field names used in card headers
+    { key: 'image', type: 'image' },
+    { key: 'video', type: 'video' },
+]
+const resolveMedia = async (obj, upload) => {
+    if (!obj || typeof obj !== 'object' || !upload || typeof upload !== 'function') return
+    for (const { key, type } of RESOLVABLE_MEDIA) {
+        if (!obj[key]) continue
+        const isRaw = key === 'image' || key === 'video'
+        if (!isRaw && obj[key].directPath) continue
+        const src = isRaw ? obj[key] : (obj[key].url ?? obj[key])
+        const result = await prepareWAMessageMedia({ [type]: typeof src === 'string' ? { url: src } : src }, { upload })
+        if (isRaw) { obj[`${type}Message`] = result[`${type}Message`]; delete obj[key] }
+        else obj[key] = result[`${type}Message`]
+        if ('hasMediaAttachment' in obj) obj.hasMediaAttachment = true
+    }
+    for (const val of Object.values(obj)) {
+        if (Array.isArray(val)) for (const item of val) await resolveMedia(item, upload)
+        else if (val && typeof val === 'object') await resolveMedia(val, upload)
+    }
+}
+
 // ─── EXPORTS: MESSAGE HELPERS ─────────────────────────────────────────────────
 
 export const getContentType = (content) => {
@@ -235,6 +270,7 @@ export const prepareWAMessageMedia = async (message, options) => {
             const { buffer } = await compressWebp(rawBuf, { packName, authorName, stickerType: message.stickerType || options?.stickerType || StickerTypes.ROUNDED, quality: message.quality || options?.quality || 80 })
             uploadData.media = buffer
             uploadData.stickerSentTs = Date.now()
+            if (message.premium != null) uploadData.premium = message.premium
         } catch (e) { options.logger?.warn({ err: e }, 'sticker formatting failed, sending raw') }
     }
 
@@ -351,7 +387,7 @@ export const prepareStickerPackMessage = async (stickerPack, options) => {
             const hash = sha256(finalBuf).toString('base64').replace(/\//g, '-').replace(/=/g, '')
             const fileSize = finalBuf.length
             writeFileSync(tmpOut, finalBuf); finalBuf = null
-            return { fileName: `${hash}.webp`, filePath: tmpOut, fileSize, mimetype: 'image/webp', isAnimated: s.isAnimated || false, isLottie: s.isLottie || false, emojis, accessibilityLabel: s.accessibilityLabel || '' }
+            return { fileName: `${hash}.webp`, filePath: tmpOut, fileSize, mimetype: 'image/webp', isAnimated: s.isAnimated || false, isLottie: s.isLottie || false, emojis, accessibilityLabel: s.accessibilityLabel || '', ...((s.premium ?? stickerPack.premium) != null && { premium: s.premium ?? stickerPack.premium }) }
         } catch (e) {
             options.logger?.warn({ err: e }, `failed processing sticker at index ${i}`)
             skippedStickers.push({ index: i, reason: e.message }); fs.unlink(tmpOut).catch(() => { }); return null
@@ -381,7 +417,7 @@ export const prepareStickerPackMessage = async (stickerPack, options) => {
             name: totalBatches > 1 ? `${packName} (${batchIdx + 1}/${totalBatches})` : packName, publisher: authorName,
             stickerPackId: totalBatches > 1 ? `${stickerPackIdValue}_${batchIdx}` : stickerPackIdValue,
             stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED, stickerPackSize: zipBuf.length,
-            stickers: batch.map(s => ({ fileName: s.fileName, mimetype: s.mimetype, isAnimated: s.isAnimated, isLottie: s.isLottie, emojis: s.emojis, accessibilityLabel: s.accessibilityLabel })),
+            stickers: batch.map(s => ({ fileName: s.fileName, mimetype: s.mimetype, isAnimated: s.isAnimated, isLottie: s.isLottie, emojis: s.emojis, accessibilityLabel: s.accessibilityLabel, ...(s.premium != null && { premium: s.premium }) })),
             fileSha256: upload.fileSha256, fileEncSha256: upload.fileEncSha256, mediaKey: upload.mediaKey,
             directPath: uploadRes.directPath, fileLength: upload.fileLength, mediaKeyTimestamp: unixTimestampSeconds(), trayIconFileName: trayFile,
             ...(thumbRes && { thumbnailDirectPath: thumbRes.directPath, thumbnailHeight: 252, thumbnailWidth: 252, thumbnailSha256: thumbRes._enc?.fileSha256, thumbnailEncSha256: thumbRes._enc?.fileEncSha256, imageDataHash: thumbRes._thumbBuf ? sha256(thumbRes._thumbBuf).toString('base64') : undefined }),
@@ -612,46 +648,61 @@ export const generateWAMessageContent = async (message, options = {}) => {
 // ─── ASSEMBLE FULL WA MESSAGE ─────────────────────────────────────────────────
 
 export const generateWAMessageFromContent = (jid, message, options) => {
-    if (!options.timestamp) options.timestamp = new Date()
-    const innerMessage = normalizeMessageContent(message)
-    const key = getContentType(innerMessage)
-    const { quoted, userJid } = options
-    if (quoted && !isJidNewsletter(jid)) {
-        const participant = quoted.key.fromMe ? userJid : (quoted.participant || quoted.key.participant || quoted.key.remoteJid)
-        const normalizedQuoted = normalizeMessageContent(quoted.message)
-        if (normalizedQuoted) {
-            const quotedType = getContentType(normalizedQuoted)
-            const quotedMsg = proto.Message.fromObject({ [quotedType]: normalizedQuoted[quotedType] })
-            const quotedContent = quotedMsg[quotedType]
-            if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) delete quotedContent.contextInfo
-            const contextInfo = innerMessage[key]?.contextInfo || {}
-            contextInfo.participant = jidNormalizedUser(participant)
-            contextInfo.stanzaId = quoted.key.id
-            contextInfo.quotedMessage = quotedMsg
-            if (jid !== quoted.key.remoteJid) contextInfo.remoteJid = quoted.key.remoteJid
-            if (innerMessage[key]) innerMessage[key].contextInfo = contextInfo
+    const upload = options.upload ?? options.waUploadToServer
+    const assemble = () => {
+        if (!options.timestamp) options.timestamp = new Date()
+        const innerMessage = normalizeMessageContent(message)
+        const key = getContentType(innerMessage)
+        const { quoted, userJid } = options
+        if (quoted && !isJidNewsletter(jid)) {
+            const participant = quoted.key.fromMe ? userJid : (quoted.participant || quoted.key.participant || quoted.key.remoteJid)
+            const normalizedQuoted = normalizeMessageContent(quoted.message)
+            if (normalizedQuoted) {
+                const quotedType = getContentType(normalizedQuoted)
+                const quotedMsg = proto.Message.fromObject({ [quotedType]: normalizedQuoted[quotedType] })
+                const quotedContent = quotedMsg[quotedType]
+                if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) delete quotedContent.contextInfo
+                const contextInfo = innerMessage[key]?.contextInfo || {}
+                contextInfo.participant = jidNormalizedUser(participant)
+                contextInfo.stanzaId = quoted.key.id
+                contextInfo.quotedMessage = quotedMsg
+                if (jid !== quoted.key.remoteJid) contextInfo.remoteJid = quoted.key.remoteJid
+                if (innerMessage[key]) innerMessage[key].contextInfo = contextInfo
+            }
         }
+        if (options?.ephemeralExpiration && key !== 'protocolMessage' && key !== 'ephemeralMessage' && !isJidNewsletter(jid)) {
+            innerMessage[key].contextInfo = { ...(innerMessage[key].contextInfo || {}), expiration: options.ephemeralExpiration || WA_DEFAULT_EPHEMERAL }
+        }
+        return WAProto.WebMessageInfo.fromObject({
+            key: { remoteJid: jid, fromMe: true, id: options?.messageId || generateMessageIDV2() },
+            message: WAProto.Message.create(message),
+            messageTimestamp: unixTimestampSeconds(options.timestamp),
+            messageStubParameters: [],
+            participant: (isJidGroup(jid) || isJidStatusBroadcast(jid)) ? userJid : undefined,
+            status: WAMessageStatus.PENDING,
+        })
     }
-    if (options?.ephemeralExpiration && key !== 'protocolMessage' && key !== 'ephemeralMessage' && !isJidNewsletter(jid)) {
-        innerMessage[key].contextInfo = { ...(innerMessage[key].contextInfo || {}), expiration: options.ephemeralExpiration || WA_DEFAULT_EPHEMERAL }
-    }
-    return WAProto.WebMessageInfo.fromObject({
-        key: { remoteJid: jid, fromMe: true, id: options?.messageId || generateMessageIDV2() },
-        message: WAProto.Message.create(message),
-        messageTimestamp: unixTimestampSeconds(options.timestamp),
-        messageStubParameters: [],
-        participant: (isJidGroup(jid) || isJidStatusBroadcast(jid)) ? userJid : undefined,
-        status: WAMessageStatus.PENDING,
-    })
+    const result = assemble()
+    if (!upload) return result
+    return Object.assign(result, { then(resolve, reject) { resolveMedia(message, upload).then(() => resolve(assemble())).catch(reject) } })
 }
 
-// Primary entry point. generateWAMessageContent returns a proto Message object.
-// generateWAMessageFromContent wraps existing content into a WebMessageInfo.
-// Call the wrong one by accident and it self-corrects rather than failing silently.
-export const generateWAMessage = async (jid, content, options = {}) => {
+// Primary entry point. Builds a WebMessageInfo from raw content.
+// Returns a thenable — key.id is available synchronously, full message resolves on await.
+// If called with an existing WebMessageInfo by accident, passes it through unchanged.
+export const generateWAMessage = (jid, content, options = {}) => {
     if (content?.key?.remoteJid && content?.message) return content
-    options.logger = options?.logger?.child({ msgId: options.messageId })
-    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, { ...options, jid }), options)
+    const msgId = options.messageId || generateMessageIDV2()
+    const result = { key: { remoteJid: jid, fromMe: true, id: msgId }, messageId: msgId }
+    const promise = (async () => {
+        options.logger = options?.logger?.child({ msgId })
+        return generateWAMessageFromContent(jid, await generateWAMessageContent(content, { ...options, jid, messageId: msgId }), { ...options, messageId: msgId })
+    })()
+    return Object.assign(result, {
+        then: (resolve, reject) => promise.then(resolve, reject),
+        catch: (reject) => promise.catch(reject),
+        finally: (fn) => promise.finally(fn),
+    })
 }
 
 // ─── UPDATE UTILITIES ─────────────────────────────────────────────────────────

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

@@ -11,64 +11,38 @@ 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
-}
-
-const patchAppStateKey = (type, v) =>
-    type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
+const bootstrapCreds = (raw) => { const c = raw ?? initAuthCreds(); if (!c.__version || c.__version < CURRENT_VERSION) c.__version = CURRENT_VERSION; return c }
+const patchAppStateKey = (type, v) => type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
 
 // ── File-based ────────────────────────────────────────────────────────────────
 
 export const useMultiFileAuthState = async (folder, options = {}) => {
     const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger } = options
-
     const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-')
     const filePath = (file) => join(folder, fixFileName(file))
     const tmpPath = (file) => filePath(file) + '.tmp'
 
     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 })
-    }
+    if (folderInfo) { if (!folderInfo.isDirectory()) throw new Error(`Path exists but is not a directory: ${folder}`) }
+    else { await mkdir(folder, { recursive: true }) }
 
     const writeData = async (data, file) => {
-        const fp = filePath(file)
-        const tp = tmpPath(file)
-        const payload = JSON.stringify(data, BufferJSON.replacer)
+        const fp = filePath(file), tp = tmpPath(file), payload = JSON.stringify(data, BufferJSON.replacer)
         await writeFile(tp, payload)
-        try {
-            await rename(tp, fp)
-        } catch {
-            await writeFile(fp, payload)
-            await unlink(tp).catch(() => { })
-        }
+        try { await rename(tp, fp) } catch { await writeFile(fp, payload); await unlink(tp).catch(() => { }) }
     }
 
     const readData = async (file) => {
         const raw = await readFile(filePath(file), { encoding: '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(() => { })
-            return null
-        }
+        try { const p = JSON.parse(raw, BufferJSON.reviver); return (p && typeof p === 'object' && '__checksum' in p && 'data' in p) ? p.data : p }
+        catch (err) { logger?.warn({ file, err: err.message }, 'failed to read auth file — reinitializing'); await unlink(filePath(file)).catch(() => { }); return null }
     }
 
     const removeData = (file) => unlink(filePath(file)).catch(() => { })
 
     let creds = bootstrapCreds(await readData('creds.json'))
-    let cleanupRunning = false
-    let lastCleanupAt = 0
-    let lastCleanedPreKeyId = creds.nextPreKeyId
+    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedPreKeyId = creds.nextPreKeyId
 
     const cleanOldPreKeys = async () => {
         const now = Date.now()
@@ -77,63 +51,30 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
         try {
             const minId = creds.nextPreKeyId - preKeyRetention
             if (minId <= 0) return
-            const targets = (await readdir(folder))
-                .map(f => f.match(/^pre-key-(\d+)\.json(\.tmp)?$/))
-                .filter(m => m && parseInt(m[1], 10) < minId)
-                .map(m => join(folder, m[0]))
+            const targets = (await readdir(folder)).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
-        }
+            lastCleanupAt = Date.now(); lastCleanedPreKeyId = creds.nextPreKeyId
+        } catch (err) { logger?.warn({ err }, '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 { totalFiles: files.length, preKeyCount: files.filter(f => /^pre-key-\d+\.json$/.test(f)).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
-                    }))
-                    return 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`))
-                        }
-                    }
-                    await Promise.all(tasks)
-                },
+                get: async (type, ids) => { const data = {}; await Promise.all(ids.map(async id => { let v = await readData(`${type}-${id}.json`); data[id] = type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v })); return data },
+                set: async (data) => { const tasks = []; for (const cat in data) for (const id in data[cat]) { const v = data[cat][id]; tasks.push(v ? writeData(v, `${cat}-${id}.json`) : removeData(`${cat}-${id}.json`)) }; await Promise.all(tasks) },
             },
         },
-        saveCreds: async () => {
-            if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
-            return writeData(creds, 'creds.json')
-        },
+        saveCreds: async () => { if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { }); return writeData(creds, 'creds.json') },
         getStats,
     }
 }
@@ -142,72 +83,41 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
 
 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 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
-        }
-    } else {
-        parsed = raw
-    }
+    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 } }
+    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 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
-    }
-
+    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)
+    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 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
@@ -219,17 +129,13 @@ const resolveStore = async (backend, collectionName) => {
 
 export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
     const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger, 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 keyName = (type, id) => `${type}-${id}`
-
     let creds = bootstrapCreds(deser(await keyv.get('creds'), logger))
-    let cleanupRunning = false
-    let lastCleanupAt = 0
-    let lastCleanedPreKeyId = creds.nextPreKeyId
+    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedPreKeyId = creds.nextPreKeyId
 
     const cleanOldPreKeys = async () => {
         const now = Date.now()
@@ -242,59 +148,35 @@ export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
             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
-        } catch (e) {
-            logger?.warn?.({ err: e.message }, '[Auth] prekey cleanup failed')
-        } finally {
-            cleanupRunning = false
-        }
+            lastCleanupAt = Date.now(); lastCleanedPreKeyId = creds.nextPreKeyId
+        } catch (e) { logger?.warn?.({ err: e.message }, '[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 rawValues = await keyv.getMany(ids.map(id => keyName(type, id)))
+            return Object.fromEntries(ids.map((id, i) => [id, patchAppStateKey(type, deser(rawValues[i], logger))]))
         },
         set: async (data) => {
-            const setEntries = []
-            const delKeys = []
-            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)
-                }
-            }
-            await Promise.all([
-                setEntries.length ? keyv.setMany(setEntries) : null,
-                delKeys.length ? keyv.deleteMany(delKeys) : null,
-            ])
+            const setEntries = [], delKeys = []
+            for (const type in data) for (const id in data[type]) { const v = data[type][id], k = keyName(type, id); v != null ? setEntries.push({ key: k, value: ser(v) }) : delKeys.push(k) }
+            await Promise.all([setEntries.length ? keyv.setMany(setEntries) : null, delKeys.length ? keyv.deleteMany(delKeys) : null])
         },
     }
 
-    const saveCreds = async () => {
-        if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
-        await keyv.set('creds', ser(creds))
-    }
+    const saveCreds = async () => { if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { }); await keyv.set('creds', ser(creds)) }
 
     const clearSession = async () => {
         const s = keyv.opts?.store ?? keyv.store
-        if (s && typeof s.deleteMany === 'function' && typeof s.iterator === 'function') {
+        if (s && typeof s.iterator === 'function') {
+            // v6: iterator() takes no namespace arg — uses this._namespace set via new Keyv({ namespace: sessionId })
             const toDelete = []
-            for await (const [key] of s.iterator(sessionId)) toDelete.push(key)
-            if (toDelete.length) await s.deleteMany(toDelete)
+            for await (const [key] of s.iterator()) toDelete.push(key)
+            if (toDelete.length) typeof s.deleteMany === 'function' ? await s.deleteMany(toDelete) : await Promise.all(toDelete.map(k => s.delete(k).catch(() => { })))
         } else {
             await keyv.clear()
         }
@@ -304,4 +186,15 @@ export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
     return { state: { creds, keys }, saveCreds, clearSession }
 }
 
+export const hasKeyvAuth = async (sessionId, backend, opts = {}) => {
+    try {
+        const store = await resolveStore(backend, opts.collectionName)
+        const keyv = store ? new Keyv({ store, namespace: sessionId }) : new Keyv({ namespace: sessionId })
+        const raw = await keyv.get('creds')
+        if (!raw) return false
+        const parsed = deser(raw)
+        return !!(parsed?.noiseKey && parsed?.signedIdentityKey)
+    } catch { return false }
+}
+
 export { Keyv }