bybit-api 2.4.0-beta.1 → 3.0.1

package/lib/websocket-client.js

@@ -19,151 +19,168 @@ const inverse_client_1 = require("./inverse-client");
 const linear_client_1 = require("./linear-client");
 const spot_client_v3_1 = require("./spot-client-v3");
 const spot_client_1 = require("./spot-client");
-const logger_1 = require("./util/logger");
 const node_support_1 = require("./util/node-support");
 const WsStore_1 = __importDefault(require("./util/WsStore"));
 const util_1 = require("./util");
-const inverseEndpoints = {
-    livenet: 'wss://stream.bybit.com/realtime',
-    testnet: 'wss://stream-testnet.bybit.com/realtime',
-};
-const linearEndpoints = {
-    private: {
-        livenet: 'wss://stream.bybit.com/realtime_private',
-        livenet2: 'wss://stream.bytick.com/realtime_private',
-        testnet: 'wss://stream-testnet.bybit.com/realtime_private',
-    },
-    public: {
-        livenet: 'wss://stream.bybit.com/realtime_public',
-        livenet2: 'wss://stream.bytick.com/realtime_public',
-        testnet: 'wss://stream-testnet.bybit.com/realtime_public',
-    },
-};
-const spotEndpoints = {
-    private: {
-        livenet: 'wss://stream.bybit.com/spot/ws',
-        testnet: 'wss://stream-testnet.bybit.com/spot/ws',
-    },
-    public: {
-        livenet: 'wss://stream.bybit.com/spot/quote/ws/v1',
-        livenet2: 'wss://stream.bybit.com/spot/quote/ws/v2',
-        testnet: 'wss://stream-testnet.bybit.com/spot/quote/ws/v1',
-        testnet2: 'wss://stream-testnet.bybit.com/spot/quote/ws/v2',
-    },
-};
+const usdc_option_client_1 = require("./usdc-option-client");
+const usdc_perpetual_client_1 = require("./usdc-perpetual-client");
+const unified_margin_client_1 = require("./unified-margin-client");
 const loggerCategory = { category: 'bybit-ws' };
 class WebsocketClient extends events_1.EventEmitter {
     constructor(options, logger) {
         super();
-        this.logger = logger || logger_1.DefaultLogger;
+        this.logger = logger || util_1.DefaultLogger;
         this.wsStore = new WsStore_1.default(this.logger);
-        this.options = Object.assign({ livenet: false, pongTimeout: 1000, pingInterval: 10000, reconnectTimeout: 500, fetchTimeOffsetBeforeAuth: false }, options);
-        if (this.isV3()) {
-            this.restClient = new spot_client_v3_1.SpotClientV3(undefined, undefined, this.isLivenet(), this.options.restOptions, this.options.requestOptions);
-        }
-        else if (this.isLinear()) {
-            this.restClient = new linear_client_1.LinearClient(undefined, undefined, this.isLivenet(), this.options.restOptions, this.options.requestOptions);
-        }
-        else if (this.isSpot()) {
-            this.restClient = new spot_client_1.SpotClient(undefined, undefined, this.isLivenet(), this.options.restOptions, this.options.requestOptions);
-            this.connectPublic();
-        }
-        else {
-            this.restClient = new inverse_client_1.InverseClient(undefined, undefined, this.isLivenet(), this.options.restOptions, this.options.requestOptions);
-        }
-    }
-    isLivenet() {
-        return this.options.livenet === true;
-    }
-    isLinear() {
-        return this.options.market === 'linear';
-    }
-    isSpot() {
-        return this.options.market === 'spot';
-    }
-    isInverse() {
-        return this.options.market === 'inverse';
-    }
-    /** USDC, spot v3, unified margin, account asset */
-    isV3() {
-        return this.options.market === 'v3';
+        this.options = Object.assign({ testnet: false, pongTimeout: 1000, pingInterval: 10000, reconnectTimeout: 500, fetchTimeOffsetBeforeAuth: false }, options);
+        this.options.restOptions = Object.assign(Object.assign({}, this.options.restOptions), { testnet: this.options.testnet });
+        this.prepareRESTClient();
     }
     /**
-     * Add topic/topics to WS subscription list
+     * 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
      */
-    subscribe(wsTopics) {
-        const topics = Array.isArray(wsTopics) ? wsTopics : [wsTopics];
-        topics.forEach((topic) => this.wsStore.addTopic(this.getWsKeyForTopic(topic), topic));
-        // attempt to send subscription topic per websocket
-        this.wsStore.getKeys().forEach((wsKey) => {
-            // if connected, send subscription request
-            if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
-                return this.requestSubscribeTopics(wsKey, topics);
+    prepareRESTClient() {
+        switch (this.options.market) {
+            case 'inverse': {
+                this.restClient = new inverse_client_1.InverseClient(this.options.restOptions, this.options.requestOptions);
+                break;
             }
-            // 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);
+            case 'linear': {
+                this.restClient = new linear_client_1.LinearClient(this.options.restOptions, this.options.requestOptions);
+                break;
             }
-        });
-    }
-    /**
-     * Remove topic/topics from WS subscription list
-     */
-    unsubscribe(wsTopics) {
-        const topics = Array.isArray(wsTopics) ? wsTopics : [wsTopics];
-        topics.forEach((topic) => this.wsStore.deleteTopic(this.getWsKeyForTopic(topic), topic));
-        this.wsStore.getKeys().forEach((wsKey) => {
-            // unsubscribe request only necessary if active connection exists
-            if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
-                this.requestUnsubscribeTopics(wsKey, topics);
+            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;
+            }
+            default: {
+                throw util_1.neverGuard(this.options.market, `prepareRESTClient(): Unhandled market`);
+            }
+        }
     }
-    close(wsKey) {
-        var _a;
+    isTestnet() {
+        return this.options.testnet === true;
+    }
+    close(wsKey, force) {
         this.logger.info('Closing connection', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
         this.setWsState(wsKey, util_1.WsConnectionStateEnum.CLOSING);
         this.clearTimers(wsKey);
-        (_a = this.getWs(wsKey)) === null || _a === void 0 ? void 0 : _a.close();
+        const ws = this.getWs(wsKey);
+        ws === null || ws === void 0 ? void 0 : ws.close();
+        if (force) {
+            ws === null || ws === void 0 ? void 0 : ws.terminate();
+        }
+    }
+    closeAll(force) {
+        const keys = this.wsStore.getKeys();
+        keys.forEach((key) => {
+            this.close(key, force);
+        });
     }
     /**
      * Request connection of all dependent (public & private) websockets, instead of waiting for automatic connection by library
      */
     connectAll() {
-        if (this.isInverse()) {
-            return [this.connect(util_1.wsKeyInverse)];
-        }
-        if (this.isLinear()) {
-            return [
-                this.connect(util_1.wsKeyLinearPublic),
-                this.connect(util_1.wsKeyLinearPrivate),
-            ];
-        }
-        if (this.isSpot()) {
-            return [this.connect(util_1.wsKeySpotPublic), this.connect(util_1.wsKeySpotPrivate)];
+        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': {
+                return [...this.connectPublic(), this.connectPrivate()];
+            }
+            default: {
+                throw util_1.neverGuard(this.options.market, `connectAll(): Unhandled market`);
+            }
         }
     }
     connectPublic() {
-        if (this.isInverse()) {
-            return this.connect(util_1.wsKeyInverse);
-        }
-        if (this.isLinear()) {
-            return this.connect(util_1.wsKeyLinearPublic);
-        }
-        if (this.isSpot()) {
-            return this.connect(util_1.wsKeySpotPublic);
+        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),
+                ];
+            }
+            default: {
+                throw util_1.neverGuard(this.options.market, `connectPublic(): Unhandled market`);
+            }
         }
     }
     connectPrivate() {
-        if (this.isInverse()) {
-            return this.connect(util_1.wsKeyInverse);
-        }
-        if (this.isLinear()) {
-            return this.connect(util_1.wsKeyLinearPrivate);
-        }
-        if (this.isSpot()) {
-            return this.connect(util_1.wsKeySpotPrivate);
+        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);
+            }
+            default: {
+                throw util_1.neverGuard(this.options.market, `connectPrivate(): Unhandled market`);
+            }
         }
     }
     connect(wsKey) {
@@ -195,6 +212,7 @@ class WebsocketClient extends events_1.EventEmitter {
     parseWsError(context, error, wsKey) {
         if (!error.message) {
             this.logger.error(`${context} due to unexpected error: `, error);
+            this.emit('error', error);
             return;
         }
         switch (error.message) {
@@ -202,38 +220,69 @@ class WebsocketClient extends events_1.EventEmitter {
                 this.logger.error(`${context} due to 401 authorization failure.`, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
                 break;
             default:
-                this.logger.error(`{context} due to unexpected response error: ${error.msg}`, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+                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 }));
                 break;
         }
+        this.emit('error', error);
     }
     /**
      * Return params required to make authorized request
      */
     getAuthParams(wsKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { key, secret } = this.options;
-            if (key &&
-                secret &&
-                wsKey !== util_1.wsKeyLinearPublic &&
-                wsKey !== util_1.wsKeySpotPublic) {
-                this.logger.debug("Getting auth'd request params", Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-                const timeOffset = this.options.fetchTimeOffsetBeforeAuth
-                    ? yield this.restClient.fetchTimeOffset()
-                    : 0;
-                const params = {
+            if (util_1.PUBLIC_WS_KEYS.includes(wsKey)) {
+                this.logger.debug('Starting public only websocket client.', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+                return '';
+            }
+            try {
+                const { signature, expiresAt } = yield this.getWsAuthSignature(wsKey);
+                const authParams = {
                     api_key: this.options.key,
-                    expires: Date.now() + timeOffset + 5000,
+                    expires: expiresAt,
+                    signature,
                 };
-                params.signature = yield node_support_1.signMessage('GET/realtime' + params.expires, secret);
-                return '?' + util_1.serializeParams(params);
+                return '?' + util_1.serializeParams(authParams);
             }
-            else if (!key || !secret) {
-                this.logger.warning('Cannot authenticate websocket, either api or private keys missing.', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+            catch (e) {
+                this.logger.error(e, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+                return '';
             }
-            else {
-                this.logger.debug('Starting public only websocket client.', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+        });
+    }
+    sendAuthRequest(wsKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { signature, expiresAt } = yield this.getWsAuthSignature(wsKey);
+                const request = {
+                    op: 'auth',
+                    args: [this.options.key, expiresAt, signature],
+                    req_id: `${wsKey}-auth`,
+                };
+                return this.tryWsSend(wsKey, JSON.stringify(request));
+            }
+            catch (e) {
+                this.logger.error(e, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
             }
-            return '';
+        });
+    }
+    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 }));
+                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;
+            const signatureExpiresAt = Date.now() + timeOffset + 5000;
+            const signature = yield node_support_1.signMessage('GET/realtime' + signatureExpiresAt, secret);
+            return {
+                expiresAt: signatureExpiresAt,
+                signature,
+            };
         });
     }
     reconnectWithDelay(wsKey, connectionDelayMs) {
@@ -242,24 +291,32 @@ class WebsocketClient extends events_1.EventEmitter {
             util_1.WsConnectionStateEnum.CONNECTING) {
             this.setWsState(wsKey, util_1.WsConnectionStateEnum.RECONNECTING);
         }
-        setTimeout(() => {
+        this.wsStore.get(wsKey, true).activeReconnectTimer = setTimeout(() => {
             this.logger.info('Reconnecting to websocket', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
             this.connect(wsKey);
         }, connectionDelayMs);
     }
     ping(wsKey) {
+        if (this.wsStore.get(wsKey, true).activePongTimer) {
+            return;
+        }
         this.clearPongTimer(wsKey);
         this.logger.silly('Sending ping', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
         this.tryWsSend(wsKey, JSON.stringify({ op: 'ping' }));
         this.wsStore.get(wsKey, true).activePongTimer = setTimeout(() => {
             var _a;
             this.logger.info('Pong timeout - closing socket to reconnect', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-            (_a = this.getWs(wsKey)) === null || _a === void 0 ? void 0 : _a.close();
+            (_a = this.getWs(wsKey)) === null || _a === void 0 ? void 0 : _a.terminate();
+            delete this.wsStore.get(wsKey, true).activePongTimer;
         }, this.options.pongTimeout);
     }
     clearTimers(wsKey) {
         this.clearPingTimer(wsKey);
         this.clearPongTimer(wsKey);
+        const wsState = this.wsStore.get(wsKey);
+        if (wsState === null || wsState === void 0 ? void 0 : wsState.activeReconnectTimer) {
+            clearTimeout(wsState.activeReconnectTimer);
+        }
     }
     // Send a ping at intervals
     clearPingTimer(wsKey) {
@@ -285,6 +342,7 @@ class WebsocketClient extends events_1.EventEmitter {
             return;
         }
         const wsMessage = JSON.stringify({
+            req_id: topics.join(','),
             op: 'subscribe',
             args: topics,
         });
@@ -333,33 +391,60 @@ class WebsocketClient extends events_1.EventEmitter {
         return ws;
     }
     onWsOpen(event, wsKey) {
-        if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTING)) {
-            this.logger.info('Websocket connected', Object.assign(Object.assign({}, loggerCategory), { wsKey, livenet: this.isLivenet(), linear: this.isLinear(), spot: this.isSpot() }));
-            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);
-        // TODO: persistence not working yet for spot topics
-        if (wsKey !== 'spotPublic' && wsKey !== 'spotPrivate') {
-            this.requestSubscribeTopics(wsKey, [...this.wsStore.getTopics(wsKey)]);
-        }
-        this.wsStore.get(wsKey, true).activePingTimer = setInterval(() => this.ping(wsKey), this.options.pingInterval);
+        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);
+            }
+            // TODO: persistence not working yet for spot v1 topics
+            if (wsKey !== util_1.WS_KEY_MAP.spotPublic && wsKey !== util_1.WS_KEY_MAP.spotPrivate) {
+                this.requestSubscribeTopics(wsKey, [...this.wsStore.getTopics(wsKey)]);
+            }
+            this.wsStore.get(wsKey, true).activePingTimer = setInterval(() => this.ping(wsKey), this.options.pingInterval);
+        });
     }
     onWsMessage(event, wsKey) {
         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);
-            if (msg['success'] || (msg === null || msg === void 0 ? void 0 : msg.pong)) {
-                return this.onWsMessageResponse(msg, wsKey);
+            this.logger.silly('Received event', Object.assign(Object.assign({}, loggerCategory), { wsKey, msg: JSON.stringify(msg) }));
+            // TODO: cleanme
+            if (msg['success'] || (msg === null || msg === void 0 ? void 0 : msg.pong) || util_1.isWsPong(msg)) {
+                if (util_1.isWsPong(msg)) {
+                    this.logger.silly('Received pong', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+                }
+                else {
+                    this.emit('response', Object.assign(Object.assign({}, msg), { wsKey }));
+                }
+                return;
             }
-            if (msg.topic) {
-                return this.emit('update', msg);
+            if (msg['finalFragment']) {
+                return this.emit('response', Object.assign(Object.assign({}, msg), { wsKey }));
             }
-            this.logger.warning('Got unhandled ws message', Object.assign(Object.assign({}, loggerCategory), { message: msg, event,
+            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) {
@@ -369,27 +454,16 @@ class WebsocketClient extends events_1.EventEmitter {
     }
     onWsError(error, wsKey) {
         this.parseWsError('Websocket error', error, wsKey);
-        if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
-            this.emit('error', error);
-        }
     }
     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 });
+            this.emit('reconnect', { wsKey, event });
         }
         else {
             this.setWsState(wsKey, util_1.WsConnectionStateEnum.INITIAL);
-            this.emit('close', { wsKey });
-        }
-    }
-    onWsMessageResponse(response, wsKey) {
-        if (util_1.isWsPong(response)) {
-            this.logger.silly('Received pong', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-        }
-        else {
-            this.emit('response', response);
+            this.emit('close', { wsKey, event });
         }
     }
     getWs(wsKey) {
@@ -402,49 +476,109 @@ class WebsocketClient extends events_1.EventEmitter {
         if (this.options.wsUrl) {
             return this.options.wsUrl;
         }
-        const networkKey = this.isLivenet() ? 'livenet' : 'testnet';
-        // TODO: repetitive
-        if (this.isLinear() || wsKey.startsWith('linear')) {
-            if (wsKey === util_1.wsKeyLinearPublic) {
-                return linearEndpoints.public[networkKey];
+        const networkKey = this.isTestnet() ? 'testnet' : 'livenet';
+        switch (wsKey) {
+            case util_1.WS_KEY_MAP.linearPublic: {
+                return util_1.WS_BASE_URL_MAP.linear.public[networkKey];
             }
-            if (wsKey === util_1.wsKeyLinearPrivate) {
-                return linearEndpoints.private[networkKey];
+            case util_1.WS_KEY_MAP.linearPrivate: {
+                return util_1.WS_BASE_URL_MAP.linear.private[networkKey];
             }
-            this.logger.error('Unhandled linear wsKey: ', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-            return linearEndpoints[networkKey];
-        }
-        if (this.isSpot() || wsKey.startsWith('spot')) {
-            if (wsKey === util_1.wsKeySpotPublic) {
-                return spotEndpoints.public[networkKey];
+            case util_1.WS_KEY_MAP.spotPublic: {
+                return util_1.WS_BASE_URL_MAP.spot.public[networkKey];
             }
-            if (wsKey === util_1.wsKeySpotPrivate) {
-                return spotEndpoints.private[networkKey];
+            case util_1.WS_KEY_MAP.spotPrivate: {
+                return util_1.WS_BASE_URL_MAP.spot.private[networkKey];
+            }
+            case util_1.WS_KEY_MAP.spotV3Public: {
+                return util_1.WS_BASE_URL_MAP.spotv3.public[networkKey];
+            }
+            case util_1.WS_KEY_MAP.spotV3Private: {
+                return util_1.WS_BASE_URL_MAP.spotv3.private[networkKey];
+            }
+            case util_1.WS_KEY_MAP.inverse: {
+                // private and public are on the same WS connection
+                return util_1.WS_BASE_URL_MAP.inverse.public[networkKey];
+            }
+            case util_1.WS_KEY_MAP.usdcOptionPublic: {
+                return util_1.WS_BASE_URL_MAP.usdcOption.public[networkKey];
+            }
+            case util_1.WS_KEY_MAP.usdcOptionPrivate: {
+                return util_1.WS_BASE_URL_MAP.usdcOption.private[networkKey];
+            }
+            case util_1.WS_KEY_MAP.usdcPerpPublic: {
+                return util_1.WS_BASE_URL_MAP.usdcPerp.public[networkKey];
+            }
+            case util_1.WS_KEY_MAP.usdcPerpPrivate: {
+                return util_1.WS_BASE_URL_MAP.usdcPerp.private[networkKey];
+            }
+            case util_1.WS_KEY_MAP.unifiedOptionPublic: {
+                return util_1.WS_BASE_URL_MAP.unifiedOption.public[networkKey];
+            }
+            case util_1.WS_KEY_MAP.unifiedPerpUSDTPublic: {
+                return util_1.WS_BASE_URL_MAP.unifiedPerpUSDT.public[networkKey];
+            }
+            case util_1.WS_KEY_MAP.unifiedPerpUSDCPublic: {
+                return util_1.WS_BASE_URL_MAP.unifiedPerpUSDC.public[networkKey];
+            }
+            case util_1.WS_KEY_MAP.unifiedPrivate: {
+                return util_1.WS_BASE_URL_MAP.unifiedPerp.private[networkKey];
+            }
+            default: {
+                this.logger.error('getWsUrl(): Unhandled wsKey: ', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
+                throw util_1.neverGuard(wsKey, `getWsUrl(): Unhandled wsKey`);
             }
-            this.logger.error('Unhandled spot wsKey: ', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-            return spotEndpoints[networkKey];
-        }
-        // fallback to inverse
-        return inverseEndpoints[networkKey];
-    }
-    getWsKeyForTopic(topic) {
-        if (this.isInverse()) {
-            return util_1.wsKeyInverse;
-        }
-        if (this.isLinear()) {
-            return util_1.getLinearWsKeyForTopic(topic);
         }
-        return util_1.getSpotWsKeyForTopic(topic);
     }
     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 spot topics`);
     }
-    // TODO: persistance for subbed topics. Look at ftx-api implementation.
+    /**
+     * Add topic/topics to WS subscription list
+     * @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];
+        topics.forEach((topic) => this.wsStore.addTopic(util_1.getWsKeyForTopic(this.options.market, topic, isPrivateTopic), topic));
+        // attempt to send subscription topic per websocket
+        this.wsStore.getKeys().forEach((wsKey) => {
+            // if connected, send subscription request
+            if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
+                return this.requestSubscribeTopics(wsKey, [
+                    ...this.wsStore.getTopics(wsKey),
+                ]);
+            }
+            // 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);
+            }
+        });
+    }
+    /**
+     * Remove topic/topics from WS subscription list
+     * @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];
+        topics.forEach((topic) => this.wsStore.deleteTopic(util_1.getWsKeyForTopic(this.options.market, topic, isPrivateTopic), topic));
+        this.wsStore.getKeys().forEach((wsKey) => {
+            // unsubscribe request only necessary if active connection exists
+            if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
+                this.requestUnsubscribeTopics(wsKey, [
+                    ...this.wsStore.getTopics(wsKey),
+                ]);
+            }
+        });
+    }
+    /** @deprecated use "market: 'spotv3" client */
     subscribePublicSpotTrades(symbol, binary) {
-        if (!this.isSpot()) {
+        if (this.options.market !== 'spot') {
             throw this.wrongMarketError('spot');
         }
-        return this.tryWsSend(util_1.wsKeySpotPublic, JSON.stringify({
+        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
             topic: 'trade',
             event: 'sub',
             symbol,
@@ -453,11 +587,12 @@ class WebsocketClient extends events_1.EventEmitter {
             },
         }));
     }
+    /** @deprecated use "market: 'spotv3" client */
     subscribePublicSpotTradingPair(symbol, binary) {
-        if (!this.isSpot()) {
+        if (this.options.market !== 'spot') {
             throw this.wrongMarketError('spot');
         }
-        return this.tryWsSend(util_1.wsKeySpotPublic, JSON.stringify({
+        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
             symbol,
             topic: 'realtimes',
             event: 'sub',
@@ -466,11 +601,12 @@ class WebsocketClient extends events_1.EventEmitter {
             },
         }));
     }
+    /** @deprecated use "market: 'spotv3" client */
     subscribePublicSpotV1Kline(symbol, candleSize, binary) {
-        if (!this.isSpot()) {
+        if (this.options.market !== 'spot') {
             throw this.wrongMarketError('spot');
         }
-        return this.tryWsSend(util_1.wsKeySpotPublic, JSON.stringify({
+        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
             symbol,
             topic: 'kline_' + candleSize,
             event: 'sub',
@@ -482,8 +618,9 @@ class WebsocketClient extends events_1.EventEmitter {
     //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.isSpot()) {
+        if (this.options.market !== 'spot') {
             throw this.wrongMarketError('spot');
         }
         let topic;
@@ -515,7 +652,7 @@ class WebsocketClient extends events_1.EventEmitter {
         if (dumpScale) {
             msg.params.dumpScale = dumpScale;
         }
-        return this.tryWsSend(util_1.wsKeySpotPublic, JSON.stringify(msg));
+        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify(msg));
     }
 }
 exports.WebsocketClient = WebsocketClient;