@hbmodsofc/baileys 1.5.0 → 1.7.6

package/lib/Signal/libsignal.js

@@ -34,19 +34,34 @@ 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");
-function makeLibSignalRepository(auth) {
-    const storage = signalStorage(auth);
-    return {
+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 = {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
             const cipher = new Group_1.GroupCipher(storage, senderName);
-            return cipher.decrypt(msg);
+            // 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);
@@ -60,70 +75,240 @@ function makeLibSignalRepository(auth) {
             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;
+            }
+            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();
             }
-            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);
+            // LID SINGLE SOURCE OF TRUTH: Always prefer LID when available
+            let encryptionJid = jid;
+            // Check for LID mapping and use it if session exists
+            if (jid.includes('@s.whatsapp.net')) {
+                const lidForPN = await lidMapping.getLIDForPN(jid);
+                if (lidForPN?.includes('@lid')) {
+                    const lidAddr = jidToSignalProtocolAddress(lidForPN);
+                    const { [lidAddr.toString()]: lidSession } = await auth.keys.get('session', [lidAddr.toString()]);
+                    if (lidSession) {
+                        // LID session exists, use it
+                        encryptionJid = lidForPN;
+                    }
+                    else {
+                        // Try to migrate if PN session exists
+                        const pnAddr = jidToSignalProtocolAddress(jid);
+                        const { [pnAddr.toString()]: pnSession } = await auth.keys.get('session', [pnAddr.toString()]);
+                        if (pnSession) {
+                            // Migrate PN to LID
+                            await repository.migrateSession([jid], lidForPN);
+                            encryptionJid = lidForPN;
+                        }
+                    }
+                }
+            }
+            const addr = jidToSignalProtocolAddress(encryptionJid);
             const cipher = new libsignal.SessionCipher(storage, addr);
-            const { type: sigType, body } = await cipher.encrypt(data);
-            const type = sigType === 3 ? 'pkmsg' : 'msg';
-            return { type, ciphertext: Buffer.from(body, 'binary') };
+            // Use transaction to ensure atomicity
+            return parsedKeys.transaction(async () => {
+                const { type: sigType, body } = await cipher.encrypt(data);
+                const type = sigType === 3 ? 'pkmsg' : 'msg';
+                return { type, ciphertext: Buffer.from(body, 'binary') };
+            }, jid);
         },
         async encryptGroupMessage({ group, meId, data }) {
             const senderName = jidToSignalSenderKeyName(group, meId);
             const builder = new Group_1.GroupSessionBuilder(storage);
             const senderNameStr = senderName.toString();
-            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 }) {
             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();
+        },
+        // 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 { 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 } = decoded;
+    if (!user) {
+        throw new Error(`JID decoded but user is empty: "${jid}" -> user: "${user}", server: "${server}", device: ${device}`);
+    }
+    // LID addresses get _1 suffix for Signal protocol
+    const signalUser = server === 'lid' ? `${user}_1` : user;
+    const finalDevice = device || 0;
+    return new libsignal.ProtocolAddress(signalUser, finalDevice);
 };
 const jidToSignalSenderKeyName = (group, user) => {
     return new sender_key_name_1.SenderKeyName(group, jidToSignalProtocolAddress(user));
 };
-function signalStorage({ creds, keys }) {
+function signalStorage({ creds, keys }, lidMapping) {
     return {
         loadSession: async (id) => {
-            const { [id]: sess } = await keys.get('session', [id]);
-            if (sess) {
-                return libsignal.SessionRecord.deserialize(sess);
+            try {
+                // LID SINGLE SOURCE OF TRUTH: Auto-redirect PN to LID if mapping exists
+                let actualId = id;
+                if (id.includes('.') && !id.includes('_1')) {
+                    // This is a PN signal address format (e.g., "1234567890.0")
+                    // Convert back to JID to check for LID mapping
+                    const parts = id.split('.');
+                    const device = parts[1] || '0';
+                    const pnJid = device === '0' ? `${parts[0]}@s.whatsapp.net` : `${parts[0]}:${device}@s.whatsapp.net`;
+                    const lidForPN = await lidMapping.getLIDForPN(pnJid);
+                    if (lidForPN?.includes('@lid')) {
+                        const lidAddr = jidToSignalProtocolAddress(lidForPN);
+                        const lidId = lidAddr.toString();
+                        // Check if LID session exists
+                        const { [lidId]: lidSession } = await keys.get('session', [lidId]);
+                        if (lidSession) {
+                            actualId = lidId;
+                        }
+                    }
+                }
+                const { [actualId]: sess } = await keys.get('session', [actualId]);
+                if (sess) {
+                    return libsignal.SessionRecord.deserialize(sess);
+                }
+            }
+            catch (e) {
+                return null;
             }
+            return null;
         },
         storeSession: async (id, session) => {
             await keys.set({ session: { [id]: session.serialize() } });
@@ -167,7 +352,7 @@ function signalStorage({ creds, keys }) {
             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.d.ts

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

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIDMappingStore = void 0;
+const lru_cache_1 = require("lru-cache");
+const logger_1 = __importDefault(require("../Utils/logger"));
+const WABinary_1 = require("../WABinary");
+class LIDMappingStore {
+    constructor(keys, onWhatsAppFunc) {
+        this.mappingCache = new lru_cache_1.LRUCache({
+            ttl: 7 * 24 * 60 * 60 * 1000, // 7 days
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        });
+        this.keys = keys;
+        this.onWhatsAppFunc = onWhatsAppFunc; // needed to get LID from PN if not found
+    }
+    /**
+     * Store LID-PN mapping - USER LEVEL
+     */
+    async storeLIDPNMappings(pairs) {
+        // Validate inputs
+        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)))) {
+                logger_1.default.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                continue;
+            }
+            const [lidJid, pnJid] = (0, WABinary_1.isLidUser)(lid) ? [lid, pn] : [pn, lid];
+            const lidDecoded = (0, WABinary_1.jidDecode)(lidJid);
+            const pnDecoded = (0, WABinary_1.jidDecode)(pnJid);
+            if (!lidDecoded || !pnDecoded)
+                return;
+            const pnUser = pnDecoded.user;
+            const lidUser = lidDecoded.user;
+            // Check if mapping already exists (cache first, then database)
+            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!existingLidUser) {
+                // Cache miss - check database
+                const stored = await this.keys.get('lid-mapping', [pnUser]);
+                existingLidUser = stored[pnUser];
+                if (existingLidUser) {
+                    // Update cache with database value
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                }
+            }
+            if (existingLidUser === lidUser) {
+                logger_1.default.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping');
+                continue;
+            }
+            pairMap[pnUser] = lidUser;
+        }
+        logger_1.default.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, // "554396160286" -> "102765716062358"
+                        [`${lidUser}_reverse`]: pnUser // "102765716062358_reverse" -> "554396160286"
+                    }
+                });
+                // Update cache with both directions
+                this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                this.mappingCache.set(`lid:${lidUser}`, pnUser);
+            }
+        }, 'lid-mapping');
+    }
+    /**
+     * Get LID for PN - Returns device-specific LID based on user mapping
+     */
+    async getLIDForPN(pn) {
+        if (!(0, WABinary_1.isPnUser)(pn))
+            return null;
+        const decoded = (0, WABinary_1.jidDecode)(pn);
+        if (!decoded)
+            return null;
+        // Check cache first for PN → LID mapping
+        const pnUser = decoded.user;
+        let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+        if (!lidUser) {
+            // Cache miss - check database
+            const stored = await this.keys.get('lid-mapping', [pnUser]);
+            lidUser = stored[pnUser];
+            if (lidUser) {
+                // Cache the database result
+                this.mappingCache.set(`pn:${pnUser}`, lidUser);
+            }
+            else {
+                // Not in database - try USync
+                logger_1.default.trace(`No LID mapping found for PN user ${pnUser}; getting from USync`);
+                const { exists, lid } = (await this.onWhatsAppFunc?.(pn))?.[0]; // this function already adds LIDs to mapping
+                if (exists && lid) {
+                    lidUser = (0, WABinary_1.jidDecode)(lid)?.user;
+                    if (lidUser) {
+                        // Cache the USync result
+                        this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    }
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        if (typeof lidUser !== 'string' || !lidUser) {
+            logger_1.default.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+            return null;
+        }
+        // Push the PN device ID to the LID to maintain device separation
+        const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+        const deviceSpecificLid = `${lidUser}:${pnDevice}@lid`;
+        logger_1.default.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
+        return deviceSpecificLid;
+    }
+    /**
+     * Get PN for LID - USER LEVEL with device construction
+     */
+    async getPNForLID(lid) {
+        if (!(0, WABinary_1.isLidUser)(lid))
+            return null;
+        const decoded = (0, WABinary_1.jidDecode)(lid);
+        if (!decoded)
+            return null;
+        // Check cache first for LID → PN mapping
+        const lidUser = decoded.user;
+        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+        if (!pnUser || typeof pnUser !== 'string') {
+            // Cache miss - check database
+            const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`]);
+            pnUser = stored[`${lidUser}_reverse`];
+            if (!pnUser || typeof pnUser !== 'string') {
+                logger_1.default.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                return null;
+            }
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        }
+        // Construct device-specific PN JID
+        const lidDevice = decoded.device !== undefined ? decoded.device : 0;
+        const pnJid = `${pnUser}:${lidDevice}@s.whatsapp.net`;
+        logger_1.default.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        return pnJid;
+    }
+}
+exports.LIDMappingStore = LIDMappingStore;

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

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

package/lib/Socket/Client/index.js

@@ -14,6 +14,5 @@ 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("./abstract-socket-client"), exports);
-__exportStar(require("./mobile-socket-client"), exports);
-__exportStar(require("./web-socket-client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./websocket"), exports);

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

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

package/lib/Socket/Client/{web-socket-client.d.ts → websocket.d.ts}

@@ -1,5 +1,5 @@
 import WebSocket from 'ws';
-import { AbstractSocketClient } from './abstract-socket-client';
+import { AbstractSocketClient } from './types';
 export declare class WebSocketClient extends AbstractSocketClient {
     protected socket: WebSocket | null;
     get isOpen(): boolean;

package/lib/Socket/Client/{web-socket-client.js → websocket.js}

@@ -6,44 +6,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const Defaults_1 = require("../../Defaults");
-const abstract_socket_client_1 = require("./abstract-socket-client");
-class WebSocketClient extends abstract_socket_client_1.AbstractSocketClient {
+const types_1 = require("./types");
+class WebSocketClient extends types_1.AbstractSocketClient {
     constructor() {
         super(...arguments);
         this.socket = null;
     }
     get isOpen() {
-        var _a;
-        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN;
+        return this.socket?.readyState === ws_1.default.OPEN;
     }
     get isClosed() {
-        var _a;
-        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSED;
+        return this.socket === null || this.socket?.readyState === ws_1.default.CLOSED;
     }
     get isClosing() {
-        var _a;
-        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CLOSING;
+        return this.socket === null || this.socket?.readyState === ws_1.default.CLOSING;
     }
     get isConnecting() {
-        var _a;
-        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.CONNECTING;
+        return this.socket?.readyState === ws_1.default.CONNECTING;
     }
     async connect() {
-        var _a, _b;
         if (this.socket) {
             return;
         }
         this.socket = new ws_1.default(this.url, {
             origin: Defaults_1.DEFAULT_ORIGIN,
-            headers: (_a = this.config.options) === null || _a === void 0 ? void 0 : _a.headers,
+            headers: this.config.options?.headers,
             handshakeTimeout: this.config.connectTimeoutMs,
             timeout: this.config.connectTimeoutMs,
-            agent: this.config.agent,
+            agent: this.config.agent
         });
         this.socket.setMaxListeners(0);
         const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
         for (const event of events) {
-            (_b = this.socket) === null || _b === void 0 ? void 0 : _b.on(event, (...args) => this.emit(event, ...args));
+            this.socket?.on(event, (...args) => this.emit(event, ...args));
         }
     }
     async close() {
@@ -54,8 +49,7 @@ class WebSocketClient extends abstract_socket_client_1.AbstractSocketClient {
         this.socket = null;
     }
     send(str, cb) {
-        var _a;
-        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(str, cb);
+        this.socket?.send(str, cb);
         return Boolean(this.socket);
     }
 }