@badzz88/baileys 8.5.6 → 8.5.8

package/{src → lib}/Signal/libsignal.js

@@ -1,81 +1,29 @@
-'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 });
-exports.makeLibSignalRepository = makeLibSignalRepository;
-const rb = require('../Utils/native-bridge').loadRustBridge();
-const lru_cache_1 = require('lru-cache');
-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 lid_mapping_1 = require('./lid-mapping');
+// @ts-ignore
+import * as libsignal from 'libsignal';
+// @ts-ignore
+import { PreKeyWhisperMessage } from 'libsignal/src/protobufs.js';
+import { LRUCache } from 'lru-cache';
+import { generateSignalPubKey } from '../Utils/index.js';
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from '../WABinary/index.js';
+import { SenderKeyName } from './Group/sender-key-name.js';
+import { SenderKeyRecord } from './Group/sender-key-record.js';
+import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage } from './Group/index.js';
+import { LIDMappingStore } from './lid-mapping.js';
+/** Extract identity key from PreKeyWhisperMessage for identity change detection */
 function extractIdentityFromPkmsg(ciphertext) {
     try {
         if (!ciphertext || ciphertext.length < 2) {
             return undefined;
         }
+        // Version byte check (version 3)
         const version = ciphertext[0];
         if ((version & 0xf) !== 3) {
             return undefined;
         }
-        const identityKeyArr = rb.getPreKeyMessageIdentityKey(ciphertext);
-        if (identityKeyArr) {
-            return identityKeyArr;
+        // Parse protobuf (skip version byte)
+        const preKeyProto = PreKeyWhisperMessage.decode(ciphertext.slice(1));
+        if (preKeyProto.identityKey?.length === 33) {
+            return new Uint8Array(preKeyProto.identityKey);
         }
         return undefined;
     }
@@ -83,50 +31,58 @@ function extractIdentityFromPkmsg(ciphertext) {
         return undefined;
     }
 }
-function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
-    if (!rb) {
-        throw new Error('The Signal session (Double Ratchet encryption) requires the "whatsapp-rust-bridge" native ' +
-            'module, which failed to load. Make sure it is installed: npm install whatsapp-rust-bridge@0.5.4');
-    }
-    const lidMapping = new lid_mapping_1.LIDMappingStore(auth.keys, logger, pnToLIDFunc);
+export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
+    const lidMapping = new LIDMappingStore(auth.keys, logger, pnToLIDFunc);
     const storage = signalStorage(auth, lidMapping);
     const parsedKeys = auth.keys;
-    const migratedSessionCache = new lru_cache_1.LRUCache({
-        ttl: 3 * 24 * 60 * 60 * 1000,
+    const migratedSessionCache = new LRUCache({
+        ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
         ttlAutopurge: true,
         updateAgeOnGet: true
     });
+    const ensureSenderKeyAndCreateSkdm = async (group, meId) => {
+        const senderName = jidToSignalSenderKeyName(group, meId);
+        const senderNameStr = senderName.toString();
+        const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+        if (!senderKey) {
+            await storage.storeSenderKey(senderName, new SenderKeyRecord());
+        }
+        const skdm = await new GroupSessionBuilder(storage).create(senderName);
+        return { senderName, skdm };
+    };
     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 rb.SessionCipher(storage, addr);
+            const session = new libsignal.SessionCipher(storage, addr);
+            // Extract and save sender's identity key before decryption for identity change detection
             if (type === 'pkmsg') {
                 const identityKey = extractIdentityFromPkmsg(ciphertext);
                 if (identityKey) {
@@ -149,13 +105,16 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
                 }
                 return result;
             }
+            // 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 }) {
             const addr = jidToSignalProtocolAddress(jid);
-            const cipher = new rb.SessionCipher(storage, addr);
+            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';
@@ -163,61 +122,61 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             }, 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()
-                };
+                const { senderName, skdm } = await ensureSenderKeyAndCreateSkdm(group, meId);
+                const ciphertext = await new GroupCipher(storage, senderName).encrypt(data);
+                return { ciphertext, senderKeyDistributionMessage: skdm.serialize() };
             }, group);
         },
-        async injectE2ESession({ jid, session }) {
-            logger.trace({ jid }, 'injecting E2EE session');
-            const cipher = new rb.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+        async getSenderKeyDistributionMessage({ group, meId }) {
             return parsedKeys.transaction(async () => {
-                await cipher.initOutgoing(session);
-            }, jid);
+                const { skdm } = await ensureSenderKeyAndCreateSkdm(group, meId);
+                return skdm.serialize();
+            }, group);
+        },
+        async hasSenderKey({ group, meId }) {
+            const senderName = jidToSignalSenderKeyName(group, meId).toString();
+            const { [senderName]: key } = await auth.keys.get('sender-key', [senderName]);
+            return !!key;
         },
         async getSessionInfo(jid) {
-            try {
-                const addr = jidToSignalProtocolAddress(jid);
-                const sessBytes = await storage.loadSession(addr.toString());
-                if (!sessBytes)
-                    return null;
-                const session = rb.SessionRecord.deserialize(sessBytes);
-                const open = session.getOpenSession?.();
-                const baseKey = open?.indexInfo?.baseKey;
-                const registrationId = open?.registrationId;
-                if (!baseKey || typeof registrationId !== 'number')
-                    return null;
-                return { baseKey: new Uint8Array(baseKey), registrationId };
+            const addr = jidToSignalProtocolAddress(jid).toString();
+            const session = (await storage.loadSession(addr));
+            if (!session) {
+                return null;
             }
-            catch (error) {
+            const open = session.getOpenSession?.();
+            const baseKey = open?.indexInfo?.baseKey;
+            const registrationId = open?.registrationId;
+            if (!baseKey || typeof registrationId !== 'number') {
                 return null;
             }
+            return { baseKey: new Uint8Array(baseKey), registrationId };
+        },
+        async injectE2ESession({ jid, session }) {
+            logger.trace({ jid }, 'injecting E2EE session');
+            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            return parsedKeys.transaction(async () => {
+                // libsignal runtime accepts an absent prekey (initOutgoing checks `device.preKey && ...`)
+                // but the bundled .d.ts marks it required.
+                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 sessBytes = await storage.loadSession(addr.toString());
-                if (!sessBytes)
+                const session = await storage.loadSession(addr.toString());
+                if (!session) {
                     return { exists: false, reason: 'no session' };
-                const session = rb.SessionRecord.deserialize(sessBytes);
-                if (!session.haveOpenSession())
+                }
+                if (!session.haveOpenSession()) {
                     return { exists: false, reason: 'no open session' };
+                }
                 return { exists: true };
             }
             catch (error) {
@@ -227,41 +186,54 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
         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`);
         },
+        close() {
+            migratedSessionCache.clear();
+            lidMapping.close();
+        },
         async migrateSession(fromJid, toJid) {
-            if (!fromJid || (!(0, WABinary_1.isLidUser)(toJid) && !(0, WABinary_1.isHostedLidUser)(toJid)))
+            // TODO: use usync to handle this entire mess
+            if (!fromJid || (!isLidUser(toJid) && !isHostedLidUser(toJid)))
                 return { migrated: 0, skipped: 0, total: 0 };
-            if (!(0, WABinary_1.isPnUser)(fromJid) && !(0, WABinary_1.isHostedPnUser)(fromJid)) {
+            // Only support PN to LID migration
+            if (!isPnUser(fromJid) && !isHostedPnUser(fromJid)) {
                 return { migrated: 0, skipped: 0, total: 1 };
             }
-            const { user } = (0, WABinary_1.jidDecode)(fromJid);
+            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 } = (0, WABinary_1.jidDecode)(fromJid);
+            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;
@@ -279,11 +251,12 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
                 devicesWithSessions: deviceJids.length,
                 devices: deviceJids
             }, 'bulk device migration complete - all user devices processed');
+            // Single transaction for all migrations
             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);
+                    const lidWithDevice = transferDevice(jid, toJid);
+                    const fromDecoded = jidDecode(jid);
+                    const toDecoded = jidDecode(lidWithDevice);
                     return {
                         fromJid: jid,
                         toJid: lidWithDevice,
@@ -296,25 +269,31 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
                 });
                 const totalOps = migrationOps.length;
                 let migratedCount = 0;
+                // 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 = {};
                 for (const op of migrationOps) {
                     const pnAddrStr = op.fromAddr.toString();
                     const lidAddrStr = op.toAddr.toString();
                     const pnSession = pnSessions[pnAddrStr];
                     if (pnSession) {
-                        const fromSession = rb.SessionRecord.deserialize(pnSession);
+                        // Session exists (guaranteed from device discovery)
+                        const fromSession = libsignal.SessionRecord.deserialize(pnSession);
                         if (fromSession.haveOpenSession()) {
+                            // Queue for bulk update: copy to LID, delete from PN
                             sessionUpdates[lidAddrStr] = fromSession.serialize();
                             sessionUpdates[pnAddrStr] = null;
                             migratedCount++;
                         }
                     }
                 }
+                // 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}`;
@@ -324,38 +303,37 @@ function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
                 }
                 const skippedCount = totalOps - migratedCount;
                 return { migrated: migratedCount, skipped: skippedCount, total: totalOps };
-            }, `migrate-${deviceJids.length}-sessions-${(0, WABinary_1.jidDecode)(toJid)?.user}`);
+            }, `migrate-${deviceJids.length}-sessions-${jidDecode(toJid)?.user}`);
         }
     };
     return repository;
 }
-const jidToSignalProtocolAddress = jid => {
-    const decoded = (0, WABinary_1.jidDecode)(jid);
+const jidToSignalProtocolAddress = (jid) => {
+    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}`);
     }
-    const signalUser = domainType !== WABinary_1.WAJIDDomains.WHATSAPP ? `${user}_${domainType}` : user;
+    const signalUser = domainType !== 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 rb.ProtocolAddress(signalUser, finalDevice);
+    return new libsignal.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 === WABinary_1.WAJIDDomains.LID ||
-                domainType === WABinary_1.WAJIDDomains.HOSTED_LID ||
-                user.includes('-'))
+            if (domainType === WAJIDDomains.LID || domainType === WAJIDDomains.HOSTED_LID)
                 return id;
-            const pnJid = `${user}${device !== '0' ? `:${device}` : ''}@${domainType === WABinary_1.WAJIDDomains.HOSTED ? 'hosted' : 's.whatsapp.net'}`;
+            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);
@@ -368,25 +346,22 @@ function signalStorage({ creds, keys }, lidMapping) {
         loadSession: async (id) => {
             try {
                 const wireJid = await resolveLIDSignalAddress(id);
-                const keysToFetch = wireJid !== id ? [wireJid, id] : [id];
-                const fetched = await keys.get('session', keysToFetch);
-                const sess = fetched[wireJid] || fetched[id];
-                if (!sess)
-                    return null;
-                if (typeof sess === 'object' && !Buffer.isBuffer(sess) && !ArrayBuffer.isView(sess) && sess._sessions) {
-                    return null;
+                const { [wireJid]: sess } = await keys.get('session', [wireJid]);
+                if (sess) {
+                    return libsignal.SessionRecord.deserialize(sess);
                 }
-                return Buffer.isBuffer(sess) ? sess : Buffer.from(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;
+            return true; // TOFU - Trust on First Use (same as WhatsApp Web)
         },
         loadIdentityKey: async (id) => {
             const wireJid = await resolveLIDSignalAddress(id);
@@ -396,10 +371,9 @@ function signalStorage({ creds, keys }, lidMapping) {
         saveIdentity: async (id, identityKey) => {
             const wireJid = await resolveLIDSignalAddress(id);
             const { [wireJid]: existingKey } = await keys.get('identity-key', [wireJid]);
-            const keysMatch = existingKey &&
-                existingKey.length === identityKey.length &&
-                existingKey.every((byte, i) => byte === identityKey[i]);
+            const keysMatch = existingKey?.length === identityKey.length && existingKey.every((byte, i) => byte === identityKey[i]);
             if (existingKey && !keysMatch) {
+                // Identity changed - clear session and update key
                 await keys.set({
                     session: { [wireJid]: null },
                     'identity-key': { [wireJid]: identityKey }
@@ -407,6 +381,7 @@ function signalStorage({ creds, keys }, lidMapping) {
                 return true;
             }
             if (!existingKey) {
+                // New contact - Trust on First Use (TOFU)
                 await keys.set({ 'identity-key': { [wireJid]: identityKey } });
                 return true;
             }
@@ -422,7 +397,7 @@ function signalStorage({ creds, keys }, lidMapping) {
                 };
             }
         },
-        removePreKey: id => keys.set({ 'pre-key': { [id]: null } }),
+        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
         loadSignedPreKey: () => {
             const key = creds.signedPreKey;
             return {
@@ -434,9 +409,9 @@ function signalStorage({ creds, keys }, lidMapping) {
             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();
@@ -448,8 +423,9 @@ function signalStorage({ creds, keys }, lidMapping) {
             const { signedIdentityKey } = creds;
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: Buffer.from((0, Utils_1.generateSignalPubKey)(signedIdentityKey.public))
+                pubKey: Buffer.from(generateSignalPubKey(signedIdentityKey.public))
             };
         }
     };
 }
+//# sourceMappingURL=libsignal.js.map

package/{src → lib}/Signal/lid-mapping.js

@@ -1,12 +1,9 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.LIDMappingStore = void 0;
-const lru_cache_1 = require('lru-cache');
-const WABinary_1 = require('../WABinary');
-class LIDMappingStore {
+import { LRUCache } from 'lru-cache';
+import { isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js';
+export class LIDMappingStore {
     constructor(keys, logger, pnToLIDFunc) {
-        this.mappingCache = new lru_cache_1.LRUCache({
-            ttl: 3 * 24 * 60 * 60 * 1000,
+        this.mappingCache = new LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
             ttlAutopurge: true,
             updateAgeOnGet: true
         });
@@ -21,13 +18,12 @@ class LIDMappingStore {
             return;
         const validatedPairs = [];
         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)))) {
+            if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && 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);
+            const lidDecoded = jidDecode(lid);
+            const pnDecoded = jidDecode(pn);
             if (!lidDecoded || !pnDecoded)
                 continue;
             validatedPairs.push({ pnUser: pnDecoded.user, lidUser: lidDecoded.user });
@@ -78,6 +74,7 @@ class LIDMappingStore {
         await this.keys.transaction(async () => {
             await this.keys.set({ 'lid-mapping': batchData });
         }, 'lid-mapping');
+        // Update cache after successful DB write
         for (const [pnUser, lidUser] of Object.entries(pairMap)) {
             this.mappingCache.set(`pn:${pnUser}`, lidUser);
             this.mappingCache.set(`lid:${lidUser}`, pnUser);
@@ -115,6 +112,7 @@ class LIDMappingStore {
                 this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
                 return false;
             }
+            // Push the PN device ID to the LID to maintain device separation
             const pnDevice = decoded.device !== undefined ? decoded.device : 0;
             const deviceSpecificLid = `${normalizedLidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`;
             this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
@@ -122,9 +120,9 @@ class LIDMappingStore {
             return true;
         };
         for (const pn of pns) {
-            if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn))
+            if (!isPnUser(pn) && !isHostedPnUser(pn))
                 continue;
-            const decoded = (0, WABinary_1.jidDecode)(pn);
+            const decoded = jidDecode(pn);
             if (!decoded)
                 continue;
             const pnUser = decoded.user;
@@ -159,8 +157,8 @@ class LIDMappingStore {
                 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)) {
+                    let normalizedPn = jidNormalizedUser(pn);
+                    if (isHostedPnUser(normalizedPn)) {
                         normalizedPn = `${pnUser}@s.whatsapp.net`;
                     }
                     if (!usyncFetch[normalizedPn]) {
@@ -173,15 +171,15 @@ class LIDMappingStore {
             }
         }
         if (Object.keys(usyncFetch).length > 0) {
-            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch)); // this function already adds LIDs to mapping
             if (result && result.length > 0) {
                 await this.storeLIDPNMappings(result);
                 for (const pair of result) {
-                    const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn);
+                    const pnDecoded = jidDecode(pair.pn);
                     const pnUser = pnDecoded?.user;
                     if (!pnUser)
                         continue;
-                    const lidUser = (0, WABinary_1.jidDecode)(pair.lid)?.user;
+                    const lidUser = jidDecode(pair.lid)?.user;
                     if (!lidUser)
                         continue;
                     for (const device of usyncFetch[pair.pn]) {
@@ -228,15 +226,15 @@ class LIDMappingStore {
                 return false;
             }
             const lidDevice = decoded.device !== undefined ? decoded.device : 0;
-            const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`;
+            const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`;
             this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
             successfulPairs[lid] = { lid, pn: pnJid };
             return true;
         };
         for (const lid of lids) {
-            if (!(0, WABinary_1.isLidUser)(lid))
+            if (!isLidUser(lid))
                 continue;
-            const decoded = (0, WABinary_1.jidDecode)(lid);
+            const decoded = jidDecode(lid);
             if (!decoded)
                 continue;
             const lidUser = decoded.user;
@@ -269,5 +267,11 @@ class LIDMappingStore {
         }
         return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null;
     }
+    /**
+     * Close the cache and release resources
+     */
+    close() {
+        this.mappingCache.clear();
+    }
 }
-exports.LIDMappingStore = LIDMappingStore;
+//# sourceMappingURL=lid-mapping.js.map

package/lib/Socket/Client/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './websocket.js';
+//# sourceMappingURL=index.js.map