@hansaka02/baileys 7.3.2 → 7.3.6

package/lib/Signal/libsignal.js

@@ -1,99 +1,88 @@
 "use strict"
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    var desc = Object.getOwnPropertyDescriptor(m, k)
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k] } }
-    }
-    Object.defineProperty(o, k2, desc)
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    o[k2] = m[k]
-}))
-
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v })
-}) : function(o, v) {
-    o["default"] = v
-})
-
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = []
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
-            return ar
-        }
-        return ownKeys(o)
-    }
-    return function (mod) {
-        if (mod && mod.__esModule) return mod
-        var result = {}
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i])
-        __setModuleDefault(result, mod)
-        return result
-    }
-})()
-
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const libsignal = __importStar(require("@itsukichan/libsignal-node"))
-const Utils_1 = require("../Utils")
-const WABinary_1 = require("../WABinary")
-const sender_key_name_1 = require("./Group/sender-key-name")
-const sender_key_record_1 = require("./Group/sender-key-record")
-const Group_1 = require("./Group")
-const LIDMappingStore_1 = require("./lid-mapping") 
+const {
+  SessionCipher, 
+  SessionBuilder, 
+  SessionRecord, 
+  ProtocolAddress
+} = require("@itsukichan/libsignal-node")
+const { generateSignalPubKey } = require("../Utils")
+const { 
+  isHostedLidUser, 
+  isHostedPnUser, 
+  isLidUser, 
+  isPnUser, 
+  jidDecode, 
+  transferDevice, 
+  WAJIDDomains 
+} = require("../WABinary")
+const { SenderKeyName } = require("./Group/sender-key-name")
+const { SenderKeyRecord } = require("./Group/sender-key-record")
+const {
+  GroupCipher, 
+  GroupSessionBuilder, 
+  SenderKeyDistributionMessage
+} = require("./Group")
+const { LRUCache } = require("lru-cache")
+const { LIDMappingStore } = require("./lid-mapping") 
 
-function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
-	const lidMapping = new LIDMappingStore_1.LIDMappingStore(auth.keys, onWhatsAppFunc, logger)
+function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    const lidMapping = new LIDMappingStore(auth.keys, logger, pnToLIDFunc)
     const storage = signalStorage(auth, lidMapping)
     const parsedKeys = auth.keys
-    
-    function isLikelySyncMessage(addr) {
-        const key = addr.toString()
-        // Only bypass for WhatsApp system addresses, not regular user contacts
-        // Be very specific about sync service patterns
-        return (key.includes('@lid.whatsapp.net') || // WhatsApp system messages
-            key.includes('@broadcast') || // Broadcast messages
-            key.includes('@newsletter'))
-    }
+    const migratedSessionCache = new LRUCache({
+        ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    })
     
     const repository = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid)
-            const cipher = new Group_1.GroupCipher(storage, senderName)
+            const cipher = new GroupCipher(storage, senderName)
+            
             // Use transaction to ensure atomicity
             return parsedKeys.transaction(async () => {
                 return cipher.decrypt(msg)
             }, group)
         },
+        
         async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new Group_1.GroupSessionBuilder(storage)
+            const builder = new GroupSessionBuilder(storage)
+            
             if (!item.groupId) {
                 throw new Error('Group ID is required for sender key distribution message')
             }
+            
             const senderName = jidToSignalSenderKeyName(item.groupId, authorJid)
-            const senderMsg = new Group_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
+            const senderMsg = new SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
             const senderNameStr = senderName.toString()
             const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
+            
             if (!senderKey) {
-                await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
+                await storage.storeSenderKey(senderName, new SenderKeyRecord())
             }
+            
             return parsedKeys.transaction(async () => {
                 const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
+                
                 if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
+                    await storage.storeSenderKey(senderName, new SenderKeyRecord())
                 }
+                
                 await builder.process(senderName, senderMsg)
             }, item.groupId)
         },
+        
         async decryptMessage({ jid, type, ciphertext }) {
             const addr = jidToSignalProtocolAddress(jid)
-            const session = new libsignal.SessionCipher(storage, addr)
+            const session = new SessionCipher(storage, addr)
+            
             async function doDecrypt() {
                 let result
+                
                 switch (type) {
                     case 'pkmsg':
                         result = await session.decryptPreKeyWhisperMessage(ciphertext)
@@ -102,98 +91,91 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
                         result = await session.decryptWhisperMessage(ciphertext)
                         break
                 }
+                
                 return result
             }
-            if (isLikelySyncMessage(addr)) {
-                // If it's a sync message, we can skip the transaction
-                // as it is likely to be a system message that doesn't require strict atomicity
-                return await doDecrypt()
-            }
+            
             // If it's not a sync message, we need to ensure atomicity
             // For regular messages, we use a transaction to ensure atomicity
             return parsedKeys.transaction(async () => {
                 return await doDecrypt()
             }, jid)
         },
+        
         async encryptMessage({ jid, data }) {
-            // LID SINGLE SOURCE OF TRUTH: Always prefer LID when available
-            let encryptionJid = jid
-            // Check for LID mapping and use it if session exists
-            if (jid.includes('@s.whatsapp.net')) {
-                const lidForPN = await lidMapping.getLIDForPN(jid)
-                if (lidForPN?.includes('@lid')) {
-                    const lidAddr = jidToSignalProtocolAddress(lidForPN)
-                    const { [lidAddr.toString()]: lidSession } = await auth.keys.get('session', [lidAddr.toString()])
-                    if (lidSession) {
-                        // LID session exists, use it
-                        encryptionJid = lidForPN
-                    }
-                    else {
-                        // Try to migrate if PN session exists
-                        const pnAddr = jidToSignalProtocolAddress(jid)
-                        const { [pnAddr.toString()]: pnSession } = await auth.keys.get('session', [pnAddr.toString()])
-                        if (pnSession) {
-                            // Migrate PN to LID
-                            await repository.migrateSession([jid], lidForPN)
-                            encryptionJid = lidForPN
-                        }
-                    }
-                }
-            }
-            const addr = jidToSignalProtocolAddress(encryptionJid)
-            const cipher = new libsignal.SessionCipher(storage, addr)
+            const addr = jidToSignalProtocolAddress(jid)
+            const cipher = new SessionCipher(storage, addr)
+            
             // Use transaction to ensure atomicity
             return parsedKeys.transaction(async () => {
                 const { type: sigType, body } = await cipher.encrypt(data)
                 const type = sigType === 3 ? 'pkmsg' : 'msg'
+                
                 return { type, ciphertext: Buffer.from(body, 'binary') }
             }, jid)
         },
+        
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId)
-            const builder = new Group_1.GroupSessionBuilder(storage)
+            const builder = new GroupSessionBuilder(storage)
             const senderNameStr = senderName.toString()
+            
             return parsedKeys.transaction(async () => {
                 const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr])
+                
                 if (!senderKey) {
-                    await storage.storeSenderKey(senderName, new sender_key_record_1.SenderKeyRecord())
+                    await storage.storeSenderKey(senderName, new SenderKeyRecord())
                 }
+                
                 const senderKeyDistributionMessage = await builder.create(senderName)
-                const session = new Group_1.GroupCipher(storage, senderName)
+                const session = new GroupCipher(storage, senderName)
                 const ciphertext = await session.encrypt(data)
+                
                 return {
                     ciphertext,
                     senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
                 }
             }, group)
-        }, 
+        },
+        
         async injectE2ESession({ jid, session }) {
-            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid))
+            logger.trace({ jid }, 'injecting E2EE session')
+            
+            const cipher = new SessionBuilder(storage, jidToSignalProtocolAddress(jid))
+            
             return parsedKeys.transaction(async () => {
                 await cipher.initOutgoing(session)
             }, jid)
         },
+        
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString()
         },
+        
         // Optimized direct access to LID mapping store
         lidMapping,
+        
         async validateSession(jid) {
             try {
                 const addr = jidToSignalProtocolAddress(jid)
                 const session = await storage.loadSession(addr.toString())
+                
                 if (!session) {
                     return { exists: false, reason: 'no session' }
                 }
+                
                 if (!session.haveOpenSession()) {
                     return { exists: false, reason: 'no open session' }
                 }
+                
                 return { exists: true }
             }
+            
             catch (error) {
                 return { exists: false, reason: 'validation error' }
             }
         },
+        
         async deleteSession(jids) {
             if (!jids.length) return
             
@@ -210,31 +192,81 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
                 await auth.keys.set({ session: sessionUpdates })
             }, `delete-${jids.length}-sessions`)
         },
-        async migrateSession(fromJids, toJid) {
-            if (!fromJids.length || !toJid.includes('@lid'))
+        
+        async migrateSession(fromJid, toJid) {
+            // TODO: use usync to handle this entire mess
+            if (!fromJid || (!isLidUser(toJid) && !isHostedLidUser(toJid))) {
                 return { migrated: 0, skipped: 0, total: 0 }
-                
-            // Filter valid PN JIDs
-            const validJids = fromJids.filter(jid => jid.includes('@s.whatsapp.net'))
+            }
             
-            if (!validJids.length)
-                return { migrated: 0, skipped: 0, total: fromJids.length }
-                
-            // Single optimized transaction for all migrations
+            // Only support PN to LID migration
+            if (!isPnUser(fromJid) && !isHostedPnUser(fromJid)) {
+                return { migrated: 0, skipped: 0, total: 1 }
+            }
+            
+            const { user } = jidDecode(fromJid)
+            
+            logger.debug({ fromJid }, 'bulk device migration - loading all user devices')
+            
+            // Get user's device list from storage
+            const { [user]: userDevices } = await parsedKeys.get('device-list', [user])
+            
+            if (!userDevices) {
+                return { migrated: 0, skipped: 0, total: 0 }
+            }
+            
+            const { device: fromDevice } = jidDecode(fromJid)
+            const fromDeviceStr = fromDevice?.toString() || '0'
+            
+            if (!userDevices.includes(fromDeviceStr)) {
+                userDevices.push(fromDeviceStr)
+            }
+            
+            // Filter out cached devices before database fetch
+            const uncachedDevices = userDevices.filter(device => {
+                const deviceKey = `${user}.${device}`
+                return !migratedSessionCache.has(deviceKey)
+            })
+            
+            // Bulk check session existence only for uncached devices
+            const deviceSessionKeys = uncachedDevices.map(device => `${user}.${device}`)
+            const existingSessions = await parsedKeys.get('session', deviceSessionKeys)
+            
+            // Step 3: Convert existing sessions to JIDs (only migrate sessions that exist)
+            const deviceJids = []
+            
+            for (const [sessionKey, sessionData] of Object.entries(existingSessions)) {
+                if (sessionData) {
+                    // Session exists in storage
+                    const deviceStr = sessionKey.split('.')[1]
+                    
+                    if (!deviceStr) continue
+                    
+                    const deviceNum = parseInt(deviceStr)
+                    
+                    let jid = deviceNum === 0 ? `${user}@s.whatsapp.net` : `${user}:${deviceNum}@s.whatsapp.net`
+                    
+                    if (deviceNum === 99) {
+                        jid = `${user}:99@hosted`
+                    }
+                    
+                    deviceJids.push(jid)
+                }
+            }
+            
+            logger.debug({
+                fromJid,
+                totalDevices: userDevices.length,
+                devicesWithSessions: deviceJids.length,
+                devices: deviceJids
+            }, 'bulk device migration complete - all user devices processed')
+            
+            // Single transaction for all migrations
             return parsedKeys.transaction(async () => {
-                // 1. Batch store all LID mappings
-                const mappings = validJids.map(jid => ({
-                    lid: WABinary_1.transferDevice(jid, toJid),
-                    pn: jid
-                }))
-                
-                await lidMapping.storeLIDPNMappings(mappings)
-                
-                // 2. Prepare migration operations
-                const migrationOps = validJids.map(jid => {
-                    const lidWithDevice = WABinary_1.transferDevice(jid, toJid)
-                    const fromDecoded = WABinary_1.jidDecode(jid)
-                    const toDecoded = WABinary_1.jidDecode(lidWithDevice)
+                const migrationOps = deviceJids.map(jid => {
+                    const lidWithDevice = transferDevice(jid, toJid)
+                    const fromDecoded = jidDecode(jid)
+                    const toDecoded = jidDecode(lidWithDevice)
                     
                     return {
                         fromJid: jid,
@@ -247,106 +279,132 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
                     }
                 })
                 
-                // 3. Batch check which LID sessions already exist
-                const lidAddrs = migrationOps.map(op => op.toAddr.toString())
-                const existingSessions = await auth.keys.get('session', lidAddrs)
+                const totalOps = migrationOps.length
                 
-                // 4. Filter out sessions that already have LID sessions
-                const opsToMigrate = migrationOps.filter(op => !existingSessions[op.toAddr.toString()])
-                const skippedCount = migrationOps.length - opsToMigrate.length
+                let migratedCount = 0
                 
-                if (!opsToMigrate.length) {
-                    return { migrated: 0, skipped: skippedCount, total: validJids.length };
-                }
+                // Bulk fetch PN sessions - already exist (verified during device discovery)
+                const pnAddrStrings = Array.from(new Set(migrationOps.map(op => op.fromAddr.toString())))
+                const pnSessions = await parsedKeys.get('session', pnAddrStrings)
+                
+                // Prepare bulk session updates (PN → LID migration + deletion)
+                const sessionUpdates = {}
                 
-                // 5. Execute all migrations in parallel
-                await Promise.all(opsToMigrate.map(async (op) => {
-                    const fromSession = await storage.loadSession(op.fromAddr.toString())
+                for (const op of migrationOps) {
+                    const pnAddrStr = op.fromAddr.toString()
+                    const lidAddrStr = op.toAddr.toString()
+                    const pnSession = pnSessions[pnAddrStr]
                     
-                    if (fromSession?.haveOpenSession()) {
-                        // Copy session to LID address
-                        const sessionBytes = fromSession.serialize()
-                        const copiedSession = libsignal.SessionRecord.deserialize(sessionBytes)
-                        await storage.storeSession(op.toAddr.toString(), copiedSession)
+                    if (pnSession) {
+                        // Session exists (guaranteed from device discovery)
+                        const fromSession = SessionRecord.deserialize(pnSession)
                         
-                        // Delete PN session
-                        await auth.keys.set({ session: { [op.fromAddr.toString()]: null } })
+                        if (fromSession.haveOpenSession()) {
+                            // Queue for bulk update: copy to LID, delete from PN
+                            sessionUpdates[lidAddrStr] = fromSession.serialize()
+                            sessionUpdates[pnAddrStr] = null
+                            migratedCount++
+                        }
                     }
-                }))
+                }
                 
-                return { migrated: opsToMigrate.length, skipped: skippedCount, total: validJids.length }
-            }, `migrate-${validJids.length}-sessions-${WABinary_1.jidDecode(toJid)?.user}`)
-        },
-        async encryptMessageWithWire({ encryptionJid, wireJid, data }) {
-            const result = await repository.encryptMessage({ jid: encryptionJid, data })
-            return { ...result, wireJid }
+                // Single bulk session update for all migrations
+                if (Object.keys(sessionUpdates).length > 0) {
+                    await parsedKeys.set({ session: sessionUpdates })
+                    
+                    logger.debug({ migratedSessions: migratedCount }, 'bulk session migration complete')
+                    
+                    // Cache device-level migrations
+                    for (const op of migrationOps) {
+                        if (sessionUpdates[op.toAddr.toString()]) {
+                            const deviceKey = `${op.pnUser}.${op.deviceId}`
+                            migratedSessionCache.set(deviceKey, true)
+                        }
+                    }
+                }
+                
+                const skippedCount = totalOps - migratedCount
+                
+                return { migrated: migratedCount, skipped: skippedCount, total: totalOps }
+            }, `migrate-${deviceJids.length}-sessions-${jidDecode(toJid)?.user}`)
         }
     }
+    
     return repository
 }
 
 const jidToSignalProtocolAddress = (jid) => {
-    const decoded = WABinary_1.jidDecode(jid)
-    const { user, device, server } = decoded
+    const decoded = jidDecode(jid)
+    const { user, device, server, domainType } = decoded
     
     if (!user) {
         throw new Error(`JID decoded but user is empty: "${jid}" -> user: "${user}", server: "${server}", device: ${device}`)
     }
     
-    // LID addresses get _1 suffix for Signal protocol
-    const signalUser = server === 'lid' ? `${user}_1` : user
+    const signalUser = domainType !== WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user
     const finalDevice = device || 0
     
-    return new libsignal.ProtocolAddress(signalUser, finalDevice)
+    if (device === 99 && decoded.server !== 'hosted' && decoded.server !== 'hosted.lid') {
+        throw new Error('Unexpected non-hosted device JID with device 99. This ID seems invalid. ID:' + jid)
+    }
+    
+    return new ProtocolAddress(signalUser, finalDevice)
 }
 
 const jidToSignalSenderKeyName = (group, user) => {
-    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user))
+    return new SenderKeyName(group, jidToSignalProtocolAddress(user))
 }
 
 function signalStorage({ creds, keys }, lidMapping) {
+    // Shared function to resolve PN signal address to LID if mapping exists
+    const resolveLIDSignalAddress = async (id) => {
+        if (id.includes('.')) {
+            const [deviceId, device] = id.split('.')
+            const [user, domainType_] = deviceId.split('_')
+            const domainType = parseInt(domainType_ || '0')
+            
+            if (domainType === WAJIDDomains.LID || domainType === WAJIDDomains.HOSTED_LID) return id
+            
+            const pnJid = `${user}${device !== '0' ? `:${device}` : ''}@${domainType === WAJIDDomains.HOSTED ? 'hosted' : 's.whatsapp.net'}`
+            const lidForPN = await lidMapping.getLIDForPN(pnJid)
+            
+            if (lidForPN) {
+                const lidAddr = jidToSignalProtocolAddress(lidForPN)
+                return lidAddr.toString()
+            }
+        }
+        
+        return id
+    }
+    
     return {
         loadSession: async (id) => {
             try {
-                // LID SINGLE SOURCE OF TRUTH: Auto-redirect PN to LID if mapping exists
-                let actualId = id
-                if (id.includes('.') && !id.includes('_1')) {
-                    // This is a PN signal address format (e.g., "1234567890.0")
-                    // Convert back to JID to check for LID mapping
-                    const parts = id.split('.')
-                    const device = parts[1] || '0'
-                    const pnJid = device === '0' ? `${parts[0]}@s.whatsapp.net` : `${parts[0]}:${device}@s.whatsapp.net`
-                    const lidForPN = await lidMapping.getLIDForPN(pnJid)
-                    if (lidForPN?.includes('@lid')) {
-                        const lidAddr = jidToSignalProtocolAddress(lidForPN)
-                        const lidId = lidAddr.toString()
-                        // Check if LID session exists
-                        const { [lidId]: lidSession } = await keys.get('session', [lidId])
-                        if (lidSession) {
-                            actualId = lidId
-                        }
-                    }
-                }
-                const { [actualId]: sess } = await keys.get('session', [actualId])
+                const wireJid = await resolveLIDSignalAddress(id)
+                const { [wireJid]: sess } = await keys.get('session', [wireJid])
+                
                 if (sess) {
-                    return libsignal.SessionRecord.deserialize(sess)
+                    return SessionRecord.deserialize(sess)
                 }
             }
+            
             catch (e) {
                 return null
             }
+            
             return null
         },
-        // TODO: Replace with libsignal.SessionRecord when type exports are added to libsignal
         storeSession: async (id, session) => {
-            await keys.set({ session: { [id]: session.serialize() } })
+            const wireJid = await resolveLIDSignalAddress(id)
+            await keys.set({ session: { [wireJid]: session.serialize() } })
         },
         isTrustedIdentity: () => {
-            return true
+            return true // todo: implement
         },
         loadPreKey: async (id) => {
             const keyId = id.toString()
             const { [keyId]: key } = await keys.get('pre-key', [keyId])
+            
             if (key) {
                 return {
                     privKey: Buffer.from(key.private),
@@ -365,10 +423,12 @@ function signalStorage({ creds, keys }, lidMapping) {
         loadSenderKey: async (senderKeyName) => {
             const keyId = senderKeyName.toString()
             const { [keyId]: key } = await keys.get('sender-key', [keyId])
+            
             if (key) {
-                return sender_key_record_1.SenderKeyRecord.deserialize(key)
+                return SenderKeyRecord.deserialize(key)
             }
-            return new sender_key_record_1.SenderKeyRecord()
+            
+            return new SenderKeyRecord()
         },
         storeSenderKey: async (senderKeyName, key) => {
             const keyId = senderKeyName.toString()
@@ -380,7 +440,7 @@ function signalStorage({ creds, keys }, lidMapping) {
             const { signedIdentityKey } = creds
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: Buffer.from(Utils_1.generateSignalPubKey(signedIdentityKey.public)) 
+                pubKey: Buffer.from(generateSignalPubKey(signedIdentityKey.public))
             }
         }
     }