@ellxz24/baileys 2.0.28 → 2.0.29

package/lib/Signal/libsignal.js

@@ -46,7 +46,7 @@ const lid_mapping_1 = require("./lid-mapping");
 const lru_cache_1 = require("lru-cache");
 
 function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
-    const lidMapping = new lid_mapping_1.LIDMappingStore(auth.keys, logger, pnToLIDFunc);
+    const lidMapping = lid_mapping_1.makeLIDMappingStore(auth.keys, logger, pnToLIDFunc);
     const storage = signalStorage(auth, lidMapping);
     const parsedKeys = auth.keys;
     const migratedSessionCache = new lru_cache_1.LRUCache({

package/lib/Signal/libsignal.js.bak

@@ -32,108 +32,290 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLibSignalRepository = makeLibSignalRepository;
+
 const libsignal = __importStar(require("libsignal"));
 const Utils_1 = require("../Utils");
 const WABinary_1 = require("../WABinary");
+const Group_1 = require("./Group");
 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");
-function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth);
-    return {
+const lid_mapping_1 = require("./lid-mapping");
+const lru_cache_1 = require("lru-cache");
+
+function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    const lidMapping = new lid_mapping_1.LIDMappingStore(auth.keys, logger, pnToLIDFunc);
+    const storage = signalStorage(auth, lidMapping);
+    const parsedKeys = auth.keys;
+    const migratedSessionCache = new lru_cache_1.LRUCache({
+        ttl: 7 * 24 * 60 * 60 * 1000,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
+
+    const repository = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
-            return cipher.decrypt(msg);
+            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');
+                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());
-            }
-            await builder.process(senderName, senderMsg);
+            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);
-            let result;
-            switch (type) {
-                case 'pkmsg':
-                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
-                    break;
-                case 'msg':
-                    result = await session.decryptWhisperMessage(ciphertext);
-                    break;
-                default:
-                    throw new Error(`Unknown message type: ${type}`);
+            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;
             }
-            return result;
+            return parsedKeys.transaction(async () => {
+                return await doDecrypt();
+            }, jid);
         },
         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') };
+            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();
-            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()
-            };
+            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 }) {
+            logger.trace({ jid }, "injecting E2EE session");
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            await cipher.initOutgoing(session);
+            return parsedKeys.transaction(async () => {
+                await cipher.initOutgoing(session);
+            }, jid);
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
+        },
+        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;
+            const sessionUpdates = {};
+            jids.forEach(jid => {
+                const addr = jidToSignalProtocolAddress(jid);
+                sessionUpdates[addr.toString()] = null;
+            });
+            return parsedKeys.transaction(async () => {
+                await auth.keys.set({ session: sessionUpdates });
+            }, `delete-${jids.length}-sessions`);
+        },
+        async migrateSession(fromJid, toJid) {
+            if (!fromJid || (!(0, WABinary_1.isLidUser)(toJid) && !(0, WABinary_1.isHostedLidUser)(toJid)))
+                return { migrated: 0, skipped: 0, total: 0 };
+            if (!(0, WABinary_1.isPnUser)(fromJid) && !(0, WABinary_1.isHostedPnUser)(fromJid)) {
+                return { migrated: 0, skipped: 0, total: 1 };
+            }
+            const { user } = (0, WABinary_1.jidDecode)(fromJid);
+            logger.debug({ fromJid }, "bulk device migration - loading all user devices");
+            const { [user]: userDevices } = await parsedKeys.get("device-list", [user]);
+            if (!userDevices) {
+                return { migrated: 0, skipped: 0, total: 0 };
+            }
+            const { device: fromDevice } = (0, WABinary_1.jidDecode)(fromJid);
+            const fromDeviceStr = fromDevice?.toString() || "0";
+            if (!userDevices.includes(fromDeviceStr)) {
+                userDevices.push(fromDeviceStr);
+            }
+            const uncachedDevices = userDevices.filter(device => {
+                const deviceKey = `${user}.${device}`;
+                return !migratedSessionCache.has(deviceKey);
+            });
+            const deviceSessionKeys = uncachedDevices.map(device => `${user}.${device}`);
+            const existingSessions = await parsedKeys.get("session", deviceSessionKeys);
+            const deviceJids = [];
+            for (const [sessionKey, sessionData] of Object.entries(existingSessions)) {
+                if (sessionData) {
+                    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");
+
+            return parsedKeys.transaction(async () => {
+                const migrationOps = deviceJids.map(jid => {
+                    const lidWithDevice = (0, WABinary_1.transferDevice)(jid, toJid);
+                    const fromDecoded = (0, WABinary_1.jidDecode)(jid);
+                    const toDecoded = (0, 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)
+                    };
+                });
+                const totalOps = migrationOps.length;
+                let migratedCount = 0;
+                const pnAddrStrings = Array.from(new Set(migrationOps.map(op => op.fromAddr.toString())));
+                const pnSessions = await parsedKeys.get("session", pnAddrStrings);
+                const sessionUpdates = {};
+                for (const op of migrationOps) {
+                    const pnAddrStr = op.fromAddr.toString();
+                    const lidAddrStr = op.toAddr.toString();
+                    const pnSession = pnSessions[pnAddrStr];
+                    if (pnSession) {
+                        const fromSession = libsignal.SessionRecord.deserialize(pnSession);
+                        if (fromSession.haveOpenSession()) {
+                            sessionUpdates[lidAddrStr] = fromSession.serialize();
+                            sessionUpdates[pnAddrStr] = null;
+                            migratedCount++;
+                        }
+                    }
+                }
+                if (Object.keys(sessionUpdates).length > 0) {
+                    await parsedKeys.set({ session: sessionUpdates });
+                    logger.debug({ migratedSessions: migratedCount }, "bulk session migration complete");
+                    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-${(0, WABinary_1.jidDecode)(toJid)?.user}`);
         }
     };
+    return repository;
 }
+
 const jidToSignalProtocolAddress = (jid) => {
-    const { user, device } = (0, WABinary_1.jidDecode)(jid);
-    return new libsignal.ProtocolAddress(user, device || 0);
+    const decoded = (0, WABinary_1.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}`);
+    }
+    const signalUser = domainType !== WABinary_1.WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user;
+    const finalDevice = device || 0;
+    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 libsignal.ProtocolAddress(signalUser, finalDevice);
 };
+
 const jidToSignalSenderKeyName = (group, user) => {
     return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
-function signalStorage({ creds, keys }) {
+
+function signalStorage({ creds, keys }, lidMapping) {
+    const resolveLIDSignalAddress = async (id) => {
+        if (id.includes(".")) {
+            const [deviceId, device] = id.split(".");
+            const [user, domainType_] = deviceId.split("_");
+            const domainType = parseInt(domainType_ || "0");
+            if (domainType === WABinary_1.WAJIDDomains.LID || domainType === WABinary_1.WAJIDDomains.HOSTED_LID)
+                return id;
+            const pnJid = `${user}${device !== "0" ? `:${device}` : ""}@${domainType === WABinary_1.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) => {
-            const { [id]: sess } = await keys.get('session', [id]);
-            if (sess) {
-                return libsignal.SessionRecord.deserialize(sess);
+            try {
+                const wireJid = await resolveLIDSignalAddress(id);
+                const { [wireJid]: sess } = await keys.get("session", [wireJid]);
+                if (sess) {
+                    return libsignal.SessionRecord.deserialize(sess);
+                }
+            } catch (e) {
+                return null;
             }
+            return null;
         },
         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;
         },
         loadPreKey: async (id) => {
             const keyId = id.toString();
-            const { [keyId]: key } = await keys.get('pre-key', [keyId]);
+            const { [keyId]: key } = await keys.get("pre-key", [keyId]);
             if (key) {
                 return {
                     privKey: Buffer.from(key.private),
@@ -141,7 +323,7 @@ function signalStorage({ creds, keys }) {
                 };
             }
         },
-        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+        removePreKey: (id) => keys.set({ "pre-key": { [id]: null } }),
         loadSignedPreKey: () => {
             const key = creds.signedPreKey;
             return {
@@ -151,7 +333,7 @@ function signalStorage({ creds, keys }) {
         },
         loadSenderKey: async (senderKeyName) => {
             const keyId = senderKeyName.toString();
-            const { [keyId]: key } = await keys.get('sender-key', [keyId]);
+            const { [keyId]: key } = await keys.get("sender-key", [keyId]);
             if (key) {
                 return sender_key_record_1.SenderKeyRecord.deserialize(key);
             }
@@ -160,14 +342,14 @@ function signalStorage({ creds, keys }) {
         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') } });
+            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: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
+                pubKey: Buffer.from((0, Utils_1.generateSignalPubKey)(signedIdentityKey.public))
             };
         }
     };

package/lib/Signal/lid-mapping.js

@@ -1,73 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIDMappingStore = void 0;
+exports.makeLIDMappingStore = void 0;
 
 const WABinary_1 = require("../WABinary");
 const lru_cache_1 = require("lru-cache");
 
-class LIDMappingStore {
-    constructor(keys, logger, pnToLIDFunc) {
-        this.mappingCache = new lru_cache_1.LRUCache({
-            ttl: 7 * 24 * 60 * 60 * 1000,
-            ttlAutopurge: true,
-            updateAgeOnGet: true
-        });
-        this.keys = keys;
-        this.pnToLIDFunc = pnToLIDFunc;
-        this.logger = logger;
-    }
+const makeLIDMappingStore = (keys, logger, pnToLIDFunc) => {
+    const mappingCache = new lru_cache_1.LRUCache({
+        ttl: 7 * 24 * 60 * 60 * 1000,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
 
-    async storeLIDPNMappings(pairs) {
+    const storeLIDPNMappings = async (pairs) => {
         const pairMap = {};
         for (const { lid, pn } of pairs) {
             if (!(((0, WABinary_1.isLidUser)(lid) && (0, WABinary_1.isPnUser)(pn)) || ((0, WABinary_1.isPnUser)(lid) && (0, WABinary_1.isLidUser)(pn)))) {
-                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                logger && logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
                 continue;
             }
             const lidDecoded = (0, WABinary_1.jidDecode)(lid);
             const pnDecoded = (0, WABinary_1.jidDecode)(pn);
-            if (!lidDecoded || !pnDecoded) return;
+            if (!lidDecoded || !pnDecoded) continue;
             const pnUser = pnDecoded.user;
             const lidUser = lidDecoded.user;
             
-            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+            let existingLidUser = mappingCache.get(`pn:${pnUser}`);
             if (!existingLidUser) {
-                this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
-                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                logger && logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
+                const stored = await keys.get("lid-mapping", [pnUser]);
                 existingLidUser = stored[pnUser];
                 if (existingLidUser) {
-                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
-                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                    mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    mappingCache.set(`lid:${existingLidUser}`, pnUser);
                 }
             }
             if (existingLidUser === lidUser) {
-                this.logger.debug({ pnUser, lidUser }, "LID mapping already exists, skipping");
+                logger && logger.debug({ pnUser, lidUser }, "LID mapping already exists, skipping");
                 continue;
             }
             pairMap[pnUser] = lidUser;
         }
         
-        this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
-        await this.keys.transaction(async () => {
+        logger && logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
+        await keys.transaction(async () => {
             for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-                await this.keys.set({
+                await keys.set({
                     "lid-mapping": {
                         [pnUser]: lidUser,
                         [`${lidUser}_reverse`]: pnUser
                     }
                 });
-                this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                mappingCache.set(`pn:${pnUser}`, lidUser);
+                mappingCache.set(`lid:${lidUser}`, pnUser);
             }
         }, "lid-mapping");
-    }
+    };
 
-    async getLIDForPN(pn) {
-        const result = await this.getLIDsForPNs([pn]);
-        return result?.[0]?.lid || null;
-    }
-
-    async getLIDsForPNs(pns) {
+    const getLIDsForPNs = async (pns) => {
         const usyncFetch = {};
         const successfulPairs = {};
         
@@ -77,15 +67,15 @@ class LIDMappingStore {
             if (!decoded) continue;
             const pnUser = decoded.user;
             
-            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+            let lidUser = mappingCache.get(`pn:${pnUser}`);
             if (!lidUser) {
-                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                const stored = await keys.get("lid-mapping", [pnUser]);
                 lidUser = stored[pnUser];
                 if (lidUser) {
-                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                    mappingCache.set(`pn:${pnUser}`, lidUser);
+                    mappingCache.set(`lid:${lidUser}`, pnUser);
                 } else {
-                    this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
+                    logger && logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
                     const device = decoded.device || 0;
                     let normalizedPn = (0, WABinary_1.jidNormalizedUser)(pn);
                     if ((0, WABinary_1.isHostedPnUser)(normalizedPn)) {
@@ -102,19 +92,19 @@ class LIDMappingStore {
             
             lidUser = lidUser.toString();
             if (!lidUser) {
-                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+                logger && logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
                 return null;
             }
             const pnDevice = decoded.device !== undefined ? decoded.device : 0;
             const deviceSpecificLid = `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === "hosted" ? "hosted.lid" : "lid"}`;
-            this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
+            logger && logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
             successfulPairs[pn] = { lid: deviceSpecificLid, pn };
         }
         
         if (Object.keys(usyncFetch).length > 0) {
-            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+            const result = await pnToLIDFunc?.(Object.keys(usyncFetch));
             if (result && result.length > 0) {
-                this.storeLIDPNMappings(result);
+                await storeLIDPNMappings(result);
                 for (const pair of result) {
                     const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn);
                     const pnUser = pnDecoded?.user;
@@ -124,7 +114,7 @@ class LIDMappingStore {
                     
                     for (const device of usyncFetch[pair.pn]) {
                         const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted.lid" : "lid"}`;
-                        this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`);
+                        logger && logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`);
                         const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted" : "s.whatsapp.net"}`;
                         successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
                     }
@@ -134,30 +124,43 @@ class LIDMappingStore {
             }
         }
         return Object.values(successfulPairs);
-    }
+    };
 
-    async getPNForLID(lid) {
+    const getLIDForPN = async (pn) => {
+        const result = await getLIDsForPNs([pn]);
+        return result?.[0]?.lid || null;
+    };
+
+    const getPNForLID = async (lid) => {
         if (!(0, WABinary_1.isLidUser)(lid)) return null;
         const decoded = (0, WABinary_1.jidDecode)(lid);
         if (!decoded) return null;
         
         const lidUser = decoded.user;
-        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+        let pnUser = mappingCache.get(`lid:${lidUser}`);
         
         if (!pnUser || typeof pnUser !== "string") {
-            const stored = await this.keys.get("lid-mapping", [`${lidUser}_reverse`]);
+            const stored = await keys.get("lid-mapping", [`${lidUser}_reverse`]);
             pnUser = stored[`${lidUser}_reverse`];
             if (!pnUser || typeof pnUser !== "string") {
-                this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                logger && logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
                 return null;
             }
-            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+            mappingCache.set(`lid:${lidUser}`, pnUser);
         }
         
         const lidDevice = decoded.device !== undefined ? decoded.device : 0;
         const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? "hosted" : "s.whatsapp.net"}`;
-        this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        logger && logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
         return pnJid;
-    }
-}
-exports.LIDMappingStore = LIDMappingStore;
+    };
+
+    return {
+        mappingCache,
+        storeLIDPNMappings,
+        getLIDForPN,
+        getLIDsForPNs,
+        getPNForLID
+    };
+};
+exports.makeLIDMappingStore = makeLIDMappingStore;

package/lib/Signal/lid-mapping.js.bak

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIDMappingStore = void 0;
+
+const WABinary_1 = require("../WABinary");
+const lru_cache_1 = require("lru-cache");
+
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new lru_cache_1.LRUCache({
+            ttl: 7 * 24 * 60 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        });
+        this.keys = keys;
+        this.pnToLIDFunc = pnToLIDFunc;
+        this.logger = logger;
+    }
+
+    async storeLIDPNMappings(pairs) {
+        const pairMap = {};
+        for (const { lid, pn } of pairs) {
+            if (!(((0, WABinary_1.isLidUser)(lid) && (0, WABinary_1.isPnUser)(pn)) || ((0, WABinary_1.isPnUser)(lid) && (0, WABinary_1.isLidUser)(pn)))) {
+                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                continue;
+            }
+            const lidDecoded = (0, WABinary_1.jidDecode)(lid);
+            const pnDecoded = (0, WABinary_1.jidDecode)(pn);
+            if (!lidDecoded || !pnDecoded) return;
+            const pnUser = pnDecoded.user;
+            const lidUser = lidDecoded.user;
+            
+            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!existingLidUser) {
+                this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
+                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                existingLidUser = stored[pnUser];
+                if (existingLidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                }
+            }
+            if (existingLidUser === lidUser) {
+                this.logger.debug({ pnUser, lidUser }, "LID mapping already exists, skipping");
+                continue;
+            }
+            pairMap[pnUser] = lidUser;
+        }
+        
+        this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
+        await this.keys.transaction(async () => {
+            for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+                await this.keys.set({
+                    "lid-mapping": {
+                        [pnUser]: lidUser,
+                        [`${lidUser}_reverse`]: pnUser
+                    }
+                });
+                this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                this.mappingCache.set(`lid:${lidUser}`, pnUser);
+            }
+        }, "lid-mapping");
+    }
+
+    async getLIDForPN(pn) {
+        const result = await this.getLIDsForPNs([pn]);
+        return result?.[0]?.lid || null;
+    }
+
+    async getLIDsForPNs(pns) {
+        const usyncFetch = {};
+        const successfulPairs = {};
+        
+        for (const pn of pns) {
+            if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) continue;
+            const decoded = (0, WABinary_1.jidDecode)(pn);
+            if (!decoded) continue;
+            const pnUser = decoded.user;
+            
+            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!lidUser) {
+                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                lidUser = stored[pnUser];
+                if (lidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                } else {
+                    this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
+                    const device = decoded.device || 0;
+                    let normalizedPn = (0, WABinary_1.jidNormalizedUser)(pn);
+                    if ((0, WABinary_1.isHostedPnUser)(normalizedPn)) {
+                        normalizedPn = `${pnUser}@s.whatsapp.net`;
+                    }
+                    if (!usyncFetch[normalizedPn]) {
+                        usyncFetch[normalizedPn] = [device];
+                    } else {
+                        usyncFetch[normalizedPn]?.push(device);
+                    }
+                    continue;
+                }
+            }
+            
+            lidUser = lidUser.toString();
+            if (!lidUser) {
+                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+                return null;
+            }
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+            const deviceSpecificLid = `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === "hosted" ? "hosted.lid" : "lid"}`;
+            this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn };
+        }
+        
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+            if (result && result.length > 0) {
+                this.storeLIDPNMappings(result);
+                for (const pair of result) {
+                    const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn);
+                    const pnUser = pnDecoded?.user;
+                    if (!pnUser) continue;
+                    const lidUser = (0, WABinary_1.jidDecode)(pair.lid)?.user;
+                    if (!lidUser) continue;
+                    
+                    for (const device of usyncFetch[pair.pn]) {
+                        const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted.lid" : "lid"}`;
+                        this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`);
+                        const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted" : "s.whatsapp.net"}`;
+                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
+                    }
+                }
+            } else {
+                return null;
+            }
+        }
+        return Object.values(successfulPairs);
+    }
+
+    async getPNForLID(lid) {
+        if (!(0, WABinary_1.isLidUser)(lid)) return null;
+        const decoded = (0, WABinary_1.jidDecode)(lid);
+        if (!decoded) return null;
+        
+        const lidUser = decoded.user;
+        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+        
+        if (!pnUser || typeof pnUser !== "string") {
+            const stored = await this.keys.get("lid-mapping", [`${lidUser}_reverse`]);
+            pnUser = stored[`${lidUser}_reverse`];
+            if (!pnUser || typeof pnUser !== "string") {
+                this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                return null;
+            }
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        }
+        
+        const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+        const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? "hosted" : "s.whatsapp.net"}`;
+        this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        return pnJid;
+    }
+}
+exports.LIDMappingStore = LIDMappingStore;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ellxz24/baileys",
-    "version": "2.0.28",
+    "version": "2.0.29",
     "description": "WhatsApp API Modification By L",
     "publishConfig": {
         "access": "public"