@nexustechpro/baileys 2.1.2 → 2.1.6

package/lib/Signal/libsignal.js

@@ -8,8 +8,9 @@ import {
     SenderKeyName,
     SenderKeyDistributionMessage,
 } from 'whatsapp-rust-bridge'
+import { proto } from '../../WAProto/index.js'
 import { LRUCache } from 'lru-cache'
-import { generateSignalPubKey, migrateIndexKey } from '../Utils/index.js'
+import { generateSignalPubKey } from '../Utils/index.js'
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from '../WABinary/index.js'
 import { LIDMappingStore } from './lid-mapping.js'
 
@@ -27,8 +28,6 @@ const jidToAddr = (jid) => {
 
 const jidToSenderKeyName = (group, user) => new SenderKeyName(group, jidToAddr(user))
 
-const v2Key = (addr) => `${addr}:v2`
-
 // ─── Buffer Utils ─────────────────────────────────────────────────────────────
 
 const toBuffer = (raw) => {
@@ -62,31 +61,19 @@ const isOldJson = (raw) => {
 const bufEqual = (a, b) =>
     a && b && a.length === b.length && a.every((byte, i) => byte === b[i])
 
-// ─── Identity Extraction ──────────────────────────────────────────────────────
-// Reads field 4 (identity key, 33 bytes) from PreKeyWhisperMessage protobuf envelope
+// ─── Identity Key Extraction ──────────────────────────────────────────────────
 
 const extractIdentityFromPkmsg = (ciphertext) => {
     try {
         if (!ciphertext || ciphertext.length < 2) return undefined
         if ((ciphertext[0] & 0xf) !== 3) return undefined
-        const buf = ciphertext.slice(1)
-        let i = 0
-        while (i < buf.length) {
-            const tag = buf[i++]
-            const fieldNum = tag >> 3
-            const wireType = tag & 0x7
-            if (wireType === 2) {
-                let len = 0, shift = 0
-                while (i < buf.length) { const b = buf[i++]; len |= (b & 0x7f) << shift; if (!(b & 0x80)) break; shift += 7 }
-                if (fieldNum === 4 && len === 33) return new Uint8Array(buf.slice(i, i + len))
-                i += len
-            } else if (wireType === 0) { while (i < buf.length && buf[i++] & 0x80) { } }
-            else if (wireType === 5) { i += 4 }
-            else if (wireType === 1) { i += 8 }
-            else break
-        }
-    } catch { }
-    return undefined
+        const decoded = proto.PreKeySignalMessage.decode(ciphertext.slice(1))
+        const key = decoded.identityKey
+        if (key && key.length === 33) return new Uint8Array(key)
+        return undefined
+    } catch {
+        return undefined
+    }
 }
 
 // ─── Main Factory ─────────────────────────────────────────────────────────────
@@ -95,29 +82,29 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
     const lidMapping = new LIDMappingStore(auth.keys, logger, pnToLIDFunc)
     const parsedKeys = auth.keys
 
-    // #17 — expose lidCache ref so migrateSession can invalidate it
+    // LRU cache for PN→LID address resolution to avoid repeated DB lookups
     const lidCache = new LRUCache({ max: 500, ttl: 5 * 60 * 1000 })
 
-    // #1 — dedicated mutex serialising all session index writes to prevent cross-JID race
-    let sessionIndexWriteLock = Promise.resolve()
-    const withSessionLock = (fn) => {
-        const next = sessionIndexWriteLock.then(fn).catch(fn)
-        sessionIndexWriteLock = next.then(() => { }, () => { })
-        return next
-    }
-
-    // #2 — session read cache: avoids full index read on every decrypt
+    // Per-address session read cache: avoids a DB round-trip on every decrypt.
+    // Keyed by resolved LID addr string. Value is Uint8Array | null.
     const sessionReadCache = new LRUCache({ max: 1000, ttl: 5 * 60 * 1000, ttlAutopurge: true })
 
-    const storage = signalStorage(auth, lidMapping, logger, lidCache, sessionReadCache, withSessionLock)
+    const storage = signalStorage(auth, lidMapping, logger, lidCache, sessionReadCache)
+
+    // Tracks which PN→LID session migrations have already been done this process
+    // lifetime so migrateSession is idempotent even if called repeatedly.
     const migratedCache = new LRUCache({ ttl: 7 * 24 * 60 * 60 * 1000, ttlAutopurge: true, updateAgeOnGet: true })
+
     const txn = (fn, key) => parsedKeys.transaction(fn, key)
 
     return {
-        // ── Group ─────────────────────────────────────────────────────────────────
+        // ── Group messaging ───────────────────────────────────────────────────────
 
         decryptGroupMessage({ group, authorJid, msg }) {
-            return txn(() => new GroupCipher(storage, group, jidToAddr(authorJid)).decrypt(msg), group)
+            return txn(
+                () => new GroupCipher(storage, group, jidToAddr(authorJid)).decrypt(toU8(msg)),
+                group
+            )
         },
 
         async processSenderKeyDistributionMessage({ item, authorJid }) {
@@ -126,7 +113,6 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             const senderMsg = SenderKeyDistributionMessage.deserialize(
                 toU8(item.axolotlSenderKeyDistributionMessage)
             )
-            // do NOT pre-store a blank SenderKeyRecord — serialize() returns 0 bytes and bridge throws
             return txn(() => new GroupSessionBuilder(storage).process(senderName, senderMsg), item.groupId)
         },
 
@@ -139,7 +125,6 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             }, group)
         },
 
-        // #10 — kept for API completeness but not called by messages-send.js
         getSenderKeyDistributionMessage({ group, meId }) {
             return txn(async () => {
                 const senderName = jidToSenderKeyName(group, meId)
@@ -149,15 +134,21 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 
         async hasSenderKey({ group, meId }) {
             const name = jidToSenderKeyName(group, meId).toString()
-            const { [name]: key } = await parsedKeys.get('sender-key', [name])
-            return !!toBuffer(key)
+            const { [name]: raw } = await parsedKeys.get('sender-key', [name])
+            const buf = toU8(raw)
+            if (!buf) return false
+            try {
+                return !SenderKeyRecord.deserialize(buf).isEmpty()
+            } catch {
+                return false
+            }
         },
 
         deleteSenderKey(group, authorJid) {
             return parsedKeys.set({ 'sender-key': { [jidToSenderKeyName(group, authorJid).toString()]: null } })
         },
 
-        // ── 1:1 ───────────────────────────────────────────────────────────────────
+        // ── 1:1 messaging ─────────────────────────────────────────────────────────
 
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToAddr(jid)
@@ -166,26 +157,26 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 
             try {
                 return await txn(async () => {
-                    // #8 — identity save inside transaction to prevent concurrent pkmsg race
                     if (type === 'pkmsg') {
                         const identityKey = extractIdentityFromPkmsg(ciphertext)
                         if (identityKey) {
                             const changed = await storage.saveIdentity(addrStr, identityKey)
-                            if (changed) logger?.info?.({ jid }, '[Signal] Identity key changed, session cleared')
+                            if (changed) logger?.info?.({ jid }, '[Signal] Identity key changed — session cleared for re-handshake')
                         } else {
-                            logger?.debug?.({ jid }, '[Signal] pkmsg: could not extract identity key from envelope')
+                            logger?.warn?.({ jid }, '[Signal] pkmsg: could not extract identity key from envelope')
                         }
-                        return cipher.decryptPreKeyWhisperMessage(ciphertext)
+                        return cipher.decryptPreKeyWhisperMessage(toU8(ciphertext))
                     }
-                    if (type === 'msg') return cipher.decryptWhisperMessage(ciphertext)
-                    throw new Error(`Unknown message type: ${type}`)
+                    if (type === 'msg') {
+                        return cipher.decryptWhisperMessage(toU8(ciphertext))
+                    }
+                    throw new Error(`[Signal] Unknown message type: ${type}`)
                 }, jid)
             } catch (e) {
                 if (e?.message?.includes('DuplicatedMessage')) {
                     logger?.debug?.({ jid }, '[Signal] Duplicate message ignored')
                     return null
                 }
-                // #11 — on untrusted identity / session corruption, wipe and let caller retry
                 if (e?.message?.includes('UntrustedIdentity') || e?.message?.includes('InvalidMessage')) {
                     logger?.warn?.({ jid, err: e.message }, '[Signal] Session error — wiping session for re-handshake')
                     await storage.wipeSession(addrStr)
@@ -197,7 +188,7 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 
         encryptMessage({ jid, data }) {
             return txn(async () => {
-                const { type: sigType, body } = await new SessionCipher(storage, jidToAddr(jid)).encrypt(data)
+                const { type: sigType, body } = await new SessionCipher(storage, jidToAddr(jid)).encrypt(toU8(data))
                 return { type: sigType === 3 ? 'pkmsg' : 'msg', ciphertext: Buffer.from(body) }
             }, jid)
         },
@@ -206,181 +197,106 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             return txn(() => new SessionBuilder(storage, jidToAddr(jid)).processPreKeyBundle(session), jid)
         },
 
-        // ── Session management ────────────────────────────────────────────────────
+        // ── Session utilities ──────────────────────────────────────────────────────
 
-        jidToSignalProtocolAddress: jid => jidToAddr(jid).toString(),
+        jidToSignalProtocolAddress: (jid) => jidToAddr(jid).toString(),
 
         lidMapping,
 
         async validateSession(jid) {
             try {
                 const addr = jidToAddr(jid).toString()
-                const batch = await migrateIndexKey(parsedKeys, 'session')
-                const raw = toBuffer(batch[v2Key(addr)]) || toBuffer(batch[addr])
-                if (!raw || isOldJson(raw)) return { exists: false, reason: 'no session' }
-                return SessionRecord.deserialize(raw).haveOpenSession()
-                    ? { exists: true }
-                    : { exists: false, reason: 'no open session' }
-            } catch { return { exists: false, reason: 'error' } }
+                const raw = await storage.loadSession(addr)
+                if (!raw) return { exists: false, reason: 'no session' }
+                try {
+                    return SessionRecord.deserialize(raw).haveOpenSession()
+                        ? { exists: true }
+                        : { exists: false, reason: 'no open session' }
+                } catch {
+                    return { exists: false, reason: 'deserialize error' }
+                }
+            } catch {
+                return { exists: false, reason: 'error' }
+            }
         },
 
         async deleteSession(jids) {
             if (!jids?.length) return
             return txn(async () => {
-                // #9 — spread before mutating to avoid corrupting in-memory store on write failure
-                const batch = await migrateIndexKey(parsedKeys, 'session')
-                const updated = { ...batch }
+                const updates = {}
                 for (const jid of jids) {
                     const addr = jidToAddr(jid).toString()
-                    delete updated[addr]
-                    delete updated[v2Key(addr)]
+                    updates[addr] = null
                     sessionReadCache.delete(addr)
                 }
-                await parsedKeys.set({ session: { index: updated } })
+                await parsedKeys.set({ session: updates })
             }, `del-${jids.length}`)
         },
 
-        // ── Session migration ─────────────────────────────────────────────────────
+        // ── Session migration (PN → LID) ──────────────────────────────────────────
 
         async migrateSession(fromJid, toJid) {
             if (!fromJid || (!isLidUser(toJid) && !isHostedLidUser(toJid))) return { migrated: 0, skipped: 0, total: 0 }
             if (!isPnUser(fromJid) && !isHostedPnUser(fromJid)) return { migrated: 0, skipped: 0, total: 1 }
             const { user } = jidDecode(fromJid)
 
-            // #15 — parallel fetch of device-list and session index
-            const [deviceListBatch, sessionBatch] = await Promise.all([
-                migrateIndexKey(parsedKeys, 'device-list'),
-                migrateIndexKey(parsedKeys, 'session'),
-            ])
-
-            const userDevices = deviceListBatch[user] ? [...deviceListBatch[user]] : []
+            const { [user]: userDevices_ } = await parsedKeys.get('device-list', [user])
+            const userDevices = userDevices_ ? [...userDevices_] : []
             const fromDeviceStr = jidDecode(fromJid).device?.toString() || '0'
             if (!userDevices.includes(fromDeviceStr)) userDevices.push(fromDeviceStr)
 
-            const deviceJids = userDevices
+            // Build addr strings for each device, skip already-migrated
+            const candidates = userDevices
                 .filter(d => !migratedCache.has(`${user}.${d}`))
                 .map(d => {
                     const num = parseInt(d)
-                    return {
-                        cacheKey: `${user}.${d}`,
-                        jid: num === 99 ? `${user}:99@hosted` : num === 0 ? `${user}@s.whatsapp.net` : `${user}:${num}@s.whatsapp.net`
-                    }
-                })
-                .filter(({ jid }) => {
-                    const addr = jidToAddr(jid).toString()
-                    return sessionBatch[v2Key(addr)] || sessionBatch[addr]
+                    const jid = num === 99 ? `${user}:99@hosted`
+                        : num === 0 ? `${user}@s.whatsapp.net`
+                            : `${user}:${num}@s.whatsapp.net`
+                    return { cacheKey: `${user}.${d}`, jid, addr: jidToAddr(jid).toString() }
                 })
 
-            if (!deviceJids.length) return { migrated: 0, skipped: 0, total: 0 }
-
-            return txn(async () => {
-                // #5 — re-read inside txn for a fresh snapshot
-                const freshBatch = await migrateIndexKey(parsedKeys, 'session')
-                const updated = { ...freshBatch }
-                let migrated = 0
-
-                for (const { jid, cacheKey } of deviceJids) {
-                    const pnAddr = jidToAddr(jid).toString()
-                    const lidAddr = jidToAddr(transferDevice(jid, toJid)).toString()
-                    const raw = toBuffer(updated[v2Key(pnAddr)]) || toBuffer(updated[pnAddr])
-                    if (!raw || isOldJson(raw)) continue
-                    const sess = SessionRecord.deserialize(raw)
-                    if (!sess.haveOpenSession()) continue
-                    updated[v2Key(lidAddr)] = sess.serialize()
-                    updated[lidAddr] = { version: 'v1', _sessions: {} }
-                    delete updated[v2Key(pnAddr)]
-                    delete updated[pnAddr]
-                    // #3 — invalidate lidCache for migrated PN addr so next resolve hits store
-                    lidCache.delete(pnAddr)
-                    sessionReadCache.delete(pnAddr)
-                    migrated++
-                    migratedCache.set(cacheKey, true)
-                }
+            if (!candidates.length) return { migrated: 0, skipped: 0, total: 0 }
 
-                if (migrated > 0) await parsedKeys.set({ session: { index: updated } })
-                return { migrated, skipped: deviceJids.length - migrated, total: deviceJids.length }
-            }, `migrate-${jidDecode(toJid)?.user}`)
-        },
+            // Bulk-fetch only the session keys we actually need
+            const addrs = candidates.map(c => c.addr)
+            const existing = await parsedKeys.get('session', addrs)
 
-        async migrateAllPNSessionsToLID() {
-            // #16 — skip everything if creds have no LID at all
-            if (!auth.creds?.me?.lid) return 0
-
-            // lid-mapping read outside txn to avoid nested key-namespace lock
-            // #5 — session batch read outside is intentional; re-read inside txn before write
-            const [sessionBatch, stored] = await (async () => {
-                const sb = await migrateIndexKey(parsedKeys, 'session')
-                const sessionKeys = Object.keys(sb)
-                if (!sessionKeys.length) return [sb, {}]
-                const pnAddrs = sessionKeys.filter(addr => {
-                    if (addr.endsWith(':v2') || !addr.includes('.')) return false
-                    const [, dt] = addr.split('.')[0].split('_')
-                    const domainType = parseInt(dt || '0')
-                    return domainType === WAJIDDomains.WHATSAPP || domainType === WAJIDDomains.HOSTED
-                })
-                if (!pnAddrs.length) return [sb, {}]
-                const pnUserSet = new Set(pnAddrs.map(addr => addr.split('.')[0].split('_')[0]))
-                const s = await parsedKeys.get('lid-mapping', [...pnUserSet])
-                return [sb, s]
-            })()
-
-            const sessionKeys = Object.keys(sessionBatch)
-            if (!sessionKeys.length) return 0
-
-            const pnAddrs = sessionKeys.filter(addr => {
-                if (addr.endsWith(':v2') || !addr.includes('.')) return false
-                const [, dt] = addr.split('.')[0].split('_')
-                const domainType = parseInt(dt || '0')
-                return domainType === WAJIDDomains.WHATSAPP || domainType === WAJIDDomains.HOSTED
+            const toMigrate = candidates.filter(c => {
+                const raw = toU8(existing[c.addr])
+                return raw && !isOldJson(raw)
             })
-            if (!pnAddrs.length) return 0
 
-            const pnToLidUserMap = new Map()
-            for (const pnUser of new Set(pnAddrs.map(addr => addr.split('.')[0].split('_')[0]))) {
-                const lidUser = stored[pnUser]
-                if (lidUser && typeof lidUser === 'string') pnToLidUserMap.set(pnUser, lidUser)
-            }
-            if (!pnToLidUserMap.size) return 0
+            if (!toMigrate.length) return { migrated: 0, skipped: candidates.length, total: candidates.length }
 
             return txn(async () => {
-                // #5 — fresh read inside txn before writing
-                const freshBatch = await migrateIndexKey(parsedKeys, 'session')
-                const updated = { ...freshBatch }
+                // Re-fetch inside txn for freshness
+                const fresh = await parsedKeys.get('session', toMigrate.map(c => c.addr))
+                const updates = {}
                 let migrated = 0
 
-                for (const addr of pnAddrs) {
-                    const [deviceId, device] = addr.split('.')
-                    const [user, dt] = deviceId.split('_')
-                    const domainType = parseInt(dt || '0')
-                    const lidUser = pnToLidUserMap.get(user)
-                    if (!lidUser) continue
-                    const lidDomainType = domainType === WAJIDDomains.HOSTED ? WAJIDDomains.HOSTED_LID : WAJIDDomains.LID
-                    const lidAddr = `${lidUser}_${lidDomainType}.${device}`
-                    if (updated[v2Key(lidAddr)]) continue
-                    const raw = toBuffer(updated[v2Key(addr)]) || toBuffer(updated[addr])
+                for (const { jid, addr, cacheKey } of toMigrate) {
+                    const raw = toU8(fresh[addr])
                     if (!raw || isOldJson(raw)) continue
-                    const sess = SessionRecord.deserialize(raw)
+                    let sess
+                    try { sess = SessionRecord.deserialize(raw) } catch { continue }
                     if (!sess.haveOpenSession()) continue
-                    updated[v2Key(lidAddr)] = sess.serialize()
-                    updated[lidAddr] = { version: 'v1', _sessions: {} }
-                    delete updated[v2Key(addr)]
-                    delete updated[addr]
-                    // #3 — invalidate caches for migrated addresses
+                    const lidAddr = jidToAddr(transferDevice(jid, toJid)).toString()
+                    updates[lidAddr] = sess.serialize()
+                    updates[addr] = null
                     lidCache.delete(addr)
                     sessionReadCache.delete(addr)
                     migrated++
-                    migratedCache.set(`${user}.${device}`, true)
+                    migratedCache.set(cacheKey, true)
                 }
 
                 if (migrated > 0) {
-                    await parsedKeys.set({ session: { index: updated } })
-                    logger?.info?.({ migrated, totalPN: pnAddrs.length, mappingsFound: pnToLidUserMap.size }, '[Signal] Batch-migrated PN sessions to LID on connect')
+                    await parsedKeys.set({ session: updates })
                 }
-                return migrated
-            }, 'migrate-all-pn-to-lid')
+                return { migrated, skipped: toMigrate.length - migrated, total: candidates.length }
+            }, `migrate-${jidDecode(toJid)?.user}`)
         },
 
-        // #17 — warm the LID cache on connect from stored mappings
         async warmLIDCache(mappings) {
             for (const { pn, lid } of mappings) {
                 try {
@@ -401,16 +317,16 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
 }
 
 // ─── Storage Adapter ──────────────────────────────────────────────────────────
-// Implements SignalStorage interface for whatsapp-rust-bridge.
+// Implements the SignalStorage interface consumed by whatsapp-rust-bridge WASM.
 //
-// Session index dual-key pattern:
-//   v2Key(addr) → actual binary SessionRecord bytes
-//   addr        → JSON tombstone { version:'v1', _sessions:{} } for old-code compat
-//
-// storeSenderKey always receives plain Uint8Array from bridge (confirmed by unit test).
-// NEVER pre-store a blank SenderKeyRecord — serialize() returns 0 bytes, bridge throws.
+// One key per record — exactly as original Baileys does:
+//   session:      addr string  → Uint8Array (SessionRecord.serialize())
+//   identity-key: addr string  → Uint8Array (33-byte identity key)
+//   pre-key:      id string    → { public, private }
+//   sender-key:   keyId string → Buffer
+
+function signalStorage({ creds, keys }, lidMapping, logger, lidCache, sessionReadCache) {
 
-function signalStorage({ creds, keys }, lidMapping, logger, lidCache, sessionReadCache, withSessionLock) {
     const resolveLID = async (id) => {
         if (!id.includes('.')) return id
         const cached = lidCache.get(id)
@@ -426,77 +342,48 @@ function signalStorage({ creds, keys }, lidMapping, logger, lidCache, sessionRea
         return result
     }
 
-    // #1/#2 — all index reads go through the read cache; all writes go through the write lock
-    const getIndex = async () => {
-        const cached = sessionReadCache.get('__index__')
-        if (cached) return cached
-        const batch = await migrateIndexKey(keys, 'session')
-        sessionReadCache.set('__index__', batch)
-        return batch
-    }
-
-    const setIndex = (batch) => withSessionLock(async () => {
-        sessionReadCache.set('__index__', batch)
-        try {
-            await keys.set({ session: { index: batch } })
-        } catch (e) {
-            // #18 — on write failure invalidate cache so next read hits store
-            sessionReadCache.delete('__index__')
-            logger?.error?.(`[Signal] storeSession write failed: ${e.message}`)
-            throw e
-        }
-    })
-
     return {
+        // ── Sessions ─────────────────────────────────────────────────────────────
+
         loadSession: async (id) => {
             try {
                 const addr = await resolveLID(id)
-                // #2 — check per-addr cache before reading full index
                 const cached = sessionReadCache.get(addr)
                 if (cached !== undefined) return cached === null ? null : toU8(cached)
-                const batch = await getIndex()
-                const v2 = batch[v2Key(addr)]
-                if (v2) {
-                    if (isOldJson(v2)) { logger?.debug?.(`[Signal] Corrupt v2 for ${addr}, fresh handshake`); sessionReadCache.set(addr, null); return null }
-                    const buf = toU8(v2)
-                    if (buf) { sessionReadCache.set(addr, buf); return buf }
-                }
-                const plain = batch[addr]
-                if (!plain || isOldJson(plain)) {
-                    if (plain) logger?.debug?.(`[Signal] Old JSON session for ${addr}, fresh handshake`)
+                const { [addr]: raw } = await keys.get('session', [addr])
+                if (!raw || isOldJson(raw)) {
                     sessionReadCache.set(addr, null)
                     return null
                 }
-                const buf = toU8(plain)
+                const buf = toU8(raw)
                 sessionReadCache.set(addr, buf)
                 return buf
-            } catch (e) { logger?.error?.(`[Signal] loadSession error: ${e.message}`); return null }
+            } catch (e) {
+                logger?.error?.(`[Signal] loadSession error for ${id}: ${e.message}`)
+                return null
+            }
         },
 
         storeSession: async (id, record) => {
             const addr = await resolveLID(id)
             const serialized = record.serialize()
-            // #19 — only update tombstone on first write; v2 always updated
-            const batch = await getIndex()
-            const needsTombstone = !batch[addr] || !isOldJson(batch[addr])
-            const updated = {
-                ...batch,
-                [v2Key(addr)]: serialized,
-                ...(needsTombstone ? { [addr]: { version: 'v1', _sessions: {} } } : {}),
-            }
             sessionReadCache.set(addr, toU8(serialized))
-            await setIndex(updated)
+            await keys.set({ session: { [addr]: serialized } })
         },
 
-        // #7 — proper identity verification instead of always trusting
+        // ── Identity keys ─────────────────────────────────────────────────────────
+
         isTrustedIdentity: async (id, identityKey) => {
             try {
                 const addr = await resolveLID(id)
-                const { [addr]: raw } = await keys.get('identity-key', [addr])
-                const existing = toU8(raw)
+                const { [addr]: existing } = await keys.get('identity-key', [addr])
                 if (!existing) return true
-                return !!bufEqual(existing, identityKey instanceof Uint8Array ? identityKey : toU8(identityKey))
-            } catch { return true }
+                const a = toU8(existing)
+                const b = identityKey instanceof Uint8Array ? identityKey : toU8(identityKey)
+                return !!bufEqual(a, b)
+            } catch {
+                return true
+            }
         },
 
         loadIdentityKey: async (id) => {
@@ -507,37 +394,33 @@ function signalStorage({ creds, keys }, lidMapping, logger, lidCache, sessionRea
 
         saveIdentity: async (id, identityKey) => {
             const addr = await resolveLID(id)
-            const { [addr]: raw } = await keys.get('identity-key', [addr])
-            const existing = toU8(raw)
-            if (existing && !bufEqual(existing, identityKey)) {
-                const batch = await getIndex()
-                const updated = { ...batch }
-                delete updated[addr]
-                delete updated[v2Key(addr)]
+            const { [addr]: existing } = await keys.get('identity-key', [addr])
+            const a = toU8(existing)
+            const b = identityKey instanceof Uint8Array ? identityKey : toU8(identityKey)
+            if (a && !bufEqual(a, b)) {
+                // Identity changed — wipe session and update key atomically
                 sessionReadCache.delete(addr)
-                sessionReadCache.delete('__index__')
-                await setIndex(updated)
-                await keys.set({ 'identity-key': { [addr]: identityKey } })
                 lidCache.delete(id)
+                await keys.set({
+                    session: { [addr]: null },
+                    'identity-key': { [addr]: b }
+                })
                 return true
             }
-            if (!existing) {
-                await keys.set({ 'identity-key': { [addr]: identityKey } })
+            if (!a) {
+                await keys.set({ 'identity-key': { [addr]: b } })
                 return true
             }
             return false
         },
 
-        // #11 — exposed for decryptMessage error recovery
         wipeSession: async (addr) => {
-            const batch = await getIndex()
-            const updated = { ...batch }
-            delete updated[addr]
-            delete updated[v2Key(addr)]
             sessionReadCache.delete(addr)
-            await setIndex(updated)
+            await keys.set({ session: { [addr]: null } })
         },
 
+        // ── PreKeys ───────────────────────────────────────────────────────────────
+
         loadPreKey: async (id) => {
             const { [id.toString()]: key } = await keys.get('pre-key', [id.toString()])
             if (!key) return null
@@ -549,7 +432,6 @@ function signalStorage({ creds, keys }, lidMapping, logger, lidCache, sessionRea
 
         removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
 
-        // #13 — return null on id mismatch instead of silently returning wrong key
         loadSignedPreKey: (id) => {
             const key = creds.signedPreKey
             if (key.keyId !== id) {
@@ -566,18 +448,25 @@ function signalStorage({ creds, keys }, lidMapping, logger, lidCache, sessionRea
             }
         },
 
+        // ── Sender keys ───────────────────────────────────────────────────────────
+
         loadSenderKey: async (keyId) => {
             try {
                 const id = keyId.toString()
                 const { [id]: key } = await keys.get('sender-key', [id])
-                return toBuffer(key) ?? null
-            } catch (e) { logger?.error?.(`[Signal] loadSenderKey error: ${e.message}`); return null }
+                return toU8(key) ?? null
+            } catch (e) {
+                logger?.error?.(`[Signal] loadSenderKey error: ${e.message}`)
+                return null
+            }
         },
 
         storeSenderKey: async (keyId, record) => {
             await keys.set({ 'sender-key': { [keyId.toString()]: Buffer.from(record) } })
         },
 
+        // ── Own identity ──────────────────────────────────────────────────────────
+
         getOurRegistrationId: () => creds.registrationId,
 
         getOurIdentity: () => ({