@queenanya/baileys 7.3.7 → 7.4.1

package/WASignalGroup/sender_key_state.js

@@ -0,0 +1,129 @@
+const SenderChainKey = require('./sender_chain_key');
+const SenderMessageKey = require('./sender_message_key');
+
+const protobufs = require('./protobufs');
+
+class SenderKeyState {
+    MAX_MESSAGE_KEYS = 2000;
+
+    constructor(
+        id = null,
+        iteration = null,
+        chainKey = null,
+        signatureKeyPair = null,
+        signatureKeyPublic = null,
+        signatureKeyPrivate = null,
+        senderKeyStateStructure = null
+    ) {
+        if (senderKeyStateStructure) {
+            this.senderKeyStateStructure = senderKeyStateStructure;
+        } else {
+            if (signatureKeyPair) {
+                signatureKeyPublic = signatureKeyPair.public;
+                signatureKeyPrivate = signatureKeyPair.private;
+            }
+
+            chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey;
+            this.senderKeyStateStructure = protobufs.SenderKeyStateStructure.create();
+            const senderChainKeyStructure = protobufs.SenderChainKey.create();
+            senderChainKeyStructure.iteration = iteration;
+            senderChainKeyStructure.seed = chainKey;
+            this.senderKeyStateStructure.senderChainKey = senderChainKeyStructure;
+
+            const signingKeyStructure = protobufs.SenderSigningKey.create();
+            signingKeyStructure.public =
+                typeof signatureKeyPublic === 'string' ?
+                Buffer.from(signatureKeyPublic, 'base64') :
+                signatureKeyPublic;
+            if (signatureKeyPrivate) {
+                signingKeyStructure.private =
+                    typeof signatureKeyPrivate === 'string' ?
+                    Buffer.from(signatureKeyPrivate, 'base64') :
+                    signatureKeyPrivate;
+            }
+            this.senderKeyStateStructure.senderKeyId = id;
+            this.senderChainKey = senderChainKeyStructure;
+            this.senderKeyStateStructure.senderSigningKey = signingKeyStructure;
+        }
+        this.senderKeyStateStructure.senderMessageKeys =
+            this.senderKeyStateStructure.senderMessageKeys || [];
+    }
+
+    SenderKeyState(senderKeyStateStructure) {
+        this.senderKeyStateStructure = senderKeyStateStructure;
+    }
+
+    getKeyId() {
+        return this.senderKeyStateStructure.senderKeyId;
+    }
+
+    getSenderChainKey() {
+        return new SenderChainKey(
+            this.senderKeyStateStructure.senderChainKey.iteration,
+            this.senderKeyStateStructure.senderChainKey.seed
+        );
+    }
+
+    setSenderChainKey(chainKey) {
+        const senderChainKeyStructure = protobufs.SenderChainKey.create({
+            iteration: chainKey.getIteration(),
+            seed: chainKey.getSeed(),
+        });
+        this.senderKeyStateStructure.senderChainKey = senderChainKeyStructure;
+    }
+
+    getSigningKeyPublic() {
+        return typeof this.senderKeyStateStructure.senderSigningKey.public === 'string' ?
+            Buffer.from(this.senderKeyStateStructure.senderSigningKey.public, 'base64') :
+            this.senderKeyStateStructure.senderSigningKey.public;
+    }
+
+    getSigningKeyPrivate() {
+        return typeof this.senderKeyStateStructure.senderSigningKey.private === 'string' ?
+            Buffer.from(this.senderKeyStateStructure.senderSigningKey.private, 'base64') :
+            this.senderKeyStateStructure.senderSigningKey.private;
+    }
+
+    hasSenderMessageKey(iteration) {
+        const list = this.senderKeyStateStructure.senderMessageKeys;
+        for (let o = 0; o < list.length; o++) {
+            const senderMessageKey = list[o];
+            if (senderMessageKey.iteration === iteration) return true;
+        }
+        return false;
+    }
+
+    addSenderMessageKey(senderMessageKey) {
+        const senderMessageKeyStructure = protobufs.SenderKeyStateStructure.create({
+            iteration: senderMessageKey.getIteration(),
+            seed: senderMessageKey.getSeed(),
+        });
+        this.senderKeyStateStructure.senderMessageKeys.push(senderMessageKeyStructure);
+
+        if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
+            this.senderKeyStateStructure.senderMessageKeys.shift();
+        }
+    }
+
+    removeSenderMessageKey(iteration) {
+        let result = null;
+
+        this.senderKeyStateStructure.senderMessageKeys = this.senderKeyStateStructure.senderMessageKeys.filter(
+            senderMessageKey => {
+                if (senderMessageKey.iteration === iteration) result = senderMessageKey;
+                return senderMessageKey.iteration !== iteration;
+            }
+        );
+
+        if (result != null) {
+            return new SenderMessageKey(result.iteration, result.seed);
+        }
+        return null;
+    }
+
+    getStructure() {
+        return this.senderKeyStateStructure;
+    }
+}
+
+module.exports = SenderKeyState;

package/WASignalGroup/sender_message_key.js

@@ -0,0 +1,39 @@
+const { deriveSecrets } = require('libsignal/src/crypto');
+class SenderMessageKey {
+    iteration = 0;
+
+    iv = Buffer.alloc(0);
+
+    cipherKey = Buffer.alloc(0);
+
+    seed = Buffer.alloc(0);
+
+    constructor(iteration, seed) {
+        const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
+        const keys = new Uint8Array(32);
+        keys.set(new Uint8Array(derivative[0].slice(16)));
+        keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
+        this.iv = Buffer.from(derivative[0].slice(0, 16));
+        this.cipherKey = Buffer.from(keys.buffer);
+
+        this.iteration = iteration;
+        this.seed = seed;
+    }
+
+    getIteration() {
+        return this.iteration;
+    }
+
+    getIv() {
+        return this.iv;
+    }
+
+    getCipherKey() {
+        return this.cipherKey;
+    }
+
+    getSeed() {
+        return this.seed;
+    }
+}
+module.exports = SenderMessageKey;

package/lib/Defaults/baileys-version.json

@@ -0,0 +1,3 @@
+{
+    "version": [2, 3000, 1017531287]
+}

package/lib/Defaults/index.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { proto } from '../../WAProto';
+import type { MediaType, SocketConfig } from '../Types';
+export declare const UNAUTHORIZED_CODES: number[];
+export declare const DEFAULT_ORIGIN = "https://web.whatsapp.com";
+export declare const DEF_CALLBACK_PREFIX = "CB:";
+export declare const DEF_TAG_PREFIX = "TAG:";
+export declare const PHONE_CONNECTION_CB = "CB:Pong";
+export declare const WA_DEFAULT_EPHEMERAL: number;
+export declare const NOISE_MODE = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+export declare const DICT_VERSION = 2;
+export declare const KEY_BUNDLE_TYPE: Buffer;
+export declare const NOISE_WA_HEADER: Buffer;
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+export declare const URL_REGEX: RegExp;
+export declare const WA_CERT_DETAILS: {
+    SERIAL: number;
+};
+export declare const PROCESSABLE_HISTORY_TYPES: proto.Message.HistorySyncNotification.HistorySyncType[];
+export declare const DEFAULT_CONNECTION_CONFIG: SocketConfig;
+export declare const MEDIA_PATH_MAP: {
+    [T in MediaType]?: string;
+};
+export declare const MEDIA_HKDF_KEY_MAPPING: {
+    audio: string;
+    document: string;
+    gif: string;
+    image: string;
+    ppic: string;
+    product: string;
+    ptt: string;
+    sticker: string;
+    video: string;
+    'thumbnail-document': string;
+    'thumbnail-image': string;
+    'thumbnail-video': string;
+    'thumbnail-link': string;
+    'md-msg-hist': string;
+    'md-app-state': string;
+    'product-catalog-image': string;
+    'payment-bg-image': string;
+    ptv: string;
+};
+export declare const MEDIA_KEYS: ("ppic" | "product" | "image" | "video" | "sticker" | "audio" | "gif" | "ptt" | "thumbnail-document" | "thumbnail-image" | "thumbnail-link" | "thumbnail-video" | "md-app-state" | "md-msg-hist" | "document" | "product-catalog-image" | "payment-bg-image" | "ptv")[];
+export declare const MIN_PREKEY_COUNT = 5;
+export declare const INITIAL_PREKEY_COUNT = 30;
+export declare const DEFAULT_CACHE_TTLS: {
+    SIGNAL_STORE: number;
+    MSG_RETRY: number;
+    CALL_OFFER: number;
+    USER_DEVICES: number;
+};

package/lib/Defaults/index.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CACHE_TTLS = exports.INITIAL_PREKEY_COUNT = exports.MIN_PREKEY_COUNT = exports.MEDIA_KEYS = exports.MEDIA_HKDF_KEY_MAPPING = exports.MEDIA_PATH_MAP = exports.DEFAULT_CONNECTION_CONFIG = exports.PROCESSABLE_HISTORY_TYPES = exports.WA_CERT_DETAILS = exports.URL_REGEX = exports.NOISE_WA_HEADER = exports.KEY_BUNDLE_TYPE = exports.DICT_VERSION = exports.NOISE_MODE = exports.WA_DEFAULT_EPHEMERAL = exports.PHONE_CONNECTION_CB = exports.DEF_TAG_PREFIX = exports.DEF_CALLBACK_PREFIX = exports.DEFAULT_ORIGIN = exports.UNAUTHORIZED_CODES = void 0;
+const WAProto_1 = require("../../WAProto");
+const libsignal_1 = require("../Signal/libsignal");
+const Utils_1 = require("../Utils");
+const logger_1 = __importDefault(require("../Utils/logger"));
+const baileys_version_json_1 = require("./baileys-version.json");
+exports.UNAUTHORIZED_CODES = [401, 403, 419];
+exports.DEFAULT_ORIGIN = 'https://web.whatsapp.com';
+exports.DEF_CALLBACK_PREFIX = 'CB:';
+exports.DEF_TAG_PREFIX = 'TAG:';
+exports.PHONE_CONNECTION_CB = 'CB:Pong';
+exports.WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+exports.NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
+exports.DICT_VERSION = 2;
+exports.KEY_BUNDLE_TYPE = Buffer.from([5]);
+exports.NOISE_WA_HEADER = Buffer.from([87, 65, 6, exports.DICT_VERSION]); // last is "DICT_VERSION"
+/** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
+exports.URL_REGEX = /(http(s)?:\/\/.)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/;
+exports.WA_CERT_DETAILS = {
+    SERIAL: 0,
+};
+exports.PROCESSABLE_HISTORY_TYPES = [
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.INITIAL_BOOTSTRAP,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.PUSH_NAME,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.RECENT,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.FULL,
+    WAProto_1.proto.Message.HistorySyncNotification.HistorySyncType.ON_DEMAND,
+];
+exports.DEFAULT_CONNECTION_CONFIG = {
+    version: baileys_version_json_1.version,
+    browser: Utils_1.Browsers.ubuntu('Firefox'),
+    waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
+    connectTimeoutMs: 20000,
+    keepAliveIntervalMs: 30000,
+    logger: logger_1.default.child({ class: 'baileys' }),
+    printQRInTerminal: true,
+    emitOwnEvents: true,
+    defaultQueryTimeoutMs: undefined,
+    customUploadHosts: [],
+    retryRequestDelayMs: 250,
+    maxMsgRetryCount: 5,
+    fireInitQueries: true,
+    ignoreMsgLoading: false,
+    auth: undefined,
+    markOnlineOnConnect: true,
+    syncFullHistory: false,
+    patchMessageBeforeSending: msg => msg,
+    shouldSyncHistoryMessage: () => true,
+    shouldIgnoreJid: () => false,
+    linkPreviewImageThumbnailWidth: 192,
+    transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
+    generateHighQualityLinkPreview: true,
+    options: {},
+    appStateMacVerification: {
+        patch: false,
+        snapshot: false,
+    },
+    getMessage: async () => undefined,
+    cachedGroupMetadata: async () => undefined,
+    makeSignalRepository: libsignal_1.makeLibSignalRepository
+};
+exports.MEDIA_PATH_MAP = {
+    image: '/mms/image',
+    video: '/mms/video',
+    document: '/mms/document',
+    audio: '/mms/audio',
+    sticker: '/mms/image',
+    'thumbnail-link': '/mms/image',
+    'product-catalog-image': '/product/image',
+    'md-app-state': '',
+    'md-msg-hist': '/mms/md-app-state',
+};
+exports.MEDIA_HKDF_KEY_MAPPING = {
+    'audio': 'Audio',
+    'document': 'Document',
+    'gif': 'Video',
+    'image': 'Image',
+    'ppic': '',
+    'product': 'Image',
+    'ptt': 'Audio',
+    'sticker': 'Image',
+    'video': 'Video',
+    'thumbnail-document': 'Document Thumbnail',
+    'thumbnail-image': 'Image Thumbnail',
+    'thumbnail-video': 'Video Thumbnail',
+    'thumbnail-link': 'Link Thumbnail',
+    'md-msg-hist': 'History',
+    'md-app-state': 'App State',
+    'product-catalog-image': '',
+    'payment-bg-image': 'Payment Background',
+    'ptv': 'Video'
+};
+exports.MEDIA_KEYS = Object.keys(exports.MEDIA_PATH_MAP);
+exports.MIN_PREKEY_COUNT = 5;
+exports.INITIAL_PREKEY_COUNT = 30;
+exports.DEFAULT_CACHE_TTLS = {
+    SIGNAL_STORE: 5 * 60,
+    MSG_RETRY: 60 * 60,
+    CALL_OFFER: 5 * 60,
+    USER_DEVICES: 5 * 60, // 5 minutes
+};

package/lib/Signal/libsignal.d.ts

@@ -0,0 +1,3 @@
+import { SignalAuthState } from '../Types';
+import { SignalRepository } from '../Types/Signal';
+export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;

package/lib/Signal/libsignal.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLibSignalRepository = void 0;
+const libsignal = __importStar(require("libsignal"));
+const WASignalGroup_1 = require("../../WASignalGroup");
+const Utils_1 = require("../Utils");
+const WABinary_1 = require("../WABinary");
+function makeLibSignalRepository(auth) {
+    const storage = signalStorage(auth);
+    return {
+        decryptGroupMessage({ group, authorJid, msg }) {
+            const senderName = jidToSignalSenderKeyName(group, authorJid);
+            const cipher = new WASignalGroup_1.GroupCipher(storage, senderName);
+            return cipher.decrypt(msg);
+        },
+        async processSenderKeyDistributionMessage({ item, authorJid }) {
+            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const senderName = jidToSignalSenderKeyName(item.groupId, authorJid);
+            const senderMsg = new WASignalGroup_1.SenderKeyDistributionMessage(null, null, null, null, item.axolotlSenderKeyDistributionMessage);
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+            }
+            await builder.process(senderName, senderMsg);
+        },
+        async decryptMessage({ jid, type, ciphertext }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const session = new libsignal.SessionCipher(storage, addr);
+            let result;
+            switch (type) {
+                case 'pkmsg':
+                    result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                    break;
+                case 'msg':
+                    result = await session.decryptWhisperMessage(ciphertext);
+                    break;
+            }
+            return result;
+        },
+        async encryptMessage({ jid, data }) {
+            const addr = jidToSignalProtocolAddress(jid);
+            const cipher = new libsignal.SessionCipher(storage, addr);
+            const { type: sigType, body } = await cipher.encrypt(data);
+            const type = sigType === 3 ? 'pkmsg' : 'msg';
+            return { type, ciphertext: Buffer.from(body, 'binary') };
+        },
+        async encryptGroupMessage({ group, meId, data }) {
+            const senderName = jidToSignalSenderKeyName(group, meId);
+            const builder = new WASignalGroup_1.GroupSessionBuilder(storage);
+            const { [senderName]: senderKey } = await auth.keys.get('sender-key', [senderName]);
+            if (!senderKey) {
+                await storage.storeSenderKey(senderName, new WASignalGroup_1.SenderKeyRecord());
+            }
+            const senderKeyDistributionMessage = await builder.create(senderName);
+            const session = new WASignalGroup_1.GroupCipher(storage, senderName);
+            const ciphertext = await session.encrypt(data);
+            return {
+                ciphertext,
+                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize(),
+            };
+        },
+        async injectE2ESession({ jid, session }) {
+            const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
+            await cipher.initOutgoing(session);
+        },
+        jidToSignalProtocolAddress(jid) {
+            return jidToSignalProtocolAddress(jid).toString();
+        },
+    };
+}
+exports.makeLibSignalRepository = makeLibSignalRepository;
+const jidToSignalProtocolAddress = (jid) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(jid);
+    return new libsignal.ProtocolAddress(user, device || 0);
+};
+const jidToSignalSenderKeyName = (group, user) => {
+    return new WASignalGroup_1.SenderKeyName(group, jidToSignalProtocolAddress(user)).toString();
+};
+function signalStorage({ creds, keys }) {
+    return {
+        loadSession: async (id) => {
+            const { [id]: sess } = await keys.get('session', [id]);
+            if (sess) {
+                return libsignal.SessionRecord.deserialize(sess);
+            }
+        },
+        storeSession: async (id, session) => {
+            await keys.set({ 'session': { [id]: session.serialize() } });
+        },
+        isTrustedIdentity: () => {
+            return true;
+        },
+        loadPreKey: async (id) => {
+            const keyId = id.toString();
+            const { [keyId]: key } = await keys.get('pre-key', [keyId]);
+            if (key) {
+                return {
+                    privKey: Buffer.from(key.private),
+                    pubKey: Buffer.from(key.public)
+                };
+            }
+        },
+        removePreKey: (id) => keys.set({ 'pre-key': { [id]: null } }),
+        loadSignedPreKey: () => {
+            const key = creds.signedPreKey;
+            return {
+                privKey: Buffer.from(key.keyPair.private),
+                pubKey: Buffer.from(key.keyPair.public)
+            };
+        },
+        loadSenderKey: async (keyId) => {
+            const { [keyId]: key } = await keys.get('sender-key', [keyId]);
+            if (key) {
+                return new WASignalGroup_1.SenderKeyRecord(key);
+            }
+        },
+        storeSenderKey: async (keyId, key) => {
+            await keys.set({ 'sender-key': { [keyId]: key.serialize() } });
+        },
+        getOurRegistrationId: () => (creds.registrationId),
+        getOurIdentity: () => {
+            const { signedIdentityKey } = creds;
+            return {
+                privKey: Buffer.from(signedIdentityKey.private),
+                pubKey: (0, Utils_1.generateSignalPubKey)(signedIdentityKey.public),
+            };
+        }
+    };
+}

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

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './websocket';

package/lib/Socket/Client/index.js

@@ -0,0 +1,18 @@
+"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 __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);

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

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { URL } from 'url';
+import { SocketConfig } from '../../Types';
+export declare abstract class AbstractSocketClient extends EventEmitter {
+    url: URL;
+    config: SocketConfig;
+    abstract get isOpen(): boolean;
+    abstract get isClosed(): boolean;
+    abstract get isClosing(): boolean;
+    abstract get isConnecting(): boolean;
+    constructor(url: URL, config: SocketConfig);
+    abstract connect(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+}

package/lib/Socket/Client/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSocketClient = void 0;
+const events_1 = require("events");
+class AbstractSocketClient extends events_1.EventEmitter {
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
+}
+exports.AbstractSocketClient = AbstractSocketClient;

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

@@ -0,0 +1,12 @@
+import WebSocket from 'ws';
+import { AbstractSocketClient } from './types';
+export declare class WebSocketClient extends AbstractSocketClient {
+    protected socket: WebSocket | 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;
+}

package/lib/Socket/Client/websocket.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const Defaults_1 = require("../../Defaults");
+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;
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.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;
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.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,
+            handshakeTimeout: this.config.connectTimeoutMs,
+            timeout: this.config.connectTimeoutMs,
+            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));
+        }
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        this.socket.close();
+        this.socket = null;
+    }
+    send(str, cb) {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(str, cb);
+        return Boolean(this.socket);
+    }
+}
+exports.WebSocketClient = WebSocketClient;