@hbmodsofc/baileys 1.7.8 → 2.2.0

package/lib/Signal/Group/queue-job.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueJob;
+const _queueAsyncBuckets = new Map();
+const _gcLimit = 10000;
+async function _asyncQueueExecutor(queue, cleanup) {
+    let offt = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const limit = Math.min(queue.length, _gcLimit);
+        for (let i = offt; i < limit; i++) {
+            const job = queue[i];
+            try {
+                job.resolve(await job.awaitable());
+            }
+            catch (e) {
+                job.reject(e);
+            }
+        }
+        if (limit < queue.length) {
+            if (limit >= _gcLimit) {
+                queue.splice(0, limit);
+                offt = 0;
+            }
+            else {
+                offt = limit;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    cleanup();
+}
+function queueJob(bucket, awaitable) {
+    // Skip name assignment since it's readonly in strict mode
+    if (typeof bucket !== 'string') {
+        console.warn('Unhandled bucket type (for naming):', typeof bucket, bucket);
+    }
+    let inactive = false;
+    if (!_queueAsyncBuckets.has(bucket)) {
+        _queueAsyncBuckets.set(bucket, []);
+        inactive = true;
+    }
+    const queue = _queueAsyncBuckets.get(bucket);
+    const job = new Promise((resolve, reject) => {
+        queue.push({
+            awaitable,
+            resolve: resolve,
+            reject
+        });
+    });
+    if (inactive) {
+        _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+    }
+    return job;
+}

package/lib/Signal/Group/sender-chain-key.d.ts

@@ -4,7 +4,7 @@ export declare class SenderChainKey {
     private readonly CHAIN_KEY_SEED;
     private readonly iteration;
     private readonly chainKey;
-    constructor(iteration: number, chainKey: Uint8Array | Buffer);
+    constructor(iteration: number, chainKey: any);
     getIteration(): number;
     getSenderMessageKey(): SenderMessageKey;
     getNext(): SenderChainKey;

package/lib/Signal/Group/sender-chain-key.js

@@ -8,18 +8,11 @@ class SenderChainKey {
         this.MESSAGE_KEY_SEED = Buffer.from([0x01]);
         this.CHAIN_KEY_SEED = Buffer.from([0x02]);
         this.iteration = iteration;
-        if (Buffer.isBuffer(chainKey)) {
+        if (chainKey instanceof Buffer) {
             this.chainKey = chainKey;
         }
-        else if (chainKey instanceof Uint8Array) {
-            this.chainKey = Buffer.from(chainKey);
-        }
-        else if (chainKey && typeof chainKey === 'object') {
-            // backported from @MartinSchere (#1741)
-            this.chainKey = Buffer.from(Object.values(chainKey)); // temp fix // backported from @MartinSchere (#1741)
-        }
         else {
-            this.chainKey = Buffer.alloc(0);
+            this.chainKey = Buffer.from(chainKey || []);
         }
     }
     getIteration() {

package/lib/Signal/Group/sender-key-distribution-message.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SenderKeyDistributionMessage = void 0;
-const index_js_1 = require("../../../WAProto/index.js");
+const WAProto_1 = require("../../../WAProto");
 const ciphertext_message_1 = require("./ciphertext-message");
 class SenderKeyDistributionMessage extends ciphertext_message_1.CiphertextMessage {
     constructor(id, iteration, chainKey, signatureKey, serialized) {
@@ -9,7 +9,7 @@ class SenderKeyDistributionMessage extends ciphertext_message_1.CiphertextMessag
         if (serialized) {
             try {
                 const message = serialized.slice(1);
-                const distributionMessage = index_js_1.proto.SenderKeyDistributionMessage.decode(message);
+                const distributionMessage = WAProto_1.proto.SenderKeyDistributionMessage.decode(message).toJSON();
                 this.serialized = serialized;
                 this.id = distributionMessage.id;
                 this.iteration = distributionMessage.iteration;
@@ -32,7 +32,7 @@ class SenderKeyDistributionMessage extends ciphertext_message_1.CiphertextMessag
             this.iteration = iteration;
             this.chainKey = chainKey;
             this.signatureKey = signatureKey;
-            const message = index_js_1.proto.SenderKeyDistributionMessage.encode(index_js_1.proto.SenderKeyDistributionMessage.create({
+            const message = WAProto_1.proto.SenderKeyDistributionMessage.encode(WAProto_1.proto.SenderKeyDistributionMessage.create({
                 id,
                 iteration,
                 chainKey,

package/lib/Signal/Group/sender-key-message.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SenderKeyMessage = void 0;
 const curve_1 = require("libsignal/src/curve");
-const index_js_1 = require("../../../WAProto/index.js");
+const WAProto_1 = require("../../../WAProto");
 const ciphertext_message_1 = require("./ciphertext-message");
 class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
     constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
@@ -12,7 +12,7 @@ class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
             const version = serialized[0];
             const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH);
             const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH);
-            const senderKeyMessage = index_js_1.proto.SenderKeyMessage.decode(message);
+            const senderKeyMessage = WAProto_1.proto.SenderKeyMessage.decode(message).toJSON();
             this.serialized = serialized;
             this.messageVersion = (version & 0xff) >> 4;
             this.keyId = senderKeyMessage.id;
@@ -26,7 +26,7 @@ class SenderKeyMessage extends ciphertext_message_1.CiphertextMessage {
         else {
             const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
             const ciphertextBuffer = Buffer.from(ciphertext);
-            const message = index_js_1.proto.SenderKeyMessage.encode(index_js_1.proto.SenderKeyMessage.create({
+            const message = WAProto_1.proto.SenderKeyMessage.encode(WAProto_1.proto.SenderKeyMessage.create({
                 id: keyId,
                 iteration: iteration,
                 ciphertext: ciphertextBuffer

package/lib/Signal/Group/sender-key-state.d.ts

@@ -21,10 +21,10 @@ interface SenderKeyStateStructure {
 export declare class SenderKeyState {
     private readonly MAX_MESSAGE_KEYS;
     private readonly senderKeyStateStructure;
-    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null | string, signatureKeyPair?: {
-        public: Uint8Array | string;
-        private: Uint8Array | string;
-    } | null, signatureKeyPublic?: Uint8Array | string | null, signatureKeyPrivate?: Uint8Array | string | null, senderKeyStateStructure?: SenderKeyStateStructure | null);
+    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null, signatureKeyPair?: {
+        public: Uint8Array;
+        private: Uint8Array;
+    } | null, signatureKeyPublic?: Uint8Array | null, signatureKeyPrivate?: Uint8Array | null, senderKeyStateStructure?: SenderKeyStateStructure | null);
     getKeyId(): number;
     getSenderChainKey(): SenderChainKey;
     setSenderChainKey(chainKey: SenderChainKey): void;

package/lib/Signal/Group/sender-key-state.js

@@ -6,22 +6,8 @@ const sender_message_key_1 = require("./sender-message-key");
 class SenderKeyState {
     constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
         this.MAX_MESSAGE_KEYS = 2000;
-        const toBuffer = (val) => {
-            if (!val)
-                return Buffer.alloc(0);
-            if (typeof val === 'string')
-                return Buffer.from(val, 'base64');
-            if (val instanceof Uint8Array || Array.isArray(val))
-                return Buffer.from(val);
-            return Buffer.alloc(0);
-        };
         if (senderKeyStateStructure) {
-            this.senderKeyStateStructure = {
-                ...senderKeyStateStructure,
-                senderMessageKeys: Array.isArray(senderKeyStateStructure.senderMessageKeys)
-                    ? senderKeyStateStructure.senderMessageKeys
-                    : []
-            };
+            this.senderKeyStateStructure = senderKeyStateStructure;
         }
         else {
             if (signatureKeyPair) {
@@ -31,12 +17,17 @@ class SenderKeyState {
             chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey;
             const senderChainKeyStructure = {
                 iteration: iteration || 0,
-                seed: chainKey ? toBuffer(chainKey) : Buffer.alloc(0)
+                seed: chainKey || Buffer.alloc(0)
             };
             const signingKeyStructure = {
-                public: toBuffer(signatureKeyPublic),
-                private: signatureKeyPrivate ? toBuffer(signatureKeyPrivate) : undefined
+                public: typeof signatureKeyPublic === 'string'
+                    ? Buffer.from(signatureKeyPublic, 'base64')
+                    : signatureKeyPublic || Buffer.alloc(0)
             };
+            if (signatureKeyPrivate) {
+                signingKeyStructure.private =
+                    typeof signatureKeyPrivate === 'string' ? Buffer.from(signatureKeyPrivate, 'base64') : signatureKeyPrivate;
+            }
             this.senderKeyStateStructure = {
                 senderKeyId: id || 0,
                 senderChainKey: senderChainKeyStructure,
@@ -58,45 +49,23 @@ class SenderKeyState {
         };
     }
     getSigningKeyPublic() {
-        let key = this.senderKeyStateStructure.senderSigningKey.public;
-        // normalize into Buffer
-        if (!Buffer.isBuffer(key)) {
-            if (key instanceof Uint8Array) {
-                key = Buffer.from(key);
-            }
-            else if (typeof key === 'string') {
-                key = Buffer.from(key, 'base64');
-            }
-            else if (key && typeof key === 'object') {
-                return Buffer.from(Object.values(key)); // temp fix // inspired by @MartinSchere 's #1741
-            }
-            else {
-                key = Buffer.from(key || []);
-            }
+        const publicKey = this.senderKeyStateStructure.senderSigningKey.public;
+        if (publicKey instanceof Buffer) {
+            return publicKey;
         }
-        const publicKey = key;
-        if (publicKey.length === 32) {
-            const fixed = Buffer.alloc(33);
-            fixed[0] = 0x05;
-            publicKey.copy(fixed, 1);
-            return fixed;
+        else if (typeof publicKey === 'string') {
+            return Buffer.from(publicKey, 'base64');
         }
-        return publicKey;
+        return Buffer.from(publicKey || []);
     }
     getSigningKeyPrivate() {
         const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
         if (!privateKey) {
             return undefined;
         }
-        if (Buffer.isBuffer(privateKey)) {
+        if (privateKey instanceof Buffer) {
             return privateKey;
         }
-        else if (privateKey instanceof Uint8Array) {
-            return Buffer.from(privateKey);
-        }
-        else if (privateKey && typeof privateKey === 'object') {
-            return Buffer.from(Object.values(privateKey)); // temp fix // inspired by @MartinSchere 's #1741
-        }
         else if (typeof privateKey === 'string') {
             return Buffer.from(privateKey, 'base64');
         }

package/lib/Signal/libsignal.d.ts

@@ -1,7 +1,3 @@
-import type { SignalAuthState } from '../Types';
-import type { SignalRepositoryWithLIDStore } from '../Types/Signal';
-export declare function makeLibSignalRepository(auth: SignalAuthState, onWhatsAppFunc?: (...jids: string[]) => Promise<{
-    jid: string;
-    exists: boolean;
-    lid: string;
-}[] | undefined>): SignalRepositoryWithLIDStore;
+import { SignalAuthState } from '../Types';
+import { SignalRepository } from '../Types/Signal';
+export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;

package/lib/Signal/libsignal.js

@@ -34,34 +34,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLibSignalRepository = makeLibSignalRepository;
-/* @ts-ignore */
 const libsignal = __importStar(require("libsignal"));
 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");
-function makeLibSignalRepository(auth, onWhatsAppFunc) {
-    const lidMapping = new lid_mapping_1.LIDMappingStore(auth.keys, onWhatsAppFunc);
-    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 = {
+function makeLibSignalRepository(auth) {
+    const storage = signalStorage(auth);
+    return {
         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);
+            return cipher.decrypt(msg);
         },
         async processSenderKeyDistributionMessage({ item, authorJid }) {
             const builder = new Group_1.GroupSessionBuilder(storage);
@@ -75,240 +60,70 @@ function makeLibSignalRepository(auth, onWhatsAppFunc) {
             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);
+            await builder.process(senderName, senderMsg);
         },
         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();
+            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}`);
             }
-            // 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);
+            return result;
         },
         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 addr = jidToSignalProtocolAddress(jid);
             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);
+            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 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);
+            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()
+            };
         },
         async injectE2ESession({ jid, session }) {
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
-            return parsedKeys.transaction(async () => {
-                await cipher.initOutgoing(session);
-            }, jid);
+            await cipher.initOutgoing(session);
         },
         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: (0, WABinary_1.transferDevice)(jid, toJid),
-                    pn: jid
-                }));
-                await lidMapping.storeLIDPNMappings(mappings);
-                // 2. Prepare migration operations
-                const migrationOps = validJids.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)
-                    };
-                });
-                // 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-${(0, 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 = (0, 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 { user, device } = (0, WABinary_1.jidDecode)(jid);
+    return new libsignal.ProtocolAddress(user, device || 0);
 };
 const jidToSignalSenderKeyName = (group, user) => {
     return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
-function signalStorage({ creds, keys }, lidMapping) {
+function signalStorage({ creds, keys }) {
     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;
+            const { [id]: sess } = await keys.get('session', [id]);
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess);
             }
-            return null;
         },
         storeSession: async (id, session) => {
             await keys.set({ session: { [id]: session.serialize() } });
@@ -352,7 +167,7 @@ function signalStorage({ creds, keys }, lidMapping) {
             const { signedIdentityKey } = creds;
             return {
                 privKey: Buffer.from(signedIdentityKey.private),
-                pubKey: Buffer.from((0, Utils_1.generateSignalPubKey)(signedIdentityKey.public))
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public)
             };
         }
     };

package/lib/Socket/Client/{types.d.ts → abstract-socket-client.d.ts}

@@ -1,6 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { EventEmitter } from 'events';
 import { URL } from 'url';
-import type { SocketConfig } from '../../Types';
+import { SocketConfig } from '../../Types';
 export declare abstract class AbstractSocketClient extends EventEmitter {
     url: URL;
     config: SocketConfig;

package/lib/Socket/Client/index.d.ts

@@ -1,2 +1,3 @@
-export * from './types';
-export * from './websocket';
+export * from './abstract-socket-client';
+export * from './mobile-socket-client';
+export * from './web-socket-client';

package/lib/Socket/Client/index.js

@@ -14,5 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./websocket"), exports);
+__exportStar(require("./abstract-socket-client"), exports);
+__exportStar(require("./mobile-socket-client"), exports);
+__exportStar(require("./web-socket-client"), exports);

package/lib/Socket/Client/mobile-socket-client.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Socket } from 'net';
+import { AbstractSocketClient } from './abstract-socket-client';
+export declare class MobileSocketClient extends AbstractSocketClient {
+    protected socket: Socket | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get isClosing(): boolean;
+    get isConnecting(): boolean;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
+}