bybit-api 3.10.29 → 4.0.0-beta.0

package/lib/websocket-client.js

@@ -8,316 +8,41 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebsocketClient = void 0;
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-/* eslint-disable max-len */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const events_1 = require("events");
-const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
-const contract_client_1 = require("./contract-client");
-const inverse_client_1 = require("./inverse-client");
-const linear_client_1 = require("./linear-client");
-const rest_client_v5_1 = require("./rest-client-v5");
-const spot_client_1 = require("./spot-client");
-const spot_client_v3_1 = require("./spot-client-v3");
-const unified_margin_client_1 = require("./unified-margin-client");
-const usdc_option_client_1 = require("./usdc-option-client");
-const usdc_perpetual_client_1 = require("./usdc-perpetual-client");
 const util_1 = require("./util");
-const node_support_1 = require("./util/node-support");
-const WsStore_1 = __importDefault(require("./util/WsStore"));
-const loggerCategory = { category: 'bybit-ws' };
-// eslint-disable-next-line no-redeclare
-class WebsocketClient extends events_1.EventEmitter {
-    constructor(options, logger) {
-        super();
-        this.pendingTopicsSubscriptions = [];
-        this.logger = logger || util_1.DefaultLogger;
-        this.wsStore = new WsStore_1.default(this.logger);
-        this.options = Object.assign({ testnet: false, pongTimeout: 1000, pingInterval: 10000, reconnectTimeout: 500, recvWindow: 5000, fetchTimeOffsetBeforeAuth: false }, options);
-        this.options.restOptions = Object.assign(Object.assign({}, this.options.restOptions), { testnet: this.options.testnet });
-        this.prepareRESTClient();
-        // add default error handling so this doesn't crash node (if the user didn't set a handler)
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        this.on('error', () => { });
-    }
-    /** Get the WsStore that tracks websockets & topics */
-    getWsStore() {
-        return this.wsStore;
-    }
-    isTestnet() {
-        return this.options.testnet === true;
-    }
-    /**
-     * Subscribe to V5 topics & track/persist them.
-     * @param wsTopics - topic or list of topics
-     * @param category - the API category this topic is for (e.g. "linear"). The value is only important when connecting to public topics and will be ignored for private topics.
-     * @param isPrivateTopic - optional - the library will try to detect private topics, you can use this to mark a topic as private (if the topic isn't recognised yet)
-     */
-    subscribeV5(wsTopics, category, isPrivateTopic) {
-        const topics = Array.isArray(wsTopics) ? wsTopics : [wsTopics];
-        return new Promise((resolver, rejector) => {
-            topics.forEach((topic) => {
-                const wsKey = (0, util_1.getWsKeyForTopic)(this.options.market, topic, isPrivateTopic, category);
-                // Persist topic for reconnects
-                this.wsStore.addTopic(wsKey, topic);
-                this.upsertPendingTopicsSubscriptions(wsKey, topic, resolver, rejector);
-                // if connected, send subscription request
-                if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
-                    return this.requestSubscribeTopics(wsKey, [topic]);
-                }
-                // start connection process if it hasn't yet begun. Topics are automatically subscribed to on-connect
-                if (!this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTING) &&
-                    !this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.RECONNECTING)) {
-                    return this.connect(wsKey);
-                }
-            });
-        });
-    }
+const BaseWSClient_1 = require("./util/BaseWSClient");
+const webCryptoAPI_1 = require("./util/webCryptoAPI");
+const WS_LOGGER_CATEGORY = { category: 'bybit-ws' };
+class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
     /**
-     * Subscribe to V1-V3 topics & track/persist them.
-     *
-     * Note: for public V5 topics use the `subscribeV5()` method.
-     *
-     * Topics will be automatically resubscribed to if the connection resets/drops/reconnects.
-     * @param wsTopics - topic or list of topics
-     * @param isPrivateTopic optional - the library will try to detect private topics, you can use this to mark a topic as private (if the topic isn't recognised yet)
-     */
-    subscribe(wsTopics, isPrivateTopic) {
-        const topics = Array.isArray(wsTopics) ? wsTopics : [wsTopics];
-        if (this.options.market === 'v5') {
-            topics.forEach((topic) => {
-                if (!(0, util_1.isPrivateWsTopic)(topic)) {
-                    throw new Error('For public "v5" websocket topics, use the subscribeV5() method & provide the category parameter');
-                }
-            });
-        }
-        return new Promise((resolver, rejector) => {
-            topics.forEach((topic) => {
-                const wsKey = (0, util_1.getWsKeyForTopic)(this.options.market, topic, isPrivateTopic);
-                // Persist topic for reconnects
-                this.wsStore.addTopic(wsKey, topic);
-                this.upsertPendingTopicsSubscriptions(wsKey, topic, resolver, rejector);
-                // if connected, send subscription request
-                if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
-                    return this.requestSubscribeTopics(wsKey, [topic]);
-                }
-                // start connection process if it hasn't yet begun. Topics are automatically subscribed to on-connect
-                if (!this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTING) &&
-                    !this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.RECONNECTING)) {
-                    return this.connect(wsKey);
-                }
-            });
-        });
-    }
-    upsertPendingTopicsSubscriptions(wsKey, topic, resolver, rejector) {
-        const existingWsKeyPendingSubscriptions = this.pendingTopicsSubscriptions.find((s) => s.wsKey === wsKey);
-        if (!existingWsKeyPendingSubscriptions) {
-            this.pendingTopicsSubscriptions.push({
-                wsKey,
-                resolver,
-                rejector,
-                failedTopicsSubscriptions: new Set(),
-                pendingTopicsSubscriptions: new Set([topic]),
-            });
-            return;
-        }
-        existingWsKeyPendingSubscriptions.pendingTopicsSubscriptions.add(topic);
-    }
-    /**
-     * Unsubscribe from V5 topics & remove them from memory. They won't be re-subscribed to if the connection reconnects.
-     * @param wsTopics - topic or list of topics
-     * @param category - the API category this topic is for (e.g. "linear"). The value is only important when connecting to public topics and will be ignored for private topics.
-     * @param isPrivateTopic - optional - the library will try to detect private topics, you can use this to mark a topic as private (if the topic isn't recognised yet)
+     * Request connection of all dependent (public & private) websockets, instead of waiting
+     * for automatic connection by SDK.
      */
-    unsubscribeV5(wsTopics, category, isPrivateTopic) {
-        const topics = Array.isArray(wsTopics) ? wsTopics : [wsTopics];
-        topics.forEach((topic) => {
-            const wsKey = (0, util_1.getWsKeyForTopic)(this.options.market, topic, isPrivateTopic, category);
-            // Remove topic from persistence for reconnects
-            this.wsStore.deleteTopic(wsKey, topic);
-            this.removeTopicPendingSubscription(wsKey, topic);
-            // unsubscribe request only necessary if active connection exists
-            if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
-                this.requestUnsubscribeTopics(wsKey, [topic]);
-            }
-        });
-    }
-    removeTopicPendingSubscription(wsKey, topic) {
-        const existingWsKeyPendingSubscriptions = this.pendingTopicsSubscriptions.find((s) => s.wsKey === wsKey);
-        if (existingWsKeyPendingSubscriptions) {
-            existingWsKeyPendingSubscriptions.pendingTopicsSubscriptions.delete(topic);
-            if (!existingWsKeyPendingSubscriptions.pendingTopicsSubscriptions.size) {
-                this.pendingTopicsSubscriptions =
-                    this.pendingTopicsSubscriptions.filter((s) => s.wsKey !== wsKey);
-            }
-        }
-    }
-    clearTopicsPendingSubscriptions(wsKey) {
-        this.pendingTopicsSubscriptions = this.pendingTopicsSubscriptions.filter((s) => s.wsKey !== wsKey);
-    }
-    /**
-     * Unsubscribe from V1-V3 topics & remove them from memory. They won't be re-subscribed to if the connection reconnects.
-     *
-     * Note: For public V5 topics, use `unsubscribeV5()` instead!
-     *
-     * @param wsTopics topic or list of topics
-     * @param isPrivateTopic optional - the library will try to detect private topics, you can use this to mark a topic as private (if the topic isn't recognised yet)
-     */
-    unsubscribe(wsTopics, isPrivateTopic) {
-        const topics = Array.isArray(wsTopics) ? wsTopics : [wsTopics];
-        if (this.options.market === 'v5') {
-            topics.forEach((topic) => {
-                if (!(0, util_1.isPrivateWsTopic)(topic)) {
-                    throw new Error('For public "v5" websocket topics, use the unsubscribeV5() method & provide the category parameter');
-                }
-            });
-        }
-        topics.forEach((topic) => {
-            const wsKey = (0, util_1.getWsKeyForTopic)(this.options.market, topic, isPrivateTopic);
-            // Remove topic from persistence for reconnects
-            this.wsStore.deleteTopic(wsKey, topic);
-            this.removeTopicPendingSubscription(wsKey, topic);
-            // unsubscribe request only necessary if active connection exists
-            if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
-                this.requestUnsubscribeTopics(wsKey, [topic]);
-            }
-        });
-    }
-    /**
-     * @private Only used if we fetch exchange time before attempting auth. Disabled by default.
-     * I've removed this for ftx and it's working great, tempted to remove this here
-     */
-    prepareRESTClient() {
+    connectAll() {
         switch (this.options.market) {
-            case 'inverse': {
-                this.restClient = new inverse_client_1.InverseClient(this.options.restOptions, this.options.requestOptions);
-                break;
-            }
-            case 'linear': {
-                this.restClient = new linear_client_1.LinearClient(this.options.restOptions, this.options.requestOptions);
-                break;
-            }
-            case 'spot': {
-                this.restClient = new spot_client_1.SpotClient(this.options.restOptions, this.options.requestOptions);
-                this.connectPublic();
-                break;
-            }
-            case 'spotv3': {
-                this.restClient = new spot_client_v3_1.SpotClientV3(this.options.restOptions, this.options.requestOptions);
-                break;
-            }
-            case 'usdcOption': {
-                this.restClient = new usdc_option_client_1.USDCOptionClient(this.options.restOptions, this.options.requestOptions);
-                break;
-            }
-            case 'usdcPerp': {
-                this.restClient = new usdc_perpetual_client_1.USDCPerpetualClient(this.options.restOptions, this.options.requestOptions);
-                break;
-            }
-            case 'unifiedOption':
-            case 'unifiedPerp': {
-                this.restClient = new unified_margin_client_1.UnifiedMarginClient(this.options.restOptions, this.options.requestOptions);
-                break;
-            }
-            case 'contractInverse':
-            case 'contractUSDT': {
-                this.restClient = new contract_client_1.ContractClient(this.options.restOptions, this.options.requestOptions);
-                break;
-            }
             case 'v5': {
-                this.restClient = new rest_client_v5_1.RestClientV5(this.options.restOptions, this.options.requestOptions);
-                break;
+                return [...this.connectPublic(), this.connectPrivate()];
             }
             default: {
-                throw (0, util_1.neverGuard)(this.options.market, 'prepareRESTClient(): Unhandled market');
+                throw (0, util_1.neverGuard)(this.options.market, 'connectAll(): Unhandled market');
             }
         }
     }
-    close(wsKey, force) {
-        this.logger.info('Closing connection', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-        this.setWsState(wsKey, util_1.WsConnectionStateEnum.CLOSING);
-        this.clearTimers(wsKey);
-        const ws = this.getWs(wsKey);
-        ws === null || ws === void 0 ? void 0 : ws.close();
-        if (force) {
-            (0, util_1.safeTerminateWs)(ws);
-        }
-    }
-    closeAll(force) {
-        const keys = this.wsStore.getKeys();
-        this.logger.info(`Closing all ws connections: ${keys}`);
-        keys.forEach((key) => {
-            this.close(key, force);
-        });
-    }
     /**
-     * Request connection of all dependent (public & private) websockets, instead of waiting for automatic connection by library
+     * Ensures the WS API connection is active and ready.
+     *
+     * You do not need to call this, but if you call this before making any WS API requests,
+     * it can accelerate the first request (by preparing the connection in advance).
      */
-    connectAll() {
-        switch (this.options.market) {
-            case 'inverse': {
-                // only one for inverse
-                return [...this.connectPublic()];
-            }
-            // these all have separate public & private ws endpoints
-            case 'linear':
-            case 'spot':
-            case 'spotv3':
-            case 'usdcOption':
-            case 'usdcPerp':
-            case 'unifiedPerp':
-            case 'unifiedOption':
-            case 'contractUSDT':
-            case 'contractInverse': {
-                return [...this.connectPublic(), this.connectPrivate()];
-            }
-            case 'v5': {
-                return [this.connectPrivate()];
-            }
-            default: {
-                throw (0, util_1.neverGuard)(this.options.market, 'connectAll(): Unhandled market');
-            }
-        }
+    connectWSAPI() {
+        /** This call automatically ensures the connection is active AND authenticated before resolving */
+        return this.assertIsAuthenticated(util_1.WS_KEY_MAP.v5PrivateTrade);
     }
     connectPublic() {
         switch (this.options.market) {
-            case 'inverse': {
-                return [this.connect(util_1.WS_KEY_MAP.inverse)];
-            }
-            case 'linear': {
-                return [this.connect(util_1.WS_KEY_MAP.linearPublic)];
-            }
-            case 'spot': {
-                return [this.connect(util_1.WS_KEY_MAP.spotPublic)];
-            }
-            case 'spotv3': {
-                return [this.connect(util_1.WS_KEY_MAP.spotV3Public)];
-            }
-            case 'usdcOption': {
-                return [this.connect(util_1.WS_KEY_MAP.usdcOptionPublic)];
-            }
-            case 'usdcPerp': {
-                return [this.connect(util_1.WS_KEY_MAP.usdcPerpPublic)];
-            }
-            case 'unifiedOption': {
-                return [this.connect(util_1.WS_KEY_MAP.unifiedOptionPublic)];
-            }
-            case 'unifiedPerp': {
-                return [
-                    this.connect(util_1.WS_KEY_MAP.unifiedPerpUSDTPublic),
-                    this.connect(util_1.WS_KEY_MAP.unifiedPerpUSDCPublic),
-                ];
-            }
-            case 'contractUSDT':
-                return [this.connect(util_1.WS_KEY_MAP.contractUSDTPublic)];
-            case 'contractInverse':
-                return [this.connect(util_1.WS_KEY_MAP.contractInversePublic)];
-            case 'v5': {
+            case 'v5':
+            default: {
                 return [
                     this.connect(util_1.WS_KEY_MAP.v5SpotPublic),
                     this.connect(util_1.WS_KEY_MAP.v5LinearPublic),
@@ -325,121 +50,213 @@ class WebsocketClient extends events_1.EventEmitter {
                     this.connect(util_1.WS_KEY_MAP.v5OptionPublic),
                 ];
             }
-            default: {
-                throw (0, util_1.neverGuard)(this.options.market, 'connectPublic(): Unhandled market');
-            }
         }
     }
     connectPrivate() {
         switch (this.options.market) {
-            case 'inverse': {
-                return this.connect(util_1.WS_KEY_MAP.inverse);
-            }
-            case 'linear': {
-                return this.connect(util_1.WS_KEY_MAP.linearPrivate);
-            }
-            case 'spot': {
-                return this.connect(util_1.WS_KEY_MAP.spotPrivate);
-            }
-            case 'spotv3': {
-                return this.connect(util_1.WS_KEY_MAP.spotV3Private);
-            }
-            case 'usdcOption': {
-                return this.connect(util_1.WS_KEY_MAP.usdcOptionPrivate);
-            }
-            case 'usdcPerp': {
-                return this.connect(util_1.WS_KEY_MAP.usdcPerpPrivate);
-            }
-            case 'unifiedPerp':
-            case 'unifiedOption': {
-                return this.connect(util_1.WS_KEY_MAP.unifiedPrivate);
-            }
-            case 'contractUSDT':
-                return this.connect(util_1.WS_KEY_MAP.contractUSDTPrivate);
-            case 'contractInverse':
-                return this.connect(util_1.WS_KEY_MAP.contractInversePrivate);
-            case 'v5': {
-                return this.connect(util_1.WS_KEY_MAP.v5Private);
-            }
+            case 'v5':
             default: {
-                throw (0, util_1.neverGuard)(this.options.market, 'connectPrivate(): Unhandled market');
+                return this.connect(util_1.WS_KEY_MAP.v5Private);
             }
         }
     }
-    connect(wsKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (this.wsStore.isWsOpen(wsKey)) {
-                    this.logger.error('Refused to connect to ws with existing active connection', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-                    return this.wsStore.getWs(wsKey);
-                }
-                if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTING)) {
-                    this.logger.error('Refused to connect to ws, connection attempt already active', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-                    return;
+    /**
+     * Subscribe to V5 topics & track/persist them.
+     * @param wsTopics - topic or list of topics
+     * @param category - the API category this topic is for (e.g. "linear").
+     * The value is only important when connecting to public topics and will be ignored for private topics.
+     * @param isPrivateTopic - optional - the library will try to detect private topics, you can use this
+     * to mark a topic as private (if the topic isn't recognised yet)
+     */
+    subscribeV5(wsTopics, category, isPrivateTopic) {
+        const topicRequests = Array.isArray(wsTopics) ? wsTopics : [wsTopics];
+        const perWsKeyTopics = {};
+        // Sort into per-WsKey batches, in case there is a mix of topics here
+        for (const topic of topicRequests) {
+            const derivedWsKey = (0, util_1.getWsKeyForTopic)(this.options.market, topic, isPrivateTopic, category);
+            const wsRequest = {
+                topic: topic,
+                category: category,
+            };
+            if (!perWsKeyTopics[derivedWsKey] ||
+                !Array.isArray(perWsKeyTopics[derivedWsKey])) {
+                perWsKeyTopics[derivedWsKey] = [];
+            }
+            perWsKeyTopics[derivedWsKey].push(wsRequest);
+        }
+        const promises = [];
+        // Batch sub topics per ws key
+        for (const wsKey in perWsKeyTopics) {
+            const wsKeyTopicRequests = perWsKeyTopics[wsKey];
+            if (wsKeyTopicRequests === null || wsKeyTopicRequests === void 0 ? void 0 : wsKeyTopicRequests.length) {
+                const requestPromise = this.subscribeTopicsForWsKey(wsKeyTopicRequests, wsKey);
+                if (Array.isArray(requestPromise)) {
+                    promises.push(...requestPromise);
                 }
-                if (!this.wsStore.getConnectionState(wsKey) ||
-                    this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.INITIAL)) {
-                    this.setWsState(wsKey, util_1.WsConnectionStateEnum.CONNECTING);
+                else {
+                    promises.push(requestPromise);
                 }
-                const authParams = yield this.getAuthParams(wsKey);
-                const url = (0, util_1.getWsUrl)(wsKey, this.options, this.logger);
-                const ws = this.connectToWsUrl(url + authParams, wsKey);
-                return this.wsStore.setWs(wsKey, ws);
             }
-            catch (err) {
-                this.parseWsError('Connection failed', err, wsKey);
-                this.reconnectWithDelay(wsKey, this.options.reconnectTimeout);
-            }
-        });
-    }
-    parseWsError(context, error, wsKey) {
-        if (!error.message) {
-            this.logger.error(`${context} due to unexpected error: `, error);
-            this.emit('error', error);
-            return;
         }
-        switch (error.message) {
-            case 'Unexpected server response: 401':
-                this.logger.error(`${context} due to 401 authorization failure.`, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-                break;
-            default:
-                if (this.wsStore.getConnectionState(wsKey) !==
-                    util_1.WsConnectionStateEnum.CLOSING) {
-                    this.logger.error(`${context} due to unexpected response error: "${(error === null || error === void 0 ? void 0 : error.msg) || (error === null || error === void 0 ? void 0 : error.message) || error}"`, Object.assign(Object.assign({}, loggerCategory), { wsKey, error }));
-                    this.executeReconnectableClose(wsKey, 'unhandled onWsError');
+        // Return promise to resolve midflight WS request (only works if already connected before request)
+        return promises;
+    }
+    /**
+     * Unsubscribe from V5 topics & remove them from memory. They won't be re-subscribed to if the
+     * connection reconnects.
+     *
+     * @param wsTopics - topic or list of topics
+     * @param category - the API category this topic is for (e.g. "linear"). The value is only
+     * important when connecting to public topics and will be ignored for private topics.
+     * @param isPrivateTopic - optional - the library will try to detect private topics, you can
+     * use this to mark a topic as private (if the topic isn't recognised yet)
+     */
+    unsubscribeV5(wsTopics, category, isPrivateTopic) {
+        const topicRequests = Array.isArray(wsTopics) ? wsTopics : [wsTopics];
+        const perWsKeyTopics = {};
+        // Sort into per-WsKey batches, in case there is a mix of topics here
+        for (const topic of topicRequests) {
+            const derivedWsKey = (0, util_1.getWsKeyForTopic)(this.options.market, topic, isPrivateTopic, category);
+            const wsRequest = {
+                topic: topic,
+                category: category,
+            };
+            if (!perWsKeyTopics[derivedWsKey] ||
+                !Array.isArray(perWsKeyTopics[derivedWsKey])) {
+                perWsKeyTopics[derivedWsKey] = [];
+            }
+            perWsKeyTopics[derivedWsKey].push(wsRequest);
+        }
+        const promises = [];
+        // Batch sub topics per ws key
+        for (const wsKey in perWsKeyTopics) {
+            const wsKeyTopicRequests = perWsKeyTopics[wsKey];
+            if (wsKeyTopicRequests === null || wsKeyTopicRequests === void 0 ? void 0 : wsKeyTopicRequests.length) {
+                const requestPromise = this.unsubscribeTopicsForWsKey(wsKeyTopicRequests, wsKey);
+                if (Array.isArray(requestPromise)) {
+                    promises.push(...requestPromise);
                 }
                 else {
-                    this.logger.info(`${wsKey} socket forcefully closed. Will not reconnect.`);
+                    promises.push(requestPromise);
                 }
-                break;
+            }
         }
-        this.emit('error', error);
+        // Return promise to resolve midflight WS request (only works if already connected before request)
+        return promises;
     }
     /**
-     * Return params required to make authorized request
+     * Note: subscribeV5() might be simpler to use. The end result is the same.
+     *
+     * Request subscription to one or more topics. Pass topics as either an array of strings,
+     * or array of objects (if the topic has parameters).
+     *
+     * Objects should be formatted as {topic: string, params: object, category: CategoryV5}.
+     *
+     * - Subscriptions are automatically routed to the correct websocket connection.
+     * - Authentication/connection is automatic.
+     * - Resubscribe after network issues is automatic.
+     *
+     * Call `unsubscribe(topics)` to remove topics
      */
-    getAuthParams(wsKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (util_1.PUBLIC_WS_KEYS.includes(wsKey)) {
-                this.logger.debug('Starting public only websocket client.', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-                return '';
+    subscribe(requests, wsKey) {
+        const topicRequests = Array.isArray(requests) ? requests : [requests];
+        const normalisedTopicRequests = (0, util_1.getNormalisedTopicRequests)(topicRequests);
+        const perWsKeyTopics = (0, util_1.getTopicsPerWSKey)(this.options.market, normalisedTopicRequests, wsKey);
+        // Batch sub topics per ws key
+        for (const wsKey in perWsKeyTopics) {
+            const wsKeyTopicRequests = perWsKeyTopics[wsKey];
+            if (wsKeyTopicRequests === null || wsKeyTopicRequests === void 0 ? void 0 : wsKeyTopicRequests.length) {
+                this.subscribeTopicsForWsKey(wsKeyTopicRequests, wsKey);
             }
-            try {
-                const { signature, expiresAt } = yield this.getWsAuthSignature(wsKey);
-                const authParams = {
-                    api_key: this.options.key,
-                    expires: expiresAt,
-                    signature,
-                };
-                return '?' + (0, util_1.serializeParams)(authParams);
+        }
+    }
+    /**
+     * Note: unsubscribe() might be simpler to use. The end result is the same.
+     * Unsubscribe from one or more topics. Similar to subscribe() but in reverse.
+     *
+     * - Requests are automatically routed to the correct websocket connection.
+     * - These topics will be removed from the topic cache, so they won't be subscribed to again.
+     */
+    unsubscribe(requests, wsKey) {
+        const topicRequests = Array.isArray(requests) ? requests : [requests];
+        const normalisedTopicRequests = (0, util_1.getNormalisedTopicRequests)(topicRequests);
+        const perWsKeyTopics = (0, util_1.getTopicsPerWSKey)(this.options.market, normalisedTopicRequests, wsKey);
+        // Batch sub topics per ws key
+        for (const wsKey in perWsKeyTopics) {
+            const wsKeyTopicRequests = perWsKeyTopics[wsKey];
+            if (wsKeyTopicRequests === null || wsKeyTopicRequests === void 0 ? void 0 : wsKeyTopicRequests.length) {
+                this.unsubscribeTopicsForWsKey(wsKeyTopicRequests, wsKey);
+            }
+        }
+    }
+    sendWSAPIRequest() {
+        return __awaiter(this, arguments, void 0, function* (wsKey = util_1.WS_KEY_MAP.v5PrivateTrade, operation, params) {
+            this.logger.trace(`sendWSAPIRequest(): assert "${wsKey}" is connected`);
+            yield this.assertIsConnected(wsKey);
+            this.logger.trace('sendWSAPIRequest()->assertIsConnected() ok');
+            yield this.assertIsAuthenticated(wsKey);
+            this.logger.trace('sendWSAPIRequest()->assertIsAuthenticated() ok');
+            const requestEvent = {
+                reqId: this.getNewRequestId(),
+                header: {
+                    'X-BAPI-RECV-WINDOW': `${this.options.recvWindow}`,
+                    'X-BAPI-TIMESTAMP': `${Date.now()}`,
+                    Referer: util_1.APIID,
+                },
+                op: operation,
+                args: [params],
+            };
+            // Sign, if needed
+            const signedEvent = yield this.signWSAPIRequest(requestEvent);
+            // Store deferred promise, resolved within the "resolveEmittableEvents" method while parsing incoming events
+            const promiseRef = (0, util_1.getPromiseRefForWSAPIRequest)(requestEvent);
+            const deferredPromise = this.getWsStore().createDeferredPromise(wsKey, promiseRef, false);
+            this.logger.trace(`sendWSAPIRequest(): sending raw request: ${JSON.stringify(signedEvent, null, 2)}`);
+            // Send event
+            this.tryWsSend(wsKey, JSON.stringify(signedEvent));
+            this.logger.trace(`sendWSAPIRequest(): sent ${operation} event`);
+            // Return deferred promise, so caller can await this call
+            return deferredPromise.promise;
+        });
+    }
+    /**
+     *
+     *
+     * Internal methods - not intended for public use
+     *
+     *
+     */
+    /**
+     * @returns The WS URL to connect to for this WS key
+     */
+    getWsUrl(wsKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wsBaseURL = (0, util_1.getWsUrl)(wsKey, this.options, this.logger);
+            // If auth is needed for this wsKey URL, this returns a suffix
+            const authParams = yield this.getWsAuthURLSuffix();
+            if (!authParams) {
+                return wsBaseURL;
             }
-            catch (e) {
-                this.logger.error(e, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-                return '';
+            return wsBaseURL + '?' + authParams;
+        });
+    }
+    /**
+     * Return params required to make authorized request
+     */
+    getWsAuthURLSuffix() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return '';
+        });
+    }
+    signMessage(paramsStr, secret, method, algorithm) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.options.customSignMessageFn === 'function') {
+                return this.options.customSignMessageFn(paramsStr, secret);
             }
+            return yield (0, webCryptoAPI_1.signMessage)(paramsStr, secret, method, algorithm);
         });
     }
-    sendAuthRequest(wsKey) {
+    getWsAuthRequestEvent(wsKey) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const { signature, expiresAt } = yield this.getWsAuthSignature(wsKey);
@@ -448,387 +265,276 @@ class WebsocketClient extends events_1.EventEmitter {
                     args: [this.options.key, expiresAt, signature],
                     req_id: `${wsKey}-auth`,
                 };
-                return this.tryWsSend(wsKey, JSON.stringify(request));
+                return request;
             }
             catch (e) {
-                this.logger.error(e, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+                this.logger.error(e, Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey }));
+                throw e;
             }
         });
     }
     getWsAuthSignature(wsKey) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { key, secret } = this.options;
             if (!key || !secret) {
-                this.logger.warning('Cannot authenticate websocket, either api or private keys missing.', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+                this.logger.error('Cannot authenticate websocket, either api or private keys missing.', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey }));
                 throw new Error('Cannot auth - missing api or secret in config');
             }
-            this.logger.debug("Getting auth'd request params", Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-            const timeOffset = this.options.fetchTimeOffsetBeforeAuth
-                ? (yield ((_a = this.restClient) === null || _a === void 0 ? void 0 : _a.fetchTimeOffset())) || 0
-                : 0;
+            this.logger.trace("Getting auth'd request params", Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey }));
             const recvWindow = this.options.recvWindow || 5000;
-            const signatureExpiresAt = Date.now() + timeOffset + recvWindow;
-            const signature = yield (0, node_support_1.signMessage)('GET/realtime' + signatureExpiresAt, secret);
+            const signatureExpiresAt = Date.now() + this.getTimeOffsetMs() + recvWindow;
+            const signature = yield this.signMessage('GET/realtime' + signatureExpiresAt, secret, 'hex', 'SHA-256');
             return {
                 expiresAt: signatureExpiresAt,
                 signature,
             };
         });
     }
-    reconnectWithDelay(wsKey, connectionDelayMs) {
-        var _a;
-        this.clearTimers(wsKey);
-        if (this.wsStore.getConnectionState(wsKey) !==
-            util_1.WsConnectionStateEnum.CONNECTING) {
-            this.setWsState(wsKey, util_1.WsConnectionStateEnum.RECONNECTING);
-        }
-        if ((_a = this.wsStore.get(wsKey)) === null || _a === void 0 ? void 0 : _a.activeReconnectTimer) {
-            this.clearReconnectTimer(wsKey);
-        }
-        this.wsStore.get(wsKey, true).activeReconnectTimer = setTimeout(() => {
-            this.logger.info('Reconnecting to websocket', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-            this.clearReconnectTimer(wsKey);
-            this.connect(wsKey);
-        }, connectionDelayMs);
+    signWSAPIRequest(requestEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Not needed for Bybit. Auth happens only on connection open, automatically.
+            return requestEvent;
+        });
     }
-    ping(wsKey) {
-        if (this.wsStore.get(wsKey, true).activePongTimer) {
-            return;
-        }
-        this.clearPongTimer(wsKey);
-        this.logger.silly('Sending ping', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+    sendPingEvent(wsKey) {
         this.tryWsSend(wsKey, JSON.stringify({ op: 'ping' }));
-        this.wsStore.get(wsKey, true).activePongTimer = setTimeout(() => this.executeReconnectableClose(wsKey, 'Pong timeout'), this.options.pongTimeout);
-    }
-    /**
-     * Closes a connection, if it's even open. If open, this will trigger a reconnect asynchronously.
-     * If closed, trigger a reconnect immediately
-     */
-    executeReconnectableClose(wsKey, reason) {
-        this.logger.info(`${reason} - closing socket to reconnect`, Object.assign(Object.assign({}, loggerCategory), { wsKey,
-            reason }));
-        const wasOpen = this.wsStore.isWsOpen(wsKey);
-        this.clearPingTimer(wsKey);
-        this.clearPongTimer(wsKey);
-        const ws = this.getWs(wsKey);
-        if (ws) {
-            ws.close();
-            (0, util_1.safeTerminateWs)(ws);
-        }
-        if (!wasOpen) {
-            this.logger.info(`${reason} - socket already closed - trigger immediate reconnect`, Object.assign(Object.assign({}, loggerCategory), { wsKey,
-                reason }));
-            this.reconnectWithDelay(wsKey, this.options.reconnectTimeout);
-        }
     }
-    clearTimers(wsKey) {
-        this.clearPingTimer(wsKey);
-        this.clearPongTimer(wsKey);
-        this.clearReconnectTimer(wsKey);
+    sendPongEvent(wsKey) {
+        this.tryWsSend(wsKey, JSON.stringify({ op: 'pong' }));
     }
-    // Send a ping at intervals
-    clearPingTimer(wsKey) {
-        const wsState = this.wsStore.get(wsKey);
-        if (wsState === null || wsState === void 0 ? void 0 : wsState.activePingTimer) {
-            clearInterval(wsState.activePingTimer);
-            wsState.activePingTimer = undefined;
-        }
-    }
-    // Expect a pong within a time limit
-    clearPongTimer(wsKey) {
-        const wsState = this.wsStore.get(wsKey);
-        if (wsState === null || wsState === void 0 ? void 0 : wsState.activePongTimer) {
-            clearTimeout(wsState.activePongTimer);
-            wsState.activePongTimer = undefined;
-        }
-    }
-    clearReconnectTimer(wsKey) {
-        const wsState = this.wsStore.get(wsKey);
-        if (wsState === null || wsState === void 0 ? void 0 : wsState.activeReconnectTimer) {
-            clearTimeout(wsState.activeReconnectTimer);
-            wsState.activeReconnectTimer = undefined;
-        }
+    /** Force subscription requests to be sent in smaller batches, if a number is returned */
+    getMaxTopicsPerSubscribeEvent(wsKey) {
+        return (0, util_1.getMaxTopicsPerSubscribeEvent)(this.options.market, wsKey);
     }
     /**
-     * @private Use the `subscribe(topics)` method to subscribe to topics. Send WS message to subscribe to topics.
+     * @returns one or more correctly structured request events for performing a operations over WS. This can vary per exchange spec.
      */
-    requestSubscribeTopics(wsKey, topics) {
-        if (!topics.length) {
-            return;
-        }
-        const maxTopicsPerEvent = (0, util_1.getMaxTopicsPerSubscribeEvent)(this.options.market, wsKey);
-        if (maxTopicsPerEvent && topics.length > maxTopicsPerEvent) {
-            this.logger.silly(`Subscribing to topics in batches of ${maxTopicsPerEvent}`);
-            for (let i = 0; i < topics.length; i += maxTopicsPerEvent) {
-                const batch = topics.slice(i, i + maxTopicsPerEvent);
-                this.logger.silly(`Subscribing to batch of ${batch.length}`);
-                this.requestSubscribeTopics(wsKey, batch);
+    getWsRequestEvents(market, operation, requests, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+    wsKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wsRequestEvents = [];
+            const wsRequestBuildingErrors = [];
+            switch (market) {
+                case 'all': {
+                    const wsEvent = {
+                        req_id: this.getNewRequestId(),
+                        op: operation,
+                        args: requests.map((r) => r.topic),
+                    };
+                    const midflightWsEvent = {
+                        requestKey: wsEvent.req_id,
+                        requestEvent: wsEvent,
+                    };
+                    wsRequestEvents.push(Object.assign({}, midflightWsEvent));
+                    break;
+                }
+                default: {
+                    throw (0, util_1.neverGuard)(market, `Unhandled market "${market}"`);
+                }
             }
-            this.logger.silly(`Finished batch subscribing to ${topics.length} topics`);
-            return;
-        }
-        const wsMessage = JSON.stringify({
-            req_id: topics.join(','),
-            op: 'subscribe',
-            args: topics,
+            if (wsRequestBuildingErrors.length) {
+                const label = wsRequestBuildingErrors.length === requests.length ? 'all' : 'some';
+                this.logger.error(`Failed to build/send ${wsRequestBuildingErrors.length} event(s) for ${label} WS requests due to exceptions`, Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsRequestBuildingErrors, wsRequestBuildingErrorsStringified: JSON.stringify(wsRequestBuildingErrors, null, 2) }));
+            }
+            return wsRequestEvents;
         });
-        this.tryWsSend(wsKey, wsMessage);
+    }
+    getPrivateWSKeys() {
+        return util_1.WS_AUTH_ON_CONNECT_KEYS;
+    }
+    isAuthOnConnectWsKey(wsKey) {
+        return util_1.WS_AUTH_ON_CONNECT_KEYS.includes(wsKey);
     }
     /**
-     * @private Use the `unsubscribe(topics)` method to unsubscribe from topics. Send WS message to unsubscribe from topics.
+     * Determines if a topic is for a private channel, using a hardcoded list of strings
      */
-    requestUnsubscribeTopics(wsKey, topics) {
-        if (!topics.length) {
-            return;
-        }
-        const maxTopicsPerEvent = (0, util_1.getMaxTopicsPerSubscribeEvent)(this.options.market, wsKey);
-        if (maxTopicsPerEvent && topics.length > maxTopicsPerEvent) {
-            this.logger.silly(`Unsubscribing to topics in batches of ${maxTopicsPerEvent}`);
-            for (let i = 0; i < topics.length; i += maxTopicsPerEvent) {
-                const batch = topics.slice(i, i + maxTopicsPerEvent);
-                this.logger.silly(`Unsubscribing to batch of ${batch.length}`);
-                this.requestUnsubscribeTopics(wsKey, batch);
-            }
-            this.logger.silly(`Finished batch unsubscribing to ${topics.length} topics`);
-            return;
+    isPrivateTopicRequest(request) {
+        var _a;
+        const topicName = (_a = request === null || request === void 0 ? void 0 : request.topic) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (!topicName) {
+            return false;
         }
-        const wsMessage = JSON.stringify({
-            op: 'unsubscribe',
-            args: topics,
-        });
-        this.tryWsSend(wsKey, wsMessage);
+        return (0, util_1.isPrivateWsTopic)(topicName);
     }
-    tryWsSend(wsKey, wsMessage) {
-        try {
-            this.logger.silly('Sending upstream ws message: ', Object.assign(Object.assign({}, loggerCategory), { wsMessage,
-                wsKey }));
-            if (!wsKey) {
-                throw new Error('Cannot send message due to no known websocket for this wsKey');
-            }
-            const ws = this.getWs(wsKey);
-            if (!ws) {
-                throw new Error(`${wsKey} socket not connected yet, call "connect(${wsKey}) first then try again when the "open" event arrives`);
-            }
-            ws.send(wsMessage);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isWsPing(msg) {
+        if (!msg) {
+            return false;
         }
-        catch (e) {
-            this.logger.error('Failed to send WS message', Object.assign(Object.assign({}, loggerCategory), { wsMessage,
-                wsKey, exception: e }));
+        if (typeof (msg === null || msg === void 0 ? void 0 : msg.data) === 'string') {
+            if (msg.data.includes('op": "ping')) {
+                return true;
+            }
+            // console.log('isWsPing?', {
+            //   data: msg.data,
+            // });
+            return false;
         }
+        return false;
     }
-    connectToWsUrl(url, wsKey) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isWsPong(msg) {
         var _a;
-        this.logger.silly(`Opening WS connection to URL: ${url}`, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-        const agent = (_a = this.options.requestOptions) === null || _a === void 0 ? void 0 : _a.agent;
-        const ws = new isomorphic_ws_1.default(url, undefined, agent ? { agent } : undefined);
-        ws.onopen = (event) => this.onWsOpen(event, wsKey);
-        ws.onmessage = (event) => this.onWsMessage(event, wsKey);
-        ws.onerror = (event) => this.parseWsError('Websocket onWsError', event, wsKey);
-        ws.onclose = (event) => this.onWsClose(event, wsKey);
-        return ws;
-    }
-    onWsOpen(event, wsKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTING)) {
-                this.logger.info('Websocket connected', Object.assign(Object.assign({}, loggerCategory), { wsKey, testnet: this.isTestnet(), market: this.options.market }));
-                this.emit('open', { wsKey, event });
-            }
-            else if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.RECONNECTING)) {
-                this.logger.info('Websocket reconnected', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-                this.emit('reconnected', { wsKey, event });
-            }
-            this.setWsState(wsKey, util_1.WsConnectionStateEnum.CONNECTED);
-            // Some websockets require an auth packet to be sent after opening the connection
-            if (util_1.WS_AUTH_ON_CONNECT_KEYS.includes(wsKey)) {
-                this.logger.info('Sending auth request...');
-                yield this.sendAuthRequest(wsKey);
+        if (!msg) {
+            return false;
+        }
+        if (typeof (msg === null || msg === void 0 ? void 0 : msg.data) === 'string') {
+            // public ws connections
+            if (msg.data.includes('ret_msg":"pong')) {
+                return true;
             }
-            // TODO: persistence not working yet for spot v1 topics
-            if (wsKey !== util_1.WS_KEY_MAP.spotPublic && wsKey !== util_1.WS_KEY_MAP.spotPrivate) {
-                const topics = [...this.wsStore.getTopics(wsKey)];
-                this.logger.info('Subscribing to topics', Object.assign(Object.assign({}, loggerCategory), { wsKey,
-                    topics }));
-                this.requestSubscribeTopics(wsKey, topics);
+            // private ws connections
+            if (msg.data.includes('op":"pong')) {
+                return true;
             }
-            this.wsStore.get(wsKey, true).activePingTimer = setInterval(() => this.ping(wsKey), this.options.pingInterval);
-        });
+            // console.log('isWsPong?', {
+            //   data: msg.data,
+            // });
+            return false;
+        }
+        if (((_a = msg.event) === null || _a === void 0 ? void 0 : _a.ret_msg) === 'pong') {
+            return true;
+        }
+        return (msg === null || msg === void 0 ? void 0 : msg.pong) || (0, util_1.isWsPong)(msg);
     }
-    onWsMessage(event, wsKey) {
+    /**
+     * Abstraction called to sort ws events into emittable event types (response to a request, data update, etc)
+     */
+    resolveEmittableEvents(wsKey, event) {
+        const results = [];
         try {
-            // any message can clear the pong timer - wouldn't get a message if the ws dropped
-            this.clearPongTimer(wsKey);
-            const msg = JSON.parse((event && event.data) || event);
-            // this.logger.silly('Received event', {
-            //   ...loggerCategory,
+            const parsed = JSON.parse(event.data);
+            // this.logger.trace('resolveEmittableEvents', {
+            //   ...WS_LOGGER_CATEGORY,
             //   wsKey,
-            //   msg: JSON.stringify(msg),
+            //   parsed: JSON.stringify(parsed),
             // });
-            if ((0, util_1.isTopicSubscriptionConfirmation)(msg)) {
-                this.updatePendingTopicSubscriptionStatus(wsKey, msg);
-            }
-            // TODO: cleanme
-            if (msg['success'] || (msg === null || msg === void 0 ? void 0 : msg.pong) || (0, util_1.isWsPong)(msg)) {
-                if ((0, util_1.isWsPong)(msg)) {
-                    this.logger.silly('Received pong', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+            // Only applies to the V5 WS topics
+            if ((0, util_1.isTopicSubscriptionConfirmation)(parsed) && parsed.req_id) {
+                const isTopicSubscriptionSuccessEvent = (0, util_1.isTopicSubscriptionSuccess)(parsed);
+                this.updatePendingTopicSubscriptionStatus(wsKey, parsed.req_id, parsed, isTopicSubscriptionSuccessEvent);
+            }
+            const EVENTS_AUTHENTICATED = ['auth'];
+            const EVENTS_RESPONSES = [
+                'subscribe',
+                'unsubscribe',
+                'COMMAND_RESP',
+                'ping',
+                'pong',
+            ];
+            const eventTopic = parsed === null || parsed === void 0 ? void 0 : parsed.topic;
+            const eventOperation = parsed === null || parsed === void 0 ? void 0 : parsed.op;
+            // WS API response
+            if ((0, util_1.isWSAPIResponse)(parsed)) {
+                const retCode = parsed.retCode;
+                const reqId = parsed.reqId;
+                const isError = retCode !== 0;
+                const promiseRef = [parsed.op, reqId].join('_');
+                if (!reqId) {
+                    this.logger.error('WS API response is missing reqId - promisified workflow could get stuck. If this happens, please get in touch with steps to reproduce. Trace:', {
+                        wsKey,
+                        promiseRef,
+                        parsedEvent: parsed,
+                    });
                 }
-                else {
-                    this.emit('response', Object.assign(Object.assign({}, msg), { wsKey }));
+                // WS API Exception
+                if (isError) {
+                    try {
+                        this.getWsStore().rejectDeferredPromise(wsKey, promiseRef, Object.assign({ wsKey }, parsed), true);
+                    }
+                    catch (e) {
+                        this.logger.error('Exception trying to reject WSAPI promise', {
+                            wsKey,
+                            promiseRef,
+                            parsedEvent: parsed,
+                        });
+                    }
+                    results.push({
+                        eventType: 'error',
+                        event: parsed,
+                        isWSAPIResponse: true,
+                    });
+                    return results;
                 }
-                return;
-            }
-            if (msg['finalFragment']) {
-                return this.emit('response', Object.assign(Object.assign({}, msg), { wsKey }));
-            }
-            if (msg === null || msg === void 0 ? void 0 : msg.topic) {
-                return this.emit('update', Object.assign(Object.assign({}, msg), { wsKey }));
-            }
-            if (
-            // spot v1
-            (msg === null || msg === void 0 ? void 0 : msg.code) ||
-                // spot v3
-                (msg === null || msg === void 0 ? void 0 : msg.type) === 'error' ||
-                // usdc options
-                (msg === null || msg === void 0 ? void 0 : msg.success) === false) {
-                return this.emit('error', Object.assign(Object.assign({}, msg), { wsKey }));
-            }
-            this.logger.warning('Unhandled/unrecognised ws event message', Object.assign(Object.assign({}, loggerCategory), { message: msg, event,
-                wsKey }));
-        }
-        catch (e) {
-            this.logger.error('Failed to parse ws event message', Object.assign(Object.assign({}, loggerCategory), { error: e, event,
-                wsKey }));
-        }
-    }
-    updatePendingTopicSubscriptionStatus(wsKey, msg) {
-        const requestsIds = msg.req_id;
-        const pendingTopicsSubscriptions = this.pendingTopicsSubscriptions.find((s) => s.wsKey === wsKey);
-        if (!pendingTopicsSubscriptions)
-            return;
-        const splitRequestsIds = requestsIds.split(',');
-        if (!(0, util_1.isTopicSubscriptionSuccess)(msg)) {
-            splitRequestsIds.forEach((req_id) => pendingTopicsSubscriptions.failedTopicsSubscriptions.add(req_id));
-        }
-        splitRequestsIds.forEach((req_id) => {
-            this.removeTopicPendingSubscription(wsKey, req_id);
-            if (!pendingTopicsSubscriptions.pendingTopicsSubscriptions.size &&
-                !pendingTopicsSubscriptions.failedTopicsSubscriptions.size) {
-                // all topics have been subscribed successfully, so we can resolve the subscription request
-                pendingTopicsSubscriptions.resolver();
-                this.clearTopicsPendingSubscriptions(wsKey);
-            }
-            if (!pendingTopicsSubscriptions.pendingTopicsSubscriptions.size &&
-                pendingTopicsSubscriptions.failedTopicsSubscriptions.size) {
-                // not all topics have been subscribed successfully, so we reject the subscription request
-                // and let the caller handle the situation by providing the list of failed subscriptions requests
-                const failedSubscriptionsMessage = `(${[
-                    ...pendingTopicsSubscriptions.failedTopicsSubscriptions,
-                ].toString()}) failed to subscribe`;
-                pendingTopicsSubscriptions.rejector(failedSubscriptionsMessage);
-                this.clearTopicsPendingSubscriptions(wsKey);
-            }
-        });
-    }
-    onWsClose(event, wsKey) {
-        this.logger.info('Websocket connection closed', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-        if (this.wsStore.getConnectionState(wsKey) !== util_1.WsConnectionStateEnum.CLOSING) {
-            this.reconnectWithDelay(wsKey, this.options.reconnectTimeout);
-            this.emit('reconnect', { wsKey, event });
-        }
-        else {
-            this.setWsState(wsKey, util_1.WsConnectionStateEnum.INITIAL);
-            this.emit('close', { wsKey, event });
-        }
-    }
-    getWs(wsKey) {
-        return this.wsStore.getWs(wsKey);
-    }
-    setWsState(wsKey, state) {
-        this.wsStore.setConnectionState(wsKey, state);
-    }
-    wrongMarketError(market) {
-        return new Error(`This WS client was instanced for the ${this.options.market} market. Make another WebsocketClient instance with "market: '${market}'" to listen to ${market} topics`);
-    }
-    /** @deprecated use "market: 'spotv3" client */
-    subscribePublicSpotTrades(symbol, binary) {
-        if (this.options.market !== 'spot') {
-            throw this.wrongMarketError('spot');
-        }
-        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
-            topic: 'trade',
-            event: 'sub',
-            symbol,
-            params: {
-                binary: !!binary,
-            },
-        }));
-    }
-    /** @deprecated use "market: 'spotv3" client */
-    subscribePublicSpotTradingPair(symbol, binary) {
-        if (this.options.market !== 'spot') {
-            throw this.wrongMarketError('spot');
-        }
-        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
-            symbol,
-            topic: 'realtimes',
-            event: 'sub',
-            params: {
-                binary: !!binary,
-            },
-        }));
-    }
-    /** @deprecated use "market: 'spotv3" client */
-    subscribePublicSpotV1Kline(symbol, candleSize, binary) {
-        if (this.options.market !== 'spot') {
-            throw this.wrongMarketError('spot');
-        }
-        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
-            symbol,
-            topic: 'kline_' + candleSize,
-            event: 'sub',
-            params: {
-                binary: !!binary,
-            },
-        }));
-    }
-    //ws.send('{"symbol":"BTCUSDT","topic":"depth","event":"sub","params":{"binary":false}}');
-    //ws.send('{"symbol":"BTCUSDT","topic":"mergedDepth","event":"sub","params":{"binary":false,"dumpScale":1}}');
-    //ws.send('{"symbol":"BTCUSDT","topic":"diffDepth","event":"sub","params":{"binary":false}}');
-    /** @deprecated use "market: 'spotv3" client */
-    subscribePublicSpotOrderbook(symbol, depth, dumpScale, binary) {
-        if (this.options.market !== 'spot') {
-            throw this.wrongMarketError('spot');
-        }
-        let topic;
-        switch (depth) {
-            case 'full': {
-                topic = 'depth';
-                break;
-            }
-            case 'merge': {
-                topic = 'mergedDepth';
-                if (!dumpScale) {
-                    throw new Error('Dumpscale must be provided for merged orderbooks');
+                // WS API Success
+                try {
+                    this.getWsStore().resolveDeferredPromise(wsKey, promiseRef, Object.assign({ wsKey }, parsed), true);
+                }
+                catch (e) {
+                    this.logger.error('Exception trying to resolve WSAPI promise', {
+                        wsKey,
+                        promiseRef,
+                        parsedEvent: parsed,
+                    });
                 }
-                break;
+                results.push({
+                    eventType: 'response',
+                    event: parsed,
+                    isWSAPIResponse: true,
+                });
+                return results;
+            }
+            // Messages for a subscribed topic all include the "topic" property
+            if (typeof eventTopic === 'string') {
+                results.push({
+                    eventType: 'update',
+                    event: parsed,
+                });
+                return results;
+            }
+            // Messages that are a "reply" to a request/command (e.g. subscribe to these topics) typically include the "op" property
+            if (typeof eventOperation === 'string') {
+                // Failed request
+                if (parsed.success === false) {
+                    results.push({
+                        eventType: 'error',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // These are r  equest/reply pattern events (e.g. after subscribing to topics or authenticating)
+                if (EVENTS_RESPONSES.includes(eventOperation)) {
+                    results.push({
+                        eventType: 'response',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // Request/reply pattern for authentication success
+                if (EVENTS_AUTHENTICATED.includes(eventOperation)) {
+                    results.push({
+                        eventType: 'authenticated',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                this.logger.error(`!! Unhandled string operation type "${eventOperation}". Defaulting to "update" channel...`, parsed);
             }
-            case 'delta': {
-                topic = 'diffDepth';
-                break;
+            else {
+                this.logger.error(`!! Unhandled non-string event type "${eventOperation}". Defaulting to "update" channel...`, parsed);
             }
+            // In case of catastrophic failure, fallback to noisy emit update
+            results.push({
+                eventType: 'update',
+                event: parsed,
+            });
         }
-        const msg = {
-            symbol,
-            topic,
-            event: 'sub',
-            params: {
-                binary: !!binary,
-            },
-        };
-        if (dumpScale) {
-            msg.params.dumpScale = dumpScale;
+        catch (e) {
+            results.push({
+                event: {
+                    message: 'Failed to parse event data due to exception',
+                    exception: e,
+                    eventData: event.data,
+                },
+                eventType: 'error',
+            });
+            this.logger.error('Failed to parse event data due to exception: ', {
+                exception: e,
+                eventData: event.data,
+            });
         }
-        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify(msg));
+        return results;
     }
 }
 exports.WebsocketClient = WebsocketClient;