@neelegirl/baileys 1.5.2 → 1.5.3

package/lib/Signal/libsignal.js

@@ -1,162 +1,391 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod
-    var result = {}
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k)
-    __setModuleDefault(result, mod)
-    return result
-}
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const libsignal = __importStar(require("@neelegirl/libsignal"))
-const WASignalGroup_1 = require("./WASignalGroup")
-const Utils_1 = require("../Utils")
-const WABinary_1 = require("../WABinary")
-
-function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth)
-    return {
-        decryptGroupMessage({ group, authorJid, msg }) {
-            const senderName = jidToSignalSenderKeyName(group, authorJid)
-            const cipher = new WASignalGroup_1.GroupCipher(storage, senderName)
-            return cipher.decrypt(msg)
-        },
-        async processSenderKeyDistributionMessage({ item, authorJid }) {
-            const builder = new WASignalGroup_1.GroupSessionBuilder(storage)
-            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid)
-            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage)
-            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
-            }
-            await builder.process(senderName, senderMsg)
-        },
-        async decryptMessage({ jid, type, ciphertext }) {
-            const addr = jidToSignalProtocolAddress(jid)
-            const session = new libsignal.SessionCipher(storage, addr)
-            let result
-            switch (type) {
-                case 'pkmsg':
-                    result = await session.decryptPreKeyWhisperMessage(ciphertext)
-                    break
-                case 'msg':
-                    result = await session.decryptWhisperMessage(ciphertext)
-                    break
-            }
-            return result
-        },
-        async encryptMessage({ jid, data }) {
-            const addr = jidToSignalProtocolAddress(jid)
-            const cipher = new libsignal.SessionCipher(storage, addr)
-            const { type: sigType, body } = await cipher.encrypt(data)
-            const type = sigType === 3 ? 'pkmsg' : 'msg'
-            return { type, ciphertext: Buffer.from(body, 'binary') }
-        },
-        async encryptGroupMessage({ group, meId, data }) {
-            const senderName = jidToSignalSenderKeyName(group, meId)
-            const builder = new WASignalGroup_1.GroupSessionBuilder(storage)
-            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName])
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord())
-            }
-            const senderKeyDistributionMessage = await builder.create(senderName)
-            const session = new WASignalGroup_1.GroupCipher(storage, senderName)
-            const ciphertext = await session.encrypt(data)
-            return {
-                ciphertext,
-                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
-            }
-        },
-        async injectE2ESession({ jid, session }) {
-            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid))
-            await cipher.initOutgoing(session)
-        },
-        jidToSignalProtocolAddress(jid) {
-            return jidToSignalProtocolAddress(jid).toString()
-        },
-    }
-}
-
-const jidToSignalProtocolAddress = (jid) => {
-    const { user, device } = WABinary_1.jidDecode(jid)
-    return new libsignal.ProtocolAddress(user, device || 0)
-}
-
-const jidToSignalSenderKeyName = (group, user) => {
-    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString()
-}
-
-function signalStorage({ creds, keys }) {
-    return {
-        loadSession: async (id) => {
-            const { [id]: sess } = await keys.get('session', [id])
-            if (sess) {
-                return libsignal.SessionRecord.deserialize(sess)
-            }
-        },
-        storeSession: async (id, session) => {
-            await keys.set({ 'session': { [id]: session.serialize() } })
-        },
-        isTrustedIdentity: () => {
-            return true
-        },
-        loadPreKey: async (id) => {
-            const keyId = id.toString()
-            const { [keyId]: key } = await keys.get('pre-key', [keyId])
-            if (key) {
-                return {
-                    privKey: Buffer.from(key.private),
-                    pubKey: Buffer.from(key.public)
-                }
-            }
-        },
-        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
-        loadSignedPreKey: () => {
-            const key = creds.signedPreKey
-            return {
-                privKey: Buffer.from(key.keyPair.private),
-                pubKey: Buffer.from(key.keyPair.public)
-            }
-        },
-        loadSenderKey: async (keyId) => {
-            const { [keyId]: key } = await keys.get('sender-key', [keyId])
-            if (key) {
-                return new WASignalGroup_1.SenderKeyRecord(key)
-            }
-        },
-        storeSenderKey: async (keyId, key) => {
-            await keys.set({ 'sender-key': { [keyId]: key.serialize() } })
-        },
-        getOurRegistrationId: () => (creds.registrationId),
-        getOurIdentity: () => {
-            const { signedIdentityKey } = creds
-            return {
-                privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: Utils_1.generateSignalPubKey(signedIdentityKey.public),
-            }
-        }
-    }
-}
-
-module.exports = {
-  makeLibSignalRepository
+"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("@neelegirl/libsignal"))
+const Utils_1 = require("../Utils")
+const WABinary_1 = require("../WABinary")
+const sender_key_name_1 = require("./WASignalGroup/sender-key-name")
+const sender_key_record_1 = require("./WASignalGroup/sender-key-record")
+const Group_1 = require("./WASignalGroup")
+const LIDMappingStore_1 = require("./lid-mapping") 
+
+function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
+	const lidMapping = new LIDMappingStore_1.LIDMappingStore(auth.keys, onWhatsAppFunc, logger)
+    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 repository = {
+        decryptGroupMessage({ group, authorJid, msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid)
+            const cipher = new Group_1.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)
+            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 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())
+            }
+            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 builder.process(senderName, senderMsg)
+            }, item.groupId)
+        },
+        async decryptMessage({ jid, type, ciphertext }) {
+            const addr = jidToSignalProtocolAddress(jid)
+            const session = new libsignal.SessionCipher(storage, addr)
+            async function doDecrypt() {
+                let result
+                switch (type) {
+                    case 'pkmsg':
+                        result = await session.decryptPreKeyWhisperMessage(ciphertext)
+                        break
+                    case 'msg':
+                        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)
+            // 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 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())
+                }
+                const senderKeyDistributionMessage = await builder.create(senderName)
+                const session = new Group_1.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))
+            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
+            
+            // Convert JIDs to signal addresses and prepare for bulk deletion
+            const sessionUpdates = {}
+            
+            jids.forEach(jid => {
+                const addr = jidToSignalProtocolAddress(jid)
+                sessionUpdates[addr.toString()] = null
+            })
+            
+            // Single transaction for all deletions
+            return parsedKeys.transaction(async () => {
+                await auth.keys.set({ session: sessionUpdates })
+            }, `delete-${jids.length}-sessions`)
+        },
+        async migrateSession(fromJids, toJid) {
+            if (!fromJids.length || !toJid.includes('@lid'))
+                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
+            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)
+                    
+                    return {
+                        fromJid: jid,
+                        toJid: lidWithDevice,
+                        pnUser: fromDecoded.user,
+                        lidUser: toDecoded.user,
+                        deviceId: fromDecoded.device || 0,
+                        fromAddr: jidToSignalProtocolAddress(jid),
+                        toAddr: jidToSignalProtocolAddress(lidWithDevice)
+                    }
+                })
+                
+                // 3. Batch check which LID sessions already exist
+                const lidAddrs = migrationOps.map(op => op.toAddr.toString())
+                const existingSessions = await auth.keys.get('session', lidAddrs)
+                
+                // 4. Filter out sessions that already have LID sessions
+                const opsToMigrate = migrationOps.filter(op => !existingSessions[op.toAddr.toString()])
+                const skippedCount = migrationOps.length - opsToMigrate.length
+                
+                if (!opsToMigrate.length) {
+                    return { migrated: 0, skipped: skippedCount, total: validJids.length };
+                }
+                
+                // 5. Execute all migrations in parallel
+                await Promise.all(opsToMigrate.map(async (op) => {
+                    const fromSession = await storage.loadSession(op.fromAddr.toString())
+                    
+                    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)
+                        
+                        // Delete PN session
+                        await auth.keys.set({ session: { [op.fromAddr.toString()]: null } })
+                    }
+                }))
+                
+                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 }
+        }
+    }
+    return repository
+}
+
+const jidToSignalProtocolAddress = (jid) => {
+    const decoded = WABinary_1.jidDecode(jid)
+    const { user, device, server } = 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 finalDevice = device || 0
+    
+    return new libsignal.ProtocolAddress(signalUser, finalDevice)
+}
+
+const jidToSignalSenderKeyName = (group, user) => {
+    return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user))
+}
+
+function signalStorage({ creds, keys }, lidMapping) {
+    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])
+                if (sess) {
+                    return libsignal.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() } })
+        },
+        isTrustedIdentity: () => {
+            return true
+        },
+        loadPreKey: async (id) => {
+            const keyId = id.toString()
+            const { [keyId]: key } = await keys.get('pre-key', [keyId])
+            if (key) {
+                return {
+                    privKey: Buffer.from(key.private),
+                    pubKey: Buffer.from(key.public)
+                }
+            }
+        },
+        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+        loadSignedPreKey: () => {
+            const key = creds.signedPreKey
+            return {
+                privKey: Buffer.from(key.keyPair.private),
+                pubKey: Buffer.from(key.keyPair.public)
+            }
+        },
+        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 new sender_key_record_1.SenderKeyRecord()
+        },
+        storeSenderKey: async (senderKeyName, key) => {
+            const keyId = senderKeyName.toString()
+            const serialized = JSON.stringify(key.serialize())
+            await keys.set({ 'sender-key': { [keyId]: Buffer.from(serialized, 'utf-8') } })
+        },
+        getOurRegistrationId: () => creds.registrationId,
+        getOurIdentity: () => {
+            const { signedIdentityKey } = creds
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: Buffer.from(Utils_1.generateSignalPubKey(signedIdentityKey.public)) 
+            }
+        }
+    }
+}
+
+module.exports = {
+  makeLibSignalRepository
 }

package/lib/Signal/lid-mapping.d.ts

@@ -0,0 +1,28 @@
+import { ILogger } from '@neelegirl/baileys/lib/Utils/loggerr'
+import { SignalKeyStoreWithTransaction } from '@neelegirl/baileys/lib/Types'
+
+export declare class LIDMappingStore {
+    private readonly mappingCache
+    private readonly keys
+    private onWhatsAppFunc?
+    constructor(keys: SignalKeyStoreWithTransaction, onWhatsAppFunc?: (...jids: string[], logger: ILogger ) => Promise<{
+        jid: string
+        exists: boolean
+        lid: string
+    }[] | undefined>)
+    /**
+     * Store LID-PN mapping - USER LEVEL
+     */
+    storeLIDPNMappings(pairs: {
+        lid: string;
+        pn: string;
+    }[]): Promise<void>
+    /**
+     * Get LID for PN - Returns device-specific LID based on user mapping
+     */
+    getLIDForPN(pn: string): Promise<string | null>
+    /**
+     * Get PN for LID - USER LEVEL with device construction
+     */
+    getPNForLID(lid: string): Promise<string | null>
+}