bybit-api 2.3.2 → 2.4.0-beta.2

package/lib/websocket-client.js

@@ -12,205 +12,150 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebsocketClient = exports.wsKeySpotPublic = exports.wsKeySpotPrivate = exports.wsKeyLinearPublic = exports.wsKeyLinearPrivate = exports.wsKeyInverse = exports.WsConnectionState = void 0;
+exports.WebsocketClient = void 0;
 const events_1 = require("events");
 const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
 const inverse_client_1 = require("./inverse-client");
 const linear_client_1 = require("./linear-client");
-const logger_1 = require("./logger");
+const spot_client_v3_1 = require("./spot-client-v3");
 const spot_client_1 = require("./spot-client");
 const node_support_1 = require("./util/node-support");
-const requestUtils_1 = require("./util/requestUtils");
 const WsStore_1 = __importDefault(require("./util/WsStore"));
-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 util_1 = require("./util");
+const usdc_option_client_1 = require("./usdc-option-client");
+const usdc_perpetual_client_1 = require("./usdc-perpetual-client");
 const loggerCategory = { category: 'bybit-ws' };
-const READY_STATE_INITIAL = 0;
-const READY_STATE_CONNECTING = 1;
-const READY_STATE_CONNECTED = 2;
-const READY_STATE_CLOSING = 3;
-const READY_STATE_RECONNECTING = 4;
-var WsConnectionState;
-(function (WsConnectionState) {
-    WsConnectionState[WsConnectionState["READY_STATE_INITIAL"] = 0] = "READY_STATE_INITIAL";
-    WsConnectionState[WsConnectionState["READY_STATE_CONNECTING"] = 1] = "READY_STATE_CONNECTING";
-    WsConnectionState[WsConnectionState["READY_STATE_CONNECTED"] = 2] = "READY_STATE_CONNECTED";
-    WsConnectionState[WsConnectionState["READY_STATE_CLOSING"] = 3] = "READY_STATE_CLOSING";
-    WsConnectionState[WsConnectionState["READY_STATE_RECONNECTING"] = 4] = "READY_STATE_RECONNECTING";
-})(WsConnectionState = exports.WsConnectionState || (exports.WsConnectionState = {}));
-exports.wsKeyInverse = 'inverse';
-exports.wsKeyLinearPrivate = 'linearPrivate';
-exports.wsKeyLinearPublic = 'linearPublic';
-exports.wsKeySpotPrivate = 'spotPrivate';
-exports.wsKeySpotPublic = 'spotPublic';
-const getLinearWsKeyForTopic = (topic) => {
-    const privateLinearTopics = [
-        'position',
-        'execution',
-        'order',
-        'stop_order',
-        'wallet',
-    ];
-    if (privateLinearTopics.includes(topic)) {
-        return exports.wsKeyLinearPrivate;
-    }
-    return exports.wsKeyLinearPublic;
-};
-const getSpotWsKeyForTopic = (topic) => {
-    const privateLinearTopics = [
-        'position',
-        'execution',
-        'order',
-        'stop_order',
-        'outboundAccountInfo',
-        'executionReport',
-        'ticketInfo',
-    ];
-    if (privateLinearTopics.includes(topic)) {
-        return exports.wsKeySpotPrivate;
-    }
-    return exports.wsKeySpotPublic;
-};
-function resolveMarket(options) {
-    if (options.linear) {
-        return 'linear';
-    }
-    return 'inverse';
-}
 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.options.market) {
-            this.options.market = resolveMarket(this.options);
-        }
-        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.isLinear() && !this.isSpot();
+        this.options = Object.assign({ testnet: false, pongTimeout: 1000, pingInterval: 10000, reconnectTimeout: 500, fetchTimeOffsetBeforeAuth: false }, options);
+        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, READY_STATE_CONNECTED)) {
-                return this.requestSubscribeTopics(wsKey, topics);
+    prepareRESTClient() {
+        switch (this.options.market) {
+            case 'inverse': {
+                this.restClient = new inverse_client_1.InverseClient(undefined, undefined, !this.isTestnet(), 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, READY_STATE_CONNECTING) &&
-                !this.wsStore.isConnectionState(wsKey, READY_STATE_RECONNECTING)) {
-                return this.connect(wsKey);
+            case 'linear': {
+                this.restClient = new linear_client_1.LinearClient(undefined, undefined, !this.isTestnet(), 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, READY_STATE_CONNECTED)) {
-                this.requestUnsubscribeTopics(wsKey, topics);
+            case 'spot': {
+                this.restClient = new spot_client_1.SpotClient(undefined, undefined, !this.isTestnet(), this.options.restOptions, this.options.requestOptions);
+                this.connectPublic();
+                break;
             }
-        });
+            case 'spotv3': {
+                this.restClient = new spot_client_v3_1.SpotClientV3(undefined, undefined, !this.isTestnet(), this.options.restOptions, this.options.requestOptions);
+                break;
+            }
+            case 'usdcOption': {
+                this.restClient = new usdc_option_client_1.USDCOptionClient(undefined, undefined, !this.isTestnet(), this.options.restOptions, this.options.requestOptions);
+                break;
+            }
+            case 'usdcPerp': {
+                this.restClient = new usdc_perpetual_client_1.USDCPerpetualClient(undefined, undefined, !this.isTestnet(), this.options.restOptions, this.options.requestOptions);
+                break;
+            }
+            default: {
+                throw util_1.neverGuard(this.options.market, `prepareRESTClient(): Unhandled market`);
+            }
+        }
+    }
+    isTestnet() {
+        return this.options.testnet === true;
     }
     close(wsKey) {
         var _a;
         this.logger.info('Closing connection', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-        this.setWsState(wsKey, READY_STATE_CLOSING);
+        this.setWsState(wsKey, util_1.WsConnectionStateEnum.CLOSING);
         this.clearTimers(wsKey);
         (_a = this.getWs(wsKey)) === null || _a === void 0 ? void 0 : _a.close();
     }
+    closeAll() {
+        const keys = this.wsStore.getKeys();
+        keys.forEach((key) => {
+            this.close(key);
+        });
+    }
     /**
-     * Request connection of all dependent websockets, instead of waiting for automatic connection by library
+     * Request connection of all dependent (public & private) websockets, instead of waiting for automatic connection by library
      */
     connectAll() {
-        if (this.isInverse()) {
-            return [this.connect(exports.wsKeyInverse)];
-        }
-        if (this.isLinear()) {
-            return [
-                this.connect(exports.wsKeyLinearPublic),
-                this.connect(exports.wsKeyLinearPrivate),
-            ];
-        }
-        if (this.isSpot()) {
-            return [this.connect(exports.wsKeySpotPublic), this.connect(exports.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': {
+                return [this.connectPublic(), this.connectPrivate()];
+            }
+            default: {
+                throw util_1.neverGuard(this.options.market, `connectAll(): Unhandled market`);
+            }
         }
     }
     connectPublic() {
-        if (this.isInverse()) {
-            return this.connect(exports.wsKeyInverse);
-        }
-        if (this.isLinear()) {
-            return this.connect(exports.wsKeyLinearPublic);
-        }
-        if (this.isSpot()) {
-            return this.connect(exports.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);
+            }
+            default: {
+                throw util_1.neverGuard(this.options.market, `connectPublic(): Unhandled market`);
+            }
         }
     }
     connectPrivate() {
-        if (this.isInverse()) {
-            return this.connect(exports.wsKeyInverse);
-        }
-        if (this.isLinear()) {
-            return this.connect(exports.wsKeyLinearPrivate);
-        }
-        if (this.isSpot()) {
-            return this.connect(exports.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);
+            }
+            default: {
+                throw util_1.neverGuard(this.options.market, `connectPrivate(): Unhandled market`);
+            }
         }
     }
     connect(wsKey) {
@@ -220,13 +165,13 @@ class WebsocketClient extends events_1.EventEmitter {
                     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, READY_STATE_CONNECTING)) {
+                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;
                 }
                 if (!this.wsStore.getConnectionState(wsKey) ||
-                    this.wsStore.isConnectionState(wsKey, READY_STATE_INITIAL)) {
-                    this.setWsState(wsKey, READY_STATE_CONNECTING);
+                    this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.INITIAL)) {
+                    this.setWsState(wsKey, util_1.WsConnectionStateEnum.CONNECTING);
                 }
                 const authParams = yield this.getAuthParams(wsKey);
                 const url = this.getWsUrl(wsKey) + authParams;
@@ -242,6 +187,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('errorEvent', error);
             return;
         }
         switch (error.message) {
@@ -252,43 +198,75 @@ class WebsocketClient extends events_1.EventEmitter {
                 this.logger.error(`{context} due to unexpected response error: ${error.msg}`, Object.assign(Object.assign({}, loggerCategory), { wsKey }));
                 break;
         }
+        this.emit('errorEvent', 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 !== exports.wsKeyLinearPublic &&
-                wsKey !== exports.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 '?' + requestUtils_1.serializeParams(params);
+                return '?' + util_1.serializeParams(authParams);
             }
-            else if (!key || !secret) {
-                this.logger.warning('Connot 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) {
         this.clearTimers(wsKey);
-        if (this.wsStore.getConnectionState(wsKey) !== READY_STATE_CONNECTING) {
-            this.setWsState(wsKey, READY_STATE_RECONNECTING);
+        if (this.wsStore.getConnectionState(wsKey) !==
+            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);
@@ -306,6 +284,10 @@ class WebsocketClient extends events_1.EventEmitter {
     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) {
@@ -331,6 +313,7 @@ class WebsocketClient extends events_1.EventEmitter {
             return;
         }
         const wsMessage = JSON.stringify({
+            req_id: topics.join(','),
             op: 'subscribe',
             args: topics,
         });
@@ -379,36 +362,61 @@ class WebsocketClient extends events_1.EventEmitter {
         return ws;
     }
     onWsOpen(event, wsKey) {
-        if (this.wsStore.isConnectionState(wsKey, READY_STATE_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, READY_STATE_RECONNECTING)) {
-            this.logger.info('Websocket reconnected', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-            this.emit('reconnected', { wsKey, event });
-        }
-        this.setWsState(wsKey, READY_STATE_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 ('success' in msg || (msg === null || msg === void 0 ? void 0 : msg.pong)) {
-                this.onWsMessageResponse(msg, wsKey);
+            this.logger.silly('Received event', Object.assign(Object.assign({}, this.logger), { wsKey, msg: JSON.stringify(msg, null, 2) }));
+            // 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', msg);
+                }
+                return;
+            }
+            if (msg['finalFragment']) {
+                return this.emit('response', msg);
             }
-            else if (msg.topic) {
-                this.onWsMessageUpdate(msg);
+            if (msg === null || msg === void 0 ? void 0 : msg.topic) {
+                return this.emit('update', msg);
             }
-            else {
-                this.logger.warning('Got unhandled ws message', Object.assign(Object.assign({}, loggerCategory), { message: msg, event,
-                    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('errorEvent', msg);
             }
+            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,
@@ -417,32 +425,21 @@ class WebsocketClient extends events_1.EventEmitter {
     }
     onWsError(error, wsKey) {
         this.parseWsError('Websocket error', error, wsKey);
-        if (this.wsStore.isConnectionState(wsKey, READY_STATE_CONNECTED)) {
-            this.emit('error', error);
+        if (this.wsStore.isConnectionState(wsKey, util_1.WsConnectionStateEnum.CONNECTED)) {
+            this.emit('errorEvent', error);
         }
     }
     onWsClose(event, wsKey) {
         this.logger.info('Websocket connection closed', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-        if (this.wsStore.getConnectionState(wsKey) !== READY_STATE_CLOSING) {
+        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, READY_STATE_INITIAL);
-            this.emit('close', { wsKey });
+            this.setWsState(wsKey, util_1.WsConnectionStateEnum.INITIAL);
+            this.emit('close', { wsKey, event });
         }
     }
-    onWsMessageResponse(response, wsKey) {
-        if (requestUtils_1.isWsPong(response)) {
-            this.logger.silly('Received pong', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-        }
-        else {
-            this.emit('response', response);
-        }
-    }
-    onWsMessageUpdate(message) {
-        this.emit('update', message);
-    }
     getWs(wsKey) {
         return this.wsStore.getWs(wsKey);
     }
@@ -453,49 +450,93 @@ class WebsocketClient extends events_1.EventEmitter {
         if (this.options.wsUrl) {
             return this.options.wsUrl;
         }
-        const networkKey = this.isLivenet() ? 'livenet' : 'testnet';
-        // TODO: reptitive
-        if (this.isLinear() || wsKey.startsWith('linear')) {
-            if (wsKey === exports.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 === exports.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 === exports.wsKeySpotPublic) {
-                return spotEndpoints.public[networkKey];
+            case util_1.WS_KEY_MAP.spotPublic: {
+                return util_1.WS_BASE_URL_MAP.spot.public[networkKey];
             }
-            if (wsKey === exports.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];
+            }
+            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 exports.wsKeyInverse;
-        }
-        if (this.isLinear()) {
-            return getLinearWsKeyForTopic(topic);
         }
-        return 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, topics);
+            }
+            // 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, topics);
+            }
+        });
+    }
+    /** @deprecated use "market: 'spotv3" client */
     subscribePublicSpotTrades(symbol, binary) {
-        if (!this.isSpot()) {
+        if (this.options.market !== 'spot') {
             throw this.wrongMarketError('spot');
         }
-        return this.tryWsSend(exports.wsKeySpotPublic, JSON.stringify({
+        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
             topic: 'trade',
             event: 'sub',
             symbol,
@@ -504,11 +545,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(exports.wsKeySpotPublic, JSON.stringify({
+        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
             symbol,
             topic: 'realtimes',
             event: 'sub',
@@ -517,11 +559,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(exports.wsKeySpotPublic, JSON.stringify({
+        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify({
             symbol,
             topic: 'kline_' + candleSize,
             event: 'sub',
@@ -533,8 +576,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;
@@ -566,7 +610,7 @@ class WebsocketClient extends events_1.EventEmitter {
         if (dumpScale) {
             msg.params.dumpScale = dumpScale;
         }
-        return this.tryWsSend(exports.wsKeySpotPublic, JSON.stringify(msg));
+        return this.tryWsSend(util_1.WS_KEY_MAP.spotPublic, JSON.stringify(msg));
     }
 }
 exports.WebsocketClient = WebsocketClient;