binance 2.15.14 → 3.0.0-beta.1

package/lib/websocket-client.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -31,812 +8,1097 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebsocketClient = exports.parseRawWsMessage = void 0;
-const events_1 = require("events");
-const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
-const coinm_client_1 = require("./coinm-client");
-const logger_1 = require("./logger");
-const main_client_1 = require("./main-client");
-const usdm_client_1 = require("./usdm-client");
+exports.WebsocketClient = void 0;
+const BaseWSClient_1 = require("./util/BaseWSClient");
 const beautifier_1 = __importDefault(require("./util/beautifier"));
 const requestUtils_1 = require("./util/requestUtils");
-const ws_utils_1 = require("./util/ws-utils");
-const WsStore_1 = __importStar(require("./util/WsStore"));
-const wsBaseEndpoints = {
-    spot: 'wss://stream.binance.com:9443',
-    margin: 'wss://stream.binance.com:9443',
-    isolatedMargin: 'wss://stream.binance.com:9443',
-    usdm: 'wss://fstream.binance.com',
-    usdmTestnet: 'wss://stream.binancefuture.com',
-    coinm: 'wss://dstream.binance.com',
-    coinmTestnet: 'wss://dstream.binancefuture.com',
-    options: 'wss://vstream.binance.com',
-    optionsTestnet: 'wss://testnetws.binanceops.com',
-};
-const loggerCategory = { category: 'binance-ws' };
-function throwUnhandledSwitch(x, msg) {
-    throw new Error(msg);
-}
-function parseEventTypeFromMessage(parsedMsg) {
-    var _a;
-    if (parsedMsg === null || parsedMsg === void 0 ? void 0 : parsedMsg.e) {
-        return parsedMsg.e;
-    }
-    if (Array.isArray(parsedMsg) && parsedMsg.length) {
-        return (_a = parsedMsg[0]) === null || _a === void 0 ? void 0 : _a.e;
-    }
-    return;
-}
+const typeGuards_1 = require("./util/typeGuards");
+const webCryptoAPI_1 = require("./util/webCryptoAPI");
+const rest_client_cache_1 = require("./util/websockets/rest-client-cache");
+const user_data_stream_manager_1 = require("./util/websockets/user-data-stream-manager");
+const websocket_util_1 = require("./util/websockets/websocket-util");
+const WS_LOGGER_CATEGORY = { category: 'binance-ws' };
 /**
- * Try to resolve event.data. Example circumstance: {"stream":"!forceOrder@arr","data":{"e":"forceOrder","E":1634653599186,"o":{"s":"IOTXUSDT","S":"SELL","o":"LIMIT","f":"IOC","q":"3661","p":"0.06606","ap":"0.06669","X":"FILLED","l":"962","z":"3661","T":1634653599180}}}
+ * Multiplex Node.js, JavaScript & TypeScript Websocket Client for all of Binance's available WebSockets.
+ *
+ * When possible, it will subscribe to all requested topics on a single websocket connection. A list of
+ * all available streams can be seen in the WS_KEY_URL_MAP found in util/websockets/websocket-util.ts.
+ *
+ * Connectivity is automatically maintained. If disconnected, the WebsocketClient will automatically
+ * clean out the old dead connection, respawn a fresh one and resubscribe to all the requested topics.
+ *
+ * If any connection is reconnected, the WS client will:
+ * - Emit the "reconnecting" event when the process begins.
+ * - Emit the "reconnected" event, when the process has completed. When this event arrives, it is often a
+ * good time to execute any synchorisation workflow (e.g. via the REST API) if any information was missed
+ * while disconnected.
+ *
+ * User data streams will use a dedicated connection per stream for increased resilience.
  */
-function parseRawWsMessage(event) {
-    if (typeof event === 'string') {
-        const parsedEvent = JSON.parse(event);
-        if (parsedEvent.data) {
-            if (typeof parsedEvent.data === 'string') {
-                return parseRawWsMessage(parsedEvent.data);
-            }
-            return parsedEvent.data;
-        }
-    }
-    if (event === null || event === void 0 ? void 0 : event.data) {
-        return JSON.parse(event.data);
-    }
-    return event;
-}
-exports.parseRawWsMessage = parseRawWsMessage;
-class WebsocketClient extends events_1.EventEmitter {
+class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
     constructor(options, logger) {
-        super();
-        this.logger = logger || logger_1.DefaultLogger;
-        this.wsStore = new WsStore_1.default(this.logger);
-        this.beautifier = new beautifier_1.default();
-        this.restClients = {};
-        this.options = Object.assign({ pongTimeout: 7500, pingInterval: 10000, reconnectTimeout: 500 }, options);
-        this.listenKeyStateStore = {};
-        this.wsUrlKeyMap = {};
-        // add default error handling so this doesn't crash node (if the user didn't set a handler)
-        this.on('error', () => { });
+        super(options, logger);
+        this.restClientCache = new rest_client_cache_1.RestClientCache();
+        this.beautifier = new beautifier_1.default({
+            warnKeyMissingInMap: true,
+        });
+        this.respawnTimeoutCache = {};
+        this.userDataStreamManager = new user_data_stream_manager_1.UserDataStreamManager({
+            logger: this.logger,
+            wsStore: this.getWsStore(),
+            restClientCache: this.restClientCache,
+            // fn pointers:
+            respawnUserDataFn: (wsKey, market, context = {}) => this.respawnUserDataStream(wsKey, market, context),
+            getWsUrlFn: (wsKey, connectionType) => this.getWsUrl(wsKey, connectionType),
+            getRestClientOptionsFn: () => this.getRestClientOptions(),
+            getWsClientOptionsfn: () => this.options,
+            closeWsFn: (wsKey, force) => this.close(wsKey, force),
+            connectFn: (wsKey, customUrl, throwOnError) => this.connect(wsKey, customUrl, throwOnError),
+        });
+    }
+    getUserDataStreamManager() {
+        return this.userDataStreamManager;
     }
     getRestClientOptions() {
         return Object.assign(Object.assign(Object.assign({}, this.options), this.options.restOptions), { api_key: this.options.api_key, api_secret: this.options.api_secret });
     }
-    connectToWsUrl(url, wsKey, forceNewConnection) {
-        const wsRefKey = wsKey || url;
-        const oldWs = this.wsStore.getWs(wsRefKey);
-        if (oldWs && this.wsStore.isWsOpen(wsRefKey) && !forceNewConnection) {
-            this.logger.silly('connectToWsUrl(): Returning existing open WS connection', Object.assign(Object.assign({}, loggerCategory), { wsRefKey }));
-            return oldWs;
-        }
-        this.logger.silly(`connectToWsUrl(): Opening WS connection to URL: ${url}`, Object.assign(Object.assign({}, loggerCategory), { wsRefKey }));
-        const _a = this.options.wsOptions || {}, { protocols = [] } = _a, wsOptions = __rest(_a, ["protocols"]);
-        const ws = new isomorphic_ws_1.default(url, protocols, wsOptions);
-        this.wsUrlKeyMap[url] = wsRefKey;
-        if (typeof ws.on === 'function') {
-            ws.on('ping', (event) => this.onWsPing(event, wsRefKey, ws, 'event'));
-            ws.on('pong', (event) => this.onWsPong(event, wsRefKey, 'event'));
-        }
-        ws.onopen = (event) => this.onWsOpen(event, wsRefKey, url);
-        ws.onerror = (event) => this.parseWsError('WS Error Event', event, wsRefKey, url);
-        ws.onclose = (event) => this.onWsClose(event, wsRefKey, ws, url);
-        ws.onmessage = (event) => this.onWsMessage(event, wsRefKey, 'function');
-        // Not sure these work in the browser, the traditional event listeners are required for ping/pong frames in node
-        ws.onping = (event) => this.onWsPing(event, wsRefKey, ws, 'function');
-        ws.onpong = (event) => this.onWsPong(event, wsRefKey, 'function');
-        // Add ws connection with key to store
-        this.wsStore.setWs(wsRefKey, ws);
-        ws.wsKey = wsRefKey;
-        return ws;
-    }
-    tryWsSend(wsKey, wsMessage) {
+    /**
+     * Request connection of all dependent (public & WS API) websockets in prod, instead of waiting
+     * for automatic connection by SDK. TODO: also do the user data streams?
+     */
+    connectAll() {
+        return this.connectPublic();
+    }
+    /**
+     * 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).
+     */
+    connectWSAPI(wsKey) {
+        /** This call automatically ensures the connection is active AND authenticated before resolving */
+        return this.assertIsAuthenticated(wsKey);
+    }
+    /**
+     * Request connection to all public websockets in prod (spot, margin, futures, options). Overkill if
+     * you're only working with one product group.
+     */
+    connectPublic() {
+        return [
+            this.connect(websocket_util_1.WS_KEY_MAP.main),
+            this.connect(websocket_util_1.WS_KEY_MAP.usdm),
+            this.connect(websocket_util_1.WS_KEY_MAP.coinm),
+            this.connect(websocket_util_1.WS_KEY_MAP.eoptions),
+        ];
+    }
+    connectPrivate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // switch (this.options.market) {
+            //   case 'v5':
+            //   default: {
+            //     return this.connect(WS_KEY_MAP.v5Private);
+            //   }
+            // }
+            // TODO:
+            return;
+        });
+    }
+    /**
+     * 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
+     */
+    subscribe(requests, wsKey) {
+        const topicRequests = Array.isArray(requests) ? requests : [requests];
+        const normalisedTopicRequests = (0, websocket_util_1.getNormalisedTopicRequests)(topicRequests);
+        return this.subscribeTopicsForWsKey(normalisedTopicRequests, wsKey);
+    }
+    /**
+     * 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, websocket_util_1.getNormalisedTopicRequests)(topicRequests);
+        return this.unsubscribeTopicsForWsKey(normalisedTopicRequests, wsKey);
+    }
+    // These overloads give stricter types than mapped generics, since generic constraints
+    // do not trigger excess property checks
+    // Without these overloads, TypeScript won't complain if you include an
+    // unexpected property with your request (if it doesn't clash with an existing property)
+    // sendWSAPIRequest<TWSOpreation extends WSAPIOperation = 'order.create'>(
+    //   wsKey: typeof WS_KEY_MAP.v5PrivateTrade,
+    //   operation: TWSOpreation,
+    //   params: WsAPITopicRequestParamMap[TWSOpreation],
+    // ): Promise<WsAPIOperationResponseMap[TWSOpreation]>;
+    // sendWSAPIRequest<TWSOpreation extends WSAPIOperation = 'order.amend'>(
+    //   wsKey: typeof WS_KEY_MAP.v5PrivateTrade,
+    //   operation: TWSOpreation,
+    //   params: WsAPITopicRequestParamMap[TWSOpreation],
+    // ): Promise<WsAPIOperationResponseMap[TWSOpreation]>;
+    // sendWSAPIRequest<TWSOpreation extends WSAPIOperation = 'order.cancel'>(
+    //   wsKey: typeof WS_KEY_MAP.v5PrivateTrade,
+    //   operation: TWSOpreation,
+    //   params: WsAPITopicRequestParamMap[TWSOpreation],
+    // ): Promise<WsAPIOperationResponseMap[TWSOpreation]>;
+    sendWSAPIRequest(wsKey, operation, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //WsAPIOperationResponseMap[TWSOperation]> {
+            /**
+             * Spot: https://developers.binance.com/docs/binance-spot-api-docs/web-socket-api/general-api-information
+             */
+            // 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 request = {
+                id: this.getNewRequestId(),
+                method: operation,
+                params: Object.assign({ timestamp: Date.now(), recvWindow: this.options.recvWindow }, params),
+            };
+            if ((0, requestUtils_1.requiresWSAPINewClientOID)(request, wsKey)) {
+                (0, requestUtils_1.validateWSAPINewClientOID)(request, wsKey);
+            }
+            // Sign, if needed
+            const signedEvent = yield this.signWSAPIRequest(request);
+            // Store deferred promise, resolved within the "resolveEmittableEvents" method while parsing incoming events
+            const promiseRef = (0, websocket_util_1.getPromiseRefForWSAPIRequest)(wsKey, signedEvent);
+            const deferredPromise = this.getWsStore().createDeferredPromise(wsKey, promiseRef, false);
+            // this.logger.trace(
+            //   `sendWSAPIRequest(): sending raw request: ${JSON.stringify(signedEvent)} with promiseRef(${promiseRef})`,
+            // );
+            // Send event
+            this.tryWsSend(wsKey, JSON.stringify(signedEvent));
+            this.logger.trace(`sendWSAPIRequest(): sent "${operation}" event with promiseRef(${promiseRef})`);
+            // 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_1) {
+        return __awaiter(this, arguments, void 0, function* (wsKey, connectionType = 'market') {
+            const wsBaseURL = (0, websocket_util_1.getWsUrl)(wsKey, this.options, this.logger) +
+                (0, websocket_util_1.getWsURLSuffix)(wsKey, connectionType);
+            return wsBaseURL;
+        });
+    }
+    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);
+        });
+    }
+    signWSAPIRequest(requestEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Not needed for Binance. Auth happens only on connection open, automatically.
+            // Faster than performing auth for every request
+            return requestEvent;
+        });
+    }
+    getWsAuthRequestEvent(wsKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Note: Only Ed25519 keys are supported for this feature.
+                // If you do not want to specify apiKey and signature in each individual request, you can authenticate your API key for the active WebSocket session.
+                // Once authenticated, you no longer have to specify apiKey and signature for those requests that need them. Requests will be performed on behalf of the account owning the authenticated API key.
+                // Note: You still have to specify the timestamp parameter for SIGNED requests.
+                const recvWindow = this.options.recvWindow || 0;
+                const timestamp = Date.now() + (this.getTimeOffsetMs() || 0) + recvWindow;
+                const strictParamValidation = true;
+                const encodeValues = true;
+                const filterUndefinedParams = true;
+                const authParams = {
+                    apiKey: this.options.api_key,
+                    timestamp,
+                };
+                const serialisedParams = (0, requestUtils_1.serialiseParams)(authParams, strictParamValidation, encodeValues, filterUndefinedParams);
+                const signature = yield this.signMessage(serialisedParams, this.options.api_secret, 'base64', 'SHA-256');
+                // https://developers.binance.com/docs/binance-spot-api-docs/web-socket-api/request-security#signed-request-example-ed25519
+                const request = {
+                    id: this.getNewRequestId(),
+                    method: 'session.logon',
+                    params: Object.assign(Object.assign({}, authParams), { signature }),
+                };
+                return request;
+            }
+            catch (e) {
+                this.logger.error(e, Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey }));
+                throw e;
+            }
+        });
+    }
+    // private async getWsAuthSignature(
+    //   wsKey: WsKey,
+    // ): Promise<{ expiresAt: number; signature: string }> {
+    //   const { api_key, api_secret } = this.options;
+    //   if (!api_key || !api_secret) {
+    //     this.logger.error(
+    //       'Cannot authenticate websocket, either api or private keys missing.',
+    //       { ...WS_LOGGER_CATEGORY, wsKey },
+    //     );
+    //     throw new Error('Cannot auth - missing api or secret in config');
+    //   }
+    //   this.logger.trace("Getting auth'd request params", {
+    //     ...WS_LOGGER_CATEGORY,
+    //     wsKey,
+    //   });
+    //   const recvWindow = this.options.recvWindow || 5000;
+    //   const signatureExpiresAt = Date.now() + this.getTimeOffsetMs() + recvWindow;
+    //   // const signature = await this.signMessage(
+    //   //   'GET/realtime' + signatureExpiresAt,
+    //   //   api_secret,
+    //   //   'hex',
+    //   //   'SHA-256',
+    //   // );
+    //   return {
+    //     expiresAt: signatureExpiresAt,
+    //     signature: '',
+    //   };
+    // }
+    sendPingEvent(wsKey) {
         try {
-            this.logger.silly('Sending upstream ws message: ', Object.assign(Object.assign({}, loggerCategory), { wsMessage,
-                wsKey }));
+            // this.logger.trace(`Sending upstream ping: `, { ...loggerCategory, wsKey });
             if (!wsKey) {
                 throw new Error('No wsKey provided');
             }
-            const ws = this.getWs(wsKey);
+            const ws = this.getWsStore().getWs(wsKey);
             if (!ws) {
                 throw new Error(`No active websocket connection exists for wsKey: ${wsKey}`);
             }
-            ws.send(wsMessage);
+            // Binance allows unsolicited pongs, so we send both (though we expect a pong in response to our ping if the connection is still alive)
+            if (ws.readyState === 1) {
+                ws.ping();
+                ws.pong();
+            }
+            else {
+                this.logger.trace('WS ready state not open - refusing to send WS ping', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey, readyState: ws === null || ws === void 0 ? void 0 : ws.readyState }));
+            }
         }
         catch (e) {
-            this.logger.error('Failed to send WS message', Object.assign(Object.assign({}, loggerCategory), { wsMessage,
-                wsKey, exception: e }));
+            this.logger.error('Failed to send WS ping', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey, exception: e }));
         }
     }
-    tryWsPing(wsKey) {
+    sendPongEvent(wsKey) {
+        // ws.pong();
         try {
-            // this.logger.silly(`Sending upstream ping: `, { ...loggerCategory, wsKey });
+            // this.logger.trace(`Sending upstream ping: `, { ...loggerCategory, wsKey });
             if (!wsKey) {
                 throw new Error('No wsKey provided');
             }
-            const ws = this.getWs(wsKey);
+            const ws = this.getWsStore().getWs(wsKey);
             if (!ws) {
                 throw new Error(`No active websocket connection exists for wsKey: ${wsKey}`);
             }
             // Binance allows unsolicited pongs, so we send both (though we expect a pong in response to our ping if the connection is still alive)
             if (ws.readyState === 1) {
-                ws.ping();
                 ws.pong();
             }
             else {
-                this.logger.silly('WS ready state not open - refusing to send WS ping', Object.assign(Object.assign({}, loggerCategory), { wsKey, readyState: ws === null || ws === void 0 ? void 0 : ws.readyState }));
+                this.logger.trace('WS ready state not open - refusing to send WS pong', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey, readyState: ws === null || ws === void 0 ? void 0 : ws.readyState }));
             }
         }
         catch (e) {
-            this.logger.error('Failed to send WS ping', Object.assign(Object.assign({}, loggerCategory), { wsKey, exception: e }));
+            this.logger.error('Failed to send WS pong', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey, exception: e }));
         }
     }
-    onWsOpen(ws, wsKey, wsUrl) {
-        this.logger.silly(`onWsOpen(): ${wsUrl} : ${wsKey}`);
-        if (this.wsStore.isConnectionState(wsKey, WsStore_1.WsConnectionStateEnum.RECONNECTING)) {
-            this.logger.info('Websocket reconnected', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-            this.emit('reconnected', { wsKey, ws });
-        }
-        else {
-            this.logger.info('Websocket connected', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-            this.emit('open', { wsKey, ws });
-        }
-        this.setWsState(wsKey, WsStore_1.WsConnectionStateEnum.CONNECTED);
-        const topics = [...this.wsStore.getTopics(wsKey)];
-        if (topics.length) {
-            this.requestSubscribeTopics(wsKey, topics);
-        }
-        if (!this.options.disableHeartbeat) {
-            const wsState = this.wsStore.get(wsKey, true);
-            if (wsState.activePingTimer) {
-                clearInterval(wsState.activePingTimer);
-            }
-            wsState.activePingTimer = setInterval(() => this.sendPing(wsKey, wsUrl), this.options.pingInterval);
-        }
-    }
-    onWsClose(event, wsKey, ws, wsUrl) {
-        var _a;
-        const wsConnectionState = this.wsStore.getConnectionState(wsKey);
-        const { market, listenKey, isUserData } = (0, requestUtils_1.getContextFromWsKey)(wsKey);
-        this.logger.info('Websocket connection closed', Object.assign(Object.assign({}, loggerCategory), { wsKey, eventCloseCode: (_a = event === null || event === void 0 ? void 0 : event.target) === null || _a === void 0 ? void 0 : _a._closeCode, wsConnectionState,
-            isUserData,
-            listenKey,
-            market }));
-        // Clear any timers before we initiate revival
-        this.clearTimers(wsKey);
-        // User data sockets include the listen key. To prevent accummulation in memory we should clean up old disconnected states
-        if (isUserData) {
-            this.wsStore.delete(wsKey);
-            if (listenKey) {
-                this.clearUserDataKeepAliveTimer(listenKey);
-            }
-        }
-        if (wsConnectionState !== WsStore_1.WsConnectionStateEnum.CLOSING) {
-            this.reconnectWithDelay(wsKey, this.options.reconnectTimeout, wsUrl);
-            this.emit('reconnecting', { wsKey, event, ws });
-        }
-        else {
-            this.setWsState(wsKey, WsStore_1.WsConnectionStateEnum.INITIAL);
-            this.emit('close', { wsKey, event, ws });
-        }
+    /** Force subscription requests to be sent in smaller batches, if a number is returned */
+    getMaxTopicsPerSubscribeEvent(wsKey) {
+        return (0, websocket_util_1.getMaxTopicsPerSubscribeEvent)(wsKey);
     }
-    onWsMessage(event, wsKey, source) {
-        try {
-            this.clearPongTimer(wsKey);
-            const msg = parseRawWsMessage(event);
-            // Edge case where raw event does not include event type, detect using wsKey and mutate msg.e
-            (0, requestUtils_1.appendEventIfMissing)(msg, wsKey);
-            (0, requestUtils_1.appendEventMarket)(msg, wsKey);
-            const eventType = parseEventTypeFromMessage(msg);
-            if (eventType) {
-                this.emit('message', msg);
-                if (eventType === 'listenKeyExpired') {
-                    const { market } = (0, requestUtils_1.getContextFromWsKey)(wsKey);
-                    this.logger.info(`${market} listenKey expired - attempting to respawn user data stream: ${wsKey}`);
-                    // Just closing the connection (with the last parameter as true) will handle cleanup and respawn
-                    const shouldTriggerReconnect = true;
-                    this.close(wsKey, shouldTriggerReconnect);
-                }
-                if (this.options.beautify) {
-                    const beautifiedMessage = this.beautifier.beautifyWsMessage(msg, eventType, false);
-                    this.emit('formattedMessage', beautifiedMessage);
-                    // emit a separate event for user data messages
-                    if (!Array.isArray(beautifiedMessage)) {
-                        if ([
-                            'balanceUpdate',
-                            'executionReport',
-                            'listStatus',
-                            'listenKeyExpired',
-                            'outboundAccountPosition',
-                            'ACCOUNT_CONFIG_UPDATE',
-                            'ACCOUNT_UPDATE',
-                            'MARGIN_CALL',
-                            'ORDER_TRADE_UPDATE',
-                            'TRADE_LITE',
-                            'CONDITIONAL_ORDER_TRIGGER_REJECT',
-                        ].includes(eventType)) {
-                            this.emit('formattedUserDataMessage', beautifiedMessage);
-                        }
-                    }
+    /**
+     * @returns one or more correctly structured request events for performing a operations over WS. This can vary per exchange spec.
+     */
+    getWsRequestEvents(wsKey, operation, requests) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wsRequestEvents = [];
+            const wsRequestBuildingErrors = [];
+            switch (wsKey) {
+                default: {
+                    const topics = requests.map((r) => r.topic);
+                    // Previously used to track topics in a request. Keeping this for subscribe/unsubscribe requests, no need for incremental values
+                    const req_id = this.getNewRequestId();
+                    const wsEvent = {
+                        method: operation,
+                        params: topics,
+                        id: req_id,
+                    };
+                    const midflightWsEvent = {
+                        requestKey: wsEvent.id,
+                        requestEvent: wsEvent,
+                    };
+                    wsRequestEvents.push(Object.assign({}, midflightWsEvent));
+                    break;
                 }
-                return;
+                // default: {
+                // throw neverGuard(wsKey, `Unhandled wsKey "${wsKey}"`);
+                // }
             }
-            if (msg.result !== undefined) {
-                this.emit('reply', {
-                    type: event.type,
-                    data: msg,
-                    wsKey,
-                });
-                return;
+            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) }));
             }
-            this.logger.warning('Bug? Unhandled ws message event type. Check if appendEventIfMissing needs to parse wsKey.', Object.assign(Object.assign({}, loggerCategory), { parsedMessage: JSON.stringify(msg), rawEvent: event, wsKey,
-                source }));
-        }
-        catch (e) {
-            this.logger.error('Exception parsing ws message: ', Object.assign(Object.assign({}, loggerCategory), { rawEvent: event, wsKey, error: e, source }));
-            this.emit('error', { wsKey, error: e, rawEvent: event, source });
-        }
-    }
-    sendPing(wsKey, wsUrl) {
-        this.clearPongTimer(wsKey);
-        this.logger.silly('Sending ping', Object.assign(Object.assign({}, loggerCategory), { wsKey }));
-        this.tryWsPing(wsKey);
-        this.wsStore.get(wsKey, true).activePongTimer = setTimeout(() => this.executeReconnectableClose(wsKey, 'Pong timeout', wsUrl), this.options.pongTimeout);
+            return wsRequestEvents;
+        });
     }
-    onWsPing(event, wsKey, ws, source) {
-        this.logger.silly('Received ping, sending pong frame', Object.assign(Object.assign({}, loggerCategory), { wsKey,
-            source }));
-        ws.pong();
+    getPrivateWSKeys() {
+        return websocket_util_1.WS_AUTH_ON_CONNECT_KEYS;
     }
-    onWsPong(event, wsKey, source) {
-        this.logger.silly('Received pong, clearing pong timer', Object.assign(Object.assign({}, loggerCategory), { wsKey,
-            source }));
-        this.clearPongTimer(wsKey);
+    isAuthOnConnectWsKey(wsKey) {
+        return websocket_util_1.WS_AUTH_ON_CONNECT_KEYS.includes(wsKey);
     }
     /**
-     * Closes a connection, if it's even open. If open, this will trigger a reconnect asynchronously.
-     * If closed, trigger a reconnect immediately
+     * Determines if a topic is for a private channel, using a hardcoded list of strings
      */
-    executeReconnectableClose(wsKey, reason, wsUrl) {
-        this.logger.info(`${reason} - closing socket to reconnect`, Object.assign(Object.assign({}, loggerCategory), { wsKey,
-            reason }));
-        const wasOpen = this.wsStore.isWsOpen(wsKey);
-        (0, ws_utils_1.safeTerminateWs)(this.getWs(wsKey));
-        this.clearPingTimer(wsKey);
-        this.clearPongTimer(wsKey);
-        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, wsUrl);
-        }
-    }
-    close(wsKey, shouldReconnectAfterClose) {
+    isPrivateTopicRequest(request) {
         var _a;
-        this.logger.info('Closing connection', Object.assign(Object.assign({}, loggerCategory), { wsKey, willReconnect: shouldReconnectAfterClose }));
-        this.setWsState(wsKey, shouldReconnectAfterClose
-            ? WsStore_1.WsConnectionStateEnum.RECONNECTING
-            : WsStore_1.WsConnectionStateEnum.CLOSING);
-        this.clearTimers(wsKey);
-        (_a = this.getWs(wsKey)) === null || _a === void 0 ? void 0 : _a.close();
-        const { listenKey } = (0, requestUtils_1.getContextFromWsKey)(wsKey);
-        if (listenKey) {
-            this.teardownUserDataListenKey(listenKey, this.getWs(wsKey));
-        }
-        else {
-            (0, ws_utils_1.safeTerminateWs)(this.getWs(wsKey));
+        const topicName = (_a = request === null || request === void 0 ? void 0 : request.topic) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (!topicName) {
+            return false;
         }
+        return (0, websocket_util_1.isPrivateWsTopic)(topicName);
     }
-    closeAll(shouldReconnectAfterClose) {
-        const keys = this.wsStore.getKeys();
-        this.logger.info(`Closing all ws connections: ${keys}`);
-        keys.forEach((key) => {
-            this.close(key, shouldReconnectAfterClose);
-        });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isWsPing(msg) {
+        if (!msg) {
+            return false;
+        }
+        // For binance, all ping/pong events are frame events
+        return false;
     }
-    closeWs(ws, shouldReconnectAfterClose) {
-        const wsKey = this.wsUrlKeyMap[ws.url] || (ws === null || ws === void 0 ? void 0 : ws.wsKey);
-        if (!wsKey) {
-            throw new Error('Cannot close websocket as it has no known wsKey attached.');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isWsPong(msg) {
+        if (!msg) {
+            return false;
         }
-        return this.close(wsKey, shouldReconnectAfterClose);
+        // For binance, all ping/pong events are frame events
+        return false;
     }
-    parseWsError(context, error, wsKey, wsUrl) {
-        this.logger.error(context, Object.assign(Object.assign({}, loggerCategory), { wsKey, error }));
-        if (!error.message) {
-            this.logger.error(`${context} due to unexpected error: `, error);
-            this.emit('error', { error, wsKey, wsUrl });
-            return;
+    /**
+     * Abstraction called to sort ws events into emittable event types (response to a request, data update, etc)
+     */
+    resolveEmittableEvents(wsKey, event) {
+        var _a, _b, _c;
+        const results = [];
+        try {
+            // const parsed = JSON.parse(event.data);
+            const parsed = (0, websocket_util_1.parseRawWsMessage)(event);
+            const eventType = (0, websocket_util_1.parseEventTypeFromMessage)(wsKey, parsed);
+            // Some events don't include the topic (event name)
+            // This tries to extract and append it, using available context
+            (0, requestUtils_1.appendEventIfMissing)(parsed, wsKey);
+            const legacyContext = (0, websocket_util_1.getLegacyWsKeyContext)(wsKey);
+            if (legacyContext) {
+                parsed.wsMarket = legacyContext.market;
+            }
+            // const eventType = eventType; //parsed?.stream;
+            // const eventOperation = parsed?.op;
+            const traceEmittable = false;
+            if (traceEmittable) {
+                this.logger.trace('resolveEmittableEvents', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey,
+                    eventType, parsed: JSON.stringify(parsed) }));
+            }
+            const reqId = parsed.id;
+            const isWSAPIResponse = typeof parsed.id === 'number';
+            const EVENTS_AUTHENTICATED = ['auth'];
+            const EVENTS_RESPONSES = [
+                'subscribe',
+                'unsubscribe',
+                'COMMAND_RESP',
+                'ping',
+                'pong',
+            ];
+            // WS API response
+            // TODO: after
+            if (isWSAPIResponse) {
+                const retCode = parsed.status;
+                /**
+                 * Responses to "subscribe" are quite basic, with no indication of errors (e.g. bad topic):
+                 *
+                 *   {
+                 *     result: null,
+                 *     id: 1,
+                 *   };
+                 *
+                 * Will need some way to tell this apart from an actual WS API response with error. Maybe to send it via a diff check than isWSAPIResponse=true
+                 *
+                 * Example wsapi error:
+                 *
+        {
+          id: 1,
+          status: 400,
+          error: {
+            code: -1021,
+            msg: "Timestamp for this request was 1000ms ahead of the server's time."
+          },
+          rateLimits: [
+            {
+              rateLimitType: 'REQUEST_WEIGHT',
+              interval: 'MINUTE',
+              intervalNum: 1,
+              limit: 6000,
+              count: 4
+            }
+          ],
+          wsKey: 'mainWSAPI',
+          isWSAPIResponse: true
         }
-        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) !==
-                    WsStore_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', wsUrl);
+                 */
+                const isError = typeof ((_a = parsed.error) === null || _a === void 0 ? void 0 : _a.code) === 'number' && ((_b = parsed.error) === null || _b === void 0 ? void 0 : _b.code) !== 0;
+                // This is the counterpart to getPromiseRefForWSAPIRequest
+                const promiseRef = [wsKey, 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.logger.info(`${wsKey} socket forcefully closed. Will not reconnect.`);
+                // 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: 'exception',
+                        event: parsed,
+                        isWSAPIResponse: isWSAPIResponse,
+                    });
+                    return results;
                 }
-                break;
-        }
-        this.emit('error', { error, wsKey, wsUrl });
-    }
-    reconnectWithDelay(wsKey, connectionDelayMs, wsUrl) {
-        var _a;
-        this.clearTimers(wsKey);
-        if (this.wsStore.getConnectionState(wsKey) !==
-            WsStore_1.WsConnectionStateEnum.CONNECTING) {
-            this.setWsState(wsKey, WsStore_1.WsConnectionStateEnum.RECONNECTING);
-        }
-        this.logger.info('Reconnecting to websocket with delay...', Object.assign(Object.assign({}, loggerCategory), { wsKey,
-            connectionDelayMs }));
-        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.clearReconnectTimer(wsKey);
-            if (wsKey.includes('userData')) {
-                const { market, symbol, isTestnet } = (0, requestUtils_1.getContextFromWsKey)(wsKey);
-                this.logger.info('Reconnecting to user data stream', Object.assign(Object.assign({}, loggerCategory), { wsKey,
-                    market,
-                    symbol }));
-                // We'll set a new one once the new stream respawns, with a diff listenKey in the key
-                this.wsStore.delete(wsKey);
-                this.respawnUserDataStream(market, symbol, isTestnet);
-                return;
+                // authenticated
+                if ((_c = parsed.result) === null || _c === void 0 ? void 0 : _c.apiKey) {
+                    // Note: Without this check, this will also trigger "onWsAuthenticaated()" for session.status requests
+                    if (this.getWsStore().getAuthenticationInProgressPromise(wsKey)) {
+                        results.push({
+                            eventType: 'authenticated',
+                            event: parsed,
+                            isWSAPIResponse: isWSAPIResponse,
+                        });
+                    }
+                }
+                // 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,
+                    });
+                }
+                results.push({
+                    eventType: 'response',
+                    event: parsed,
+                    isWSAPIResponse: isWSAPIResponse,
+                });
+                return results;
             }
-            this.logger.info('Reconnecting to public websocket', Object.assign(Object.assign({}, loggerCategory), { wsKey,
-                wsUrl }));
-            this.connectToWsUrl(wsUrl, wsKey);
-        }, connectionDelayMs);
-    }
-    clearTimers(wsKey) {
-        this.clearPingTimer(wsKey);
-        this.clearPongTimer(wsKey);
-        this.clearReconnectTimer(wsKey);
-    }
-    // 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;
-        }
-    }
-    // Timer tracking that a reconnect is about to happen / in progress
-    clearReconnectTimer(wsKey) {
-        const wsState = this.wsStore.get(wsKey);
-        if (wsState === null || wsState === void 0 ? void 0 : wsState.activeReconnectTimer) {
-            clearTimeout(wsState.activeReconnectTimer);
-            wsState.activeReconnectTimer = undefined;
-        }
-    }
-    clearUserDataKeepAliveTimer(listenKey) {
-        const state = this.listenKeyStateStore[listenKey];
-        if (!state) {
-            return;
-        }
-        if (state.keepAliveTimer) {
-            this.logger.silly(`Clearing old listen key interval timer for ${listenKey}`);
-            clearInterval(state.keepAliveTimer);
-        }
-        if (state.keepAliveRetryTimer) {
-            this.logger.silly(`Clearing old listen key keepAliveRetry timer for ${listenKey}`);
-            clearTimeout(state.keepAliveRetryTimer);
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getWsBaseUrl(market, wsKey) {
-        if (this.options.wsUrl) {
-            return this.options.wsUrl;
-        }
-        return wsBaseEndpoints[market];
-    }
-    getWs(wsKey) {
-        return this.wsStore.getWs(wsKey);
-    }
-    setWsState(wsKey, state) {
-        this.wsStore.setConnectionState(wsKey, state);
-    }
-    getSpotRestClient() {
-        if (!this.restClients.spot) {
-            this.restClients.spot = new main_client_1.MainClient(this.getRestClientOptions(), this.options.requestOptions);
-        }
-        return this.restClients.spot;
-    }
-    getUSDMRestClient(isTestnet) {
-        if (isTestnet) {
-            if (!this.restClients.usdmFuturesTestnet) {
-                this.restClients.usdmFuturesTestnet = new usdm_client_1.USDMClient(this.getRestClientOptions(), this.options.requestOptions, isTestnet);
+            // Handle incoming event that listen key expired
+            if (eventType === 'listenKeyExpired') {
+                const legacyContext = (0, websocket_util_1.getLegacyWsKeyContext)(wsKey);
+                if (!legacyContext) {
+                    // handle this how?
+                    throw new Error('No context found within wsKey - fatal error with expired listen key');
+                }
+                this.logger.info(`${legacyContext.market} listenKey EXPIRED - attempting to respawn user data stream: ${wsKey}`, parsed);
+                // Just closing the connection (with the last parameter as true) will handle cleanup and respawn
+                // Automatically leads to triggerCustomReconnectionWorkflow() to handle fresh user data respawn
+                this.getUserDataStreamManager().teardownUserDataListenKey(legacyContext.listenKey, this.getWsStore().getWs(wsKey));
+                this.executeReconnectableClose(wsKey, 'listenKeyExpired');
             }
-            return this.restClients.usdmFuturesTestnet;
-        }
-        if (!this.restClients.usdmFutures) {
-            this.restClients.usdmFutures = new usdm_client_1.USDMClient(this.getRestClientOptions(), this.options.requestOptions);
-        }
-        return this.restClients.usdmFutures;
-    }
-    getCOINMRestClient(isTestnet) {
-        if (isTestnet) {
-            if (!this.restClients.coinmFuturesTestnet) {
-                this.restClients.coinmFuturesTestnet = new coinm_client_1.CoinMClient(this.getRestClientOptions(), this.options.requestOptions, isTestnet);
+            if (this.options.beautify) {
+                const beautifiedMessage = this.beautifier.beautifyWsMessage(parsed, eventType, false, 
+                // Suffix all events for the beautifier, if market is options
+                // Options has some conflicting keys with different intentions
+                wsKey === 'eoptions' ? 'Options' : '');
+                results.push({
+                    eventType: 'formattedMessage',
+                    event: beautifiedMessage,
+                    isWSAPIResponse,
+                });
+                // emit an additional event for user data messages
+                if (!Array.isArray(beautifiedMessage) && eventType) {
+                    if ([
+                        'balanceUpdate',
+                        'executionReport',
+                        'listStatus',
+                        'listenKeyExpired',
+                        'outboundAccountPosition',
+                        'ACCOUNT_CONFIG_UPDATE',
+                        'ACCOUNT_UPDATE',
+                        'MARGIN_CALL',
+                        'ORDER_TRADE_UPDATE',
+                        'TRADE_LITE',
+                        'CONDITIONAL_ORDER_TRIGGER_REJECT',
+                    ].includes(eventType)) {
+                        results.push({
+                            eventType: 'formattedUserDataMessage',
+                            event: beautifiedMessage,
+                            isWSAPIResponse,
+                        });
+                    }
+                }
+            }
+            // Messages for a subscribed topic all include the "topic" property
+            if (typeof eventType === 'string') {
+                results.push({
+                    eventType: 'message',
+                    event: (parsed === null || parsed === void 0 ? void 0 : parsed.data) ? parsed.data : parsed,
+                });
+                return results;
             }
-            return this.restClients.coinmFuturesTestnet;
+            // Messages that are a "reply" to a request/command (e.g. subscribe to these topics) typically include the "op" property
+            if (typeof eventType === 'string') {
+                // Failed request
+                if (parsed.success === false) {
+                    results.push({
+                        eventType: 'exception',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // These are r  equest/reply pattern events (e.g. after subscribing to topics or authenticating)
+                if (EVENTS_RESPONSES.includes(eventType)) {
+                    results.push({
+                        eventType: 'response',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // Request/reply pattern for authentication success
+                if (EVENTS_AUTHENTICATED.includes(eventType)) {
+                    results.push({
+                        eventType: 'authenticated',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                this.logger.error(`!! Unhandled string operation type "${eventType}". Defaulting to "update" channel...`, parsed);
+            }
+            else {
+                this.logger.error(`!!!! Unhandled non-string event type "${eventType}". Defaulting to "update" channel...`, parsed);
+            }
+            // In case of catastrophic failure, fallback to noisy emit update
+            results.push({
+                eventType: 'message',
+                event: parsed,
+            });
         }
-        if (!this.restClients.coinmFutures) {
-            this.restClients.coinmFutures = new coinm_client_1.CoinMClient(this.getRestClientOptions(), this.options.requestOptions);
+        catch (e) {
+            results.push({
+                event: {
+                    message: 'Failed to parse event data due to exception',
+                    exception: e,
+                    eventData: event.data,
+                },
+                eventType: 'exception',
+            });
+            this.logger.error('Error caught within resolveEmittableEvents - failed to parse event data? Caught exception: ', {
+                exception: e,
+                eventData: event.data,
+            });
         }
-        return this.restClients.coinmFutures;
+        return results;
     }
     /**
-     * Send WS message to subscribe to topics. Use subscribe() to call this.
+     *
+     *
+     *
+     *
+     *
+     *  User Data Streams
+     *
+     *
+     *
+     *
+     *
      */
-    requestSubscribeTopics(wsKey, topics) {
-        const wsMessage = JSON.stringify({
-            method: 'SUBSCRIBE',
-            params: topics,
-            id: new Date().getTime(),
-        });
-        this.tryWsSend(wsKey, wsMessage);
-    }
     /**
-     * Send WS message to unsubscribe from topics. Use unsubscribe() to call this.
+     * --------------------------
+     * User data listen key tracking & persistence
+     * --------------------------
+     **/
+    /**
+     * Subscribe to a spot user data stream. Use REST client to generate and persist listen key.
+     * Supports spot, margin & isolated margin listen keys.
      */
-    requestUnsubscribeTopics(wsKey, topics) {
-        const wsMessage = JSON.stringify({
-            op: 'UNSUBSCRIBE',
-            params: topics,
-            id: new Date().getTime(),
+    subscribeSpotUserDataStreamWithListenKey(wsKey, listenKey, forceNewConnection, miscState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, 'spot', listenKey, forceNewConnection, miscState);
         });
-        this.tryWsSend(wsKey, wsMessage);
     }
     /**
-     * Send WS message to unsubscribe from topics.
+     * Subscribe to spot user data stream - listen key is automaticallyr generated. Calling multiple times only opens one connection.
      */
-    requestListSubscriptions(wsKey, requestId) {
-        const wsMessage = JSON.stringify({
-            method: 'LIST_SUBSCRIPTIONS',
-            id: requestId,
+    subscribeSpotUserDataStream() {
+        return __awaiter(this, arguments, void 0, function* (wsKey = 'main', forceNewConnection, miscState) {
+            this.logger.trace('subscribeSpotUserDataStream()', {
+                wsKey,
+                forceNewConnection,
+                miscState,
+            });
+            try {
+                const { listenKey } = yield this.restClientCache
+                    .getSpotRestClient(this.getRestClientOptions(), this.options.requestOptions)
+                    .getSpotUserDataListenKey();
+                return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, 'spot', listenKey, forceNewConnection, miscState);
+            }
+            catch (e) {
+                this.logger.error('Failed to connect to spot user data', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { error: e }));
+                this.emit('exception', Object.assign(Object.assign({ functionRef: 'subscribeSpotUserDataStream()', wsKey,
+                    forceNewConnection }, miscState), { error: (e === null || e === void 0 ? void 0 : e.stack) || e }));
+            }
         });
-        this.tryWsSend(wsKey, wsMessage);
     }
     /**
-     * Send WS message to set property state
+     * Subscribe to margin user data stream - listen key is automatically generated.
      */
-    requestSetProperty(wsKey, property, value, requestId) {
-        const wsMessage = JSON.stringify({
-            method: 'SET_PROPERTY',
-            params: [property, value],
-            id: requestId,
+    subscribeCrossMarginUserDataStream() {
+        return __awaiter(this, arguments, void 0, function* (wsKey = 'main', forceNewConnection, miscState) {
+            try {
+                const { listenKey } = yield this.restClientCache
+                    .getSpotRestClient(this.getRestClientOptions(), this.options.requestOptions)
+                    .getMarginUserDataListenKey();
+                const market = 'crossMargin';
+                return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, market, listenKey, forceNewConnection, miscState);
+            }
+            catch (e) {
+                this.logger.error('Failed to connect to margin user data', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { error: e }));
+                this.emit('exception', Object.assign(Object.assign({ functionRef: 'subscribeMarginUserDataStream()', wsKey,
+                    forceNewConnection }, miscState), { error: (e === null || e === void 0 ? void 0 : e.stack) || e }));
+            }
         });
-        this.tryWsSend(wsKey, wsMessage);
     }
     /**
-     * Send WS message to get property state
+     * Subscribe to isolated margin user data stream - listen key is automatically generated.
      */
-    requestGetProperty(wsKey, property, requestId) {
-        const wsMessage = JSON.stringify({
-            method: 'GET_PROPERTY',
-            params: [property],
-            id: requestId,
+    subscribeIsolatedMarginUserDataStream(symbol_1) {
+        return __awaiter(this, arguments, void 0, function* (symbol, wsKey = 'main', forceNewConnection, miscState) {
+            try {
+                const lowerCaseSymbol = symbol.toLowerCase();
+                const { listenKey } = yield this.restClientCache
+                    .getSpotRestClient(this.getRestClientOptions(), this.options.requestOptions)
+                    .getIsolatedMarginUserDataListenKey({
+                    symbol: lowerCaseSymbol,
+                });
+                const market = 'isolatedMargin';
+                return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, market, listenKey, forceNewConnection, miscState);
+            }
+            catch (e) {
+                this.logger.error('Failed to connect to isolated margin user data', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { error: e, symbol }));
+                this.emit('exception', Object.assign(Object.assign({ functionRef: 'subscribeIsolatedMarginUserDataStream()', wsKey,
+                    forceNewConnection }, miscState), { error: (e === null || e === void 0 ? void 0 : e.stack) || e }));
+            }
         });
-        this.tryWsSend(wsKey, wsMessage);
     }
     /**
-     * --------------------------
-     * User data listen key tracking & persistence
-     * --------------------------
-     **/
-    getListenKeyState(listenKey, market) {
-        const state = this.listenKeyStateStore[listenKey];
-        if (state) {
-            return state;
-        }
-        this.listenKeyStateStore[listenKey] = {
-            market,
-            lastKeepAlive: 0,
-            keepAliveTimer: undefined,
-            keepAliveRetryTimer: undefined,
-            keepAliveFailures: 0,
-        };
-        return this.listenKeyStateStore[listenKey];
-    }
-    setKeepAliveListenKeyTimer(listenKey, market, ws, wsKey, symbol, isTestnet) {
-        const listenKeyState = this.getListenKeyState(listenKey, market);
-        this.clearUserDataKeepAliveTimer(listenKey);
-        this.logger.silly(`Created new listen key interval timer for ${listenKey}`);
-        // Set timer to keep WS alive every 50 minutes
-        const minutes50 = 1000 * 60 * 50;
-        listenKeyState.keepAliveTimer = setInterval(() => this.checkKeepAliveListenKey(listenKey, market, ws, wsKey, symbol, isTestnet), minutes50);
-    }
-    sendKeepAliveForMarket(listenKey, market, ws, wsKey, symbol, isTestnet) {
-        switch (market) {
-            case 'spot':
-                return this.getSpotRestClient().keepAliveSpotUserDataListenKey(listenKey);
-            case 'margin':
-                return this.getSpotRestClient().keepAliveMarginUserDataListenKey(listenKey);
-            case 'isolatedMargin':
-                return this.getSpotRestClient().keepAliveIsolatedMarginUserDataListenKey({ listenKey, symbol: symbol });
-            case 'coinm':
-            case 'options':
-            case 'optionsTestnet':
-            case 'usdm':
-                return this.getUSDMRestClient().keepAliveFuturesUserDataListenKey();
-            case 'usdmTestnet':
-                return this.getUSDMRestClient(isTestnet).keepAliveFuturesUserDataListenKey();
-            case 'coinmTestnet':
-                return this.getUSDMRestClient(isTestnet).keepAliveFuturesUserDataListenKey();
-            default:
-                throwUnhandledSwitch(market, `Failed to send keep alive for user data stream in unhandled market ${market}`);
-        }
-    }
-    checkKeepAliveListenKey(listenKey, market, ws, wsKey, symbol, isTestnet) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const listenKeyState = this.getListenKeyState(listenKey, market);
+     * Subscribe to margin risk user data stream - listen key is automatically generated.
+     */
+    subscribeMarginRiskUserDataStream() {
+        return __awaiter(this, arguments, void 0, function* (wsKey = 'main', forceNewConnection, miscState) {
             try {
-                if (listenKeyState.keepAliveRetryTimer) {
-                    clearTimeout(listenKeyState.keepAliveRetryTimer);
-                    listenKeyState.keepAliveRetryTimer = undefined;
-                }
-                // Simple way to test keep alive failure handling:
-                // throw new Error(`Fake keep alive failure`);
-                yield this.sendKeepAliveForMarket(listenKey, market, ws, wsKey, symbol, isTestnet);
-                listenKeyState.lastKeepAlive = Date.now();
-                listenKeyState.keepAliveFailures = 0;
-                this.logger.info(`Completed keep alive cycle for listenKey(${listenKey}) in market(${market})`, Object.assign(Object.assign({}, loggerCategory), { listenKey }));
+                const { listenKey } = yield this.restClientCache
+                    .getSpotRestClient(this.getRestClientOptions(), this.options.requestOptions)
+                    .getMarginRiskUserDataListenKey();
+                const market = 'riskDataMargin';
+                return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, market, listenKey, forceNewConnection, miscState);
             }
             catch (e) {
-                listenKeyState.keepAliveFailures++;
-                // code: -1125,
-                // message: 'This listenKey does not exist.',
-                const errorCode = e === null || e === void 0 ? void 0 : e.code;
-                if (errorCode === -1125) {
-                    this.logger.error('FATAL: Failed to keep WS alive for listen key - listen key expired/invalid. Respawning with fresh listen key...', Object.assign(Object.assign({}, loggerCategory), { listenKey, error: e, errorCode, errorMsg: e === null || e === void 0 ? void 0 : e.message }));
-                    const shouldReconnectAfterClose = false;
-                    this.close(wsKey, shouldReconnectAfterClose);
-                    this.respawnUserDataStream(market, symbol);
-                    return;
-                }
-                // If max failurees reached, tear down and respawn if allowed
-                if (listenKeyState.keepAliveFailures >= 3) {
-                    this.logger.error('FATAL: Failed to keep WS alive for listen key after 3 attempts', Object.assign(Object.assign({}, loggerCategory), { listenKey, error: e }));
-                    // reconnect follows a less automatic workflow since this is tied to a listen key (which may need a new one).
-                    // Kill connection first, with instruction NOT to reconnect automatically
-                    const shouldReconnectAfterClose = false;
-                    this.close(wsKey, shouldReconnectAfterClose);
-                    // Then respawn a connection with a potentially new listen key (since the old one may be invalid now)
-                    this.respawnUserDataStream(market, symbol);
-                    return;
-                }
-                const reconnectDelaySeconds = 1000 * 15;
-                this.logger.warning(`Userdata keep alive request failed due to error, trying again with short delay (${reconnectDelaySeconds} seconds)`, Object.assign(Object.assign({}, loggerCategory), { listenKey, error: e, keepAliveAttempts: listenKeyState.keepAliveFailures }));
-                listenKeyState.keepAliveRetryTimer = setTimeout(() => this.checkKeepAliveListenKey(listenKey, market, ws, wsKey, symbol), reconnectDelaySeconds);
+                this.logger.error('Failed to connect to margin risk user data', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { error: e }));
+                this.emit('exception', Object.assign(Object.assign({ functionRef: 'subscribeMarginRiskUserDataStream()', wsKey,
+                    forceNewConnection }, miscState), { error: (e === null || e === void 0 ? void 0 : e.stack) || e }));
             }
         });
     }
-    teardownUserDataListenKey(listenKey, ws) {
-        if (listenKey) {
-            this.clearUserDataKeepAliveTimer(listenKey);
-            delete this.listenKeyStateStore[listenKey];
-            (0, ws_utils_1.safeTerminateWs)(ws);
-        }
+    isCustomReconnectionNeeded(wsKey) {
+        return wsKey.includes('userData');
     }
-    respawnUserDataStream(market, symbol, isTestnet, respawnAttempt) {
+    triggerCustomReconnectionWorkflow(legacyWsKey) {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log(`triggerCustomReconnectionWorkflow(${legacyWsKey})`);
+            if (legacyWsKey.includes('userData')) {
+                return this.getUserDataStreamManager().triggerUserDataReconnectionWorkflow(legacyWsKey);
+            }
+        });
+    }
+    respawnUserDataStream(wsKey_1, market_1) {
+        return __awaiter(this, arguments, void 0, function* (wsKey, market, context = {}) {
+            // Handle corner case where wsKey is still the derived key for some reason...
+            const realWsKey = (0, websocket_util_1.getRealWsKeyFromDerivedWsKey)(wsKey);
+            if (realWsKey !== wsKey) {
+                console.error('Derived key fed into respawn method!! ', Object.assign(Object.assign({ wsKey,
+                    market }, context), { realWsKey }));
+                console.trace();
+                process.exit(-1);
+            }
             // If another connection attempt is in progress for this listen key, don't initiate a retry or the risk is multiple connections on the same listen key
             const forceNewConnection = false;
-            const isReconnecting = true;
-            let ws;
+            const miscConnectionState = {
+                isReconnecting: true,
+                respawnAttempt: context === null || context === void 0 ? void 0 : context.respawnAttempt,
+            };
+            let ws = undefined;
             try {
                 switch (market) {
                     case 'spot':
-                        ws = yield this.subscribeSpotUserDataStream(forceNewConnection, isReconnecting);
+                    case 'spotTestnet':
+                        ws = yield this.subscribeSpotUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
-                    case 'margin':
-                        ws = yield this.subscribeMarginUserDataStream(forceNewConnection, isReconnecting);
+                    case 'crossMargin':
+                        ws = yield this.subscribeCrossMarginUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'isolatedMargin':
-                        ws = yield this.subscribeIsolatedMarginUserDataStream(symbol, forceNewConnection, isReconnecting);
+                        ws = yield this.subscribeIsolatedMarginUserDataStream(context.symbol, realWsKey, forceNewConnection, miscConnectionState);
+                        break;
+                    case 'riskDataMargin':
+                        ws = yield this.subscribeMarginRiskUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'usdm':
-                        ws = yield this.subscribeUsdFuturesUserDataStream(isTestnet, forceNewConnection, isReconnecting);
+                        ws = yield this.subscribeUsdFuturesUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'usdmTestnet':
-                        ws = yield this.subscribeUsdFuturesUserDataStream(true, forceNewConnection, isReconnecting);
+                        ws = yield this.subscribeUsdFuturesUserDataStream('usdmTestnet', forceNewConnection, miscConnectionState);
                         break;
                     case 'coinm':
-                        ws = yield this.subscribeCoinFuturesUserDataStream(isTestnet, forceNewConnection, isReconnecting);
+                        ws = yield this.subscribeCoinFuturesUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'coinmTestnet':
-                        ws = yield this.subscribeCoinFuturesUserDataStream(true, forceNewConnection, isReconnecting);
+                        ws = yield this.subscribeCoinFuturesUserDataStream('coinmTestnet', forceNewConnection, miscConnectionState);
+                        break;
+                    case 'portfoliom':
+                        ws = yield this.subscribePortfolioMarginUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'options':
                     case 'optionsTestnet':
-                        throw new Error('TODO: respawn other user data streams once subscribe methods have been added');
+                        throw new Error('European options are not supported yet. Please get in touch if you need this.');
                     default:
-                        throwUnhandledSwitch(market, `Failed to respawn user data stream - unhandled market: ${market}`);
+                        throw (0, typeGuards_1.neverGuard)(market, `Failed to respawn user data stream - unhandled market: ${market}`);
                 }
             }
             catch (e) {
-                this.logger.error('Exception trying to spawn user data stream', Object.assign(Object.assign({}, loggerCategory), { market,
-                    symbol,
-                    isTestnet, error: e }));
-                this.emit('error', { wsKey: market + '_' + 'userData', error: e });
+                this.logger.error('Exception trying to spawn user data stream', Object.assign(Object.assign(Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { market }), context), { error: e }));
+                this.emit('exception', { wsKey: market + '_' + 'userData', error: e });
             }
             if (!ws) {
                 const delayInSeconds = 2;
-                this.logger.error('User key respawn failed, trying again with short delay', Object.assign(Object.assign({}, loggerCategory), { market,
-                    symbol,
-                    isTestnet,
-                    respawnAttempt,
-                    delayInSeconds }));
-                setTimeout(() => this.respawnUserDataStream(market, symbol, isTestnet, respawnAttempt ? respawnAttempt + 1 : 1), 1000 * delayInSeconds);
+                this.logger.error('Userdata respawn failed, trying again with short delay', Object.assign(Object.assign(Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { market }), context), { delayInSeconds }));
+                const respawnTimeoutKey = [
+                    market,
+                    context === null || context === void 0 ? void 0 : context.symbol,
+                    context === null || context === void 0 ? void 0 : context.isTestnet,
+                ].join('_');
+                // Prevent simultaneous timers in same scope
+                if (this.respawnTimeoutCache[respawnTimeoutKey]) {
+                    clearTimeout(this.respawnTimeoutCache[respawnTimeoutKey]);
+                    delete this.respawnTimeoutCache[respawnTimeoutKey];
+                    this.logger.error('Respawn timer already active while trying to queue respawn...delaying existing timer further...', Object.assign(Object.assign(Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { market }), context), { delayInSeconds }));
+                }
+                // Execute reconnection workflow after short delay
+                this.respawnTimeoutCache[respawnTimeoutKey] = setTimeout(() => {
+                    delete this.respawnTimeoutCache[respawnTimeoutKey];
+                    this.respawnUserDataStream(realWsKey, market, Object.assign(Object.assign({}, context), { respawnAttempt: (context === null || context === void 0 ? void 0 : context.respawnAttempt)
+                            ? context.respawnAttempt + 1
+                            : 1 }));
+                }, 1000 * delayInSeconds);
+            }
+        });
+    }
+    /**
+     * --------------------------
+     * End of SPOT market websocket streams
+     * --------------------------
+     **/
+    /**
+     * Subscribe to USD-M Futures user data stream - listen key is automatically generated.
+     */
+    subscribeUsdFuturesUserDataStream() {
+        return __awaiter(this, arguments, void 0, function* (wsKey = 'usdm', // usdm | usdmTestnet
+        forceNewConnection, miscState) {
+            try {
+                const isTestnet = wsKey === websocket_util_1.WS_KEY_MAP.usdmTestnet;
+                const restClient = this.restClientCache.getUSDMRestClient(this.getRestClientOptions(), this.options.requestOptions, isTestnet);
+                const { listenKey } = yield restClient.getFuturesUserDataListenKey();
+                const market = isTestnet ? 'usdmTestnet' : 'usdm';
+                return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, market, listenKey, forceNewConnection, miscState);
+            }
+            catch (e) {
+                this.logger.error('Failed to connect to USD Futures user data', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { error: e }));
+                this.emit('exception', Object.assign(Object.assign({ functionRef: 'subscribeUsdFuturesUserDataStream()', wsKey,
+                    forceNewConnection }, miscState), { error: (e === null || e === void 0 ? void 0 : e.stack) || e }));
             }
         });
     }
+    /**
+     * Subscribe to COIN-M Futures user data stream - listen key is automatically generated.
+     */
+    subscribeCoinFuturesUserDataStream() {
+        return __awaiter(this, arguments, void 0, function* (wsKey = 'coinm', // coinm | coinmTestnet
+        forceNewConnection, miscState) {
+            try {
+                const isTestnet = wsKey === websocket_util_1.WS_KEY_MAP.coinmTestnet;
+                const { listenKey } = yield this.restClientCache
+                    .getCOINMRestClient(this.getRestClientOptions(), this.options.requestOptions, isTestnet)
+                    .getFuturesUserDataListenKey();
+                const market = isTestnet ? 'coinmTestnet' : 'coinm';
+                return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, market, listenKey, forceNewConnection, miscState);
+            }
+            catch (e) {
+                this.logger.error('Failed to connect to COIN Futures user data', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { error: e }));
+                this.emit('exception', Object.assign(Object.assign({ functionRef: 'subscribeCoinFuturesUserDataStream()', wsKey,
+                    forceNewConnection }, miscState), { error: (e === null || e === void 0 ? void 0 : e.stack) || e }));
+            }
+        });
+    }
+    /**
+     * Subscribe to Portfolio Margin user data stream - listen key is automatically generated.
+     */
+    subscribePortfolioMarginUserDataStream() {
+        return __awaiter(this, arguments, void 0, function* (wsKey = 'portfolioMarginUserData', forceNewConnection, miscState) {
+            try {
+                const { listenKey } = yield this.restClientCache
+                    .getPortfolioClient(this.getRestClientOptions(), this.options.requestOptions)
+                    .getPMUserDataListenKey();
+                const market = 'portfoliom';
+                return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, market, listenKey, forceNewConnection, miscState);
+            }
+            catch (e) {
+                this.logger.error('Failed to connect to Portfolio Margin user data', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { error: e }));
+                this.emit('exception', Object.assign(Object.assign({ functionRef: 'subscribePortfolioMarginUserDataStream()', wsKey,
+                    forceNewConnection }, miscState), { error: (e === null || e === void 0 ? void 0 : e.stack) || e }));
+            }
+        });
+    }
+    /**
+     * Subscribe to the European Options user data stream - listen key is automatically generated.
+     *
+     * Not supported at this time. Please get in touch if you need this.
+     */
+    // public async subscribeEuropeanOptionsUserData(
+    //   wsKey: WsKey = 'eoptions',
+    //   forceNewConnection?: boolean,
+    //   isReconnecting?: boolean,
+    // ): Promise<WSConnectedResult | undefined> {
+    //   try {
+    //     const { listenKey } = await this.restClientCache
+    //       .getEuropeanOptionsClient(
+    //         this.getRestClientOptions(),
+    //         this.options.requestOptions,
+    //       )
+    //       .getUserDataListenKey();
+    //     const market: WsMarket = 'options';
+    //     return this.subscribeGeneralUserDataStreamWithListenKey(
+    //       wsKey,
+    //       market,
+    //       listenKey,
+    //       forceNewConnection,
+    //       isReconnecting,
+    //     );
+    //   } catch (e) {
+    //     this.logger.error('Failed to connect to Options user data', {
+    //       ...WS_LOGGER_CATEGORY,
+    //       error: e,
+    //     });
+    //     this.emit('exception', {
+    //       functionRef: 'subscribePortfolioMarginUserDataStream()',
+    //       wsKey,
+    //       forceNewConnection,
+    //       isReconnecting,
+    //       error: e?.stack || e,
+    //     });
+    //   }
+    // }
+    /**
+     *
+     *
+     *
+     *
+     * Convenient subscribe methods, similar to the legacy WebsocketClient for Binance.
+     *
+     *
+     *
+     *
+     */
     /**
      * --------------------------
      * Universal market websocket streams (may apply to one or more API markets)
      * --------------------------
      **/
     /**
-     * Subscribe to a universal market websocket stream
+     * Advanced: Subscribe to a universal market websocket stream
+     *
+     * This is NOT recommended unless you're very confident with what you're doing.
      */
-    subscribeEndpoint(endpoint, market, forceNewConnection) {
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, endpoint);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${endpoint}`, wsKey, forceNewConnection);
+    subscribeEndpoint(endpoint, market) {
+        const wsBaseEndpoints = {
+            spot: 'wss://stream.binance.com:9443',
+            crossMargin: 'wss://stream.binance.com:9443',
+            isolatedMargin: 'wss://stream.binance.com:9443',
+            usdm: 'wss://fstream.binance.com',
+            usdmTestnet: 'wss://stream.binancefuture.com',
+            coinm: 'wss://dstream.binance.com',
+            coinmTestnet: 'wss://dstream.binancefuture.com',
+            options: 'wss://vstream.binance.com',
+            optionsTestnet: 'wss://testnetws.binanceops.com',
+            riskDataMargin: '',
+            spotTestnet: '',
+            portfoliom: '',
+        };
+        const wsKey = (0, websocket_util_1.getLegacyWsStoreKeyWithContext)(market, endpoint);
+        return this.connect(wsKey, wsBaseEndpoints[market] + `/ws/${endpoint}`);
     }
     /**
      * Subscribe to aggregate trades for a symbol in a market category
      */
-    subscribeAggregateTrades(symbol, market, forceNewConnection) {
+    subscribeAggregateTrades(symbol, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'aggTrade';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${lowerCaseSymbol}@${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}`, wsKey);
     }
     /**
      * Subscribe to trades for a symbol in a market category
      * IMPORTANT: This topic for usdm and coinm is not listed in the api docs and might stop working without warning
      */
-    subscribeTrades(symbol, market, forceNewConnection) {
+    subscribeTrades(symbol, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'trade';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${lowerCaseSymbol}@${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}`, wsKey);
     }
     /**
      * Subscribe to coin index for a symbol in COINM Futures markets
      */
-    subscribeCoinIndexPrice(symbol, updateSpeedMs = 3000, forceNewConnection) {
+    subscribeCoinIndexPrice(symbol, updateSpeedMs = 3000) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'indexPrice';
         const speedSuffix = updateSpeedMs === 1000 ? '@1s' : '';
         const market = 'coinm';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) +
-            `/ws/${lowerCaseSymbol}@${streamName}${speedSuffix}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}${speedSuffix}`, wsKey);
     }
     /**
      * Subscribe to mark price for a symbol in a market category
      */
-    subscribeMarkPrice(symbol, market, updateSpeedMs = 3000, forceNewConnection) {
+    subscribeMarkPrice(symbol, market, updateSpeedMs = 3000) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'markPrice';
         const speedSuffix = updateSpeedMs === 1000 ? '@1s' : '';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) +
-            `/ws/${lowerCaseSymbol}@${streamName}${speedSuffix}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}${speedSuffix}`, wsKey);
     }
     /**
      * Subscribe to mark price for all symbols in a market category
      */
-    subscribeAllMarketMarkPrice(market, updateSpeedMs = 3000, forceNewConnection) {
+    subscribeAllMarketMarkPrice(market, updateSpeedMs = 3000) {
         const streamName = '!markPrice@arr';
         const speedSuffix = updateSpeedMs === 1000 ? '@1s' : '';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${streamName}${speedSuffix}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${streamName}${speedSuffix}`, wsKey);
     }
     /**
      * Subscribe to klines(candles) for a symbol in a market category
      */
-    subscribeKlines(symbol, interval, market, forceNewConnection) {
+    subscribeKlines(symbol, interval, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'kline';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol, interval);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) +
-            `/ws/${lowerCaseSymbol}@${streamName}_${interval}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}_${interval}`, wsKey);
     }
     /**
      * Subscribe to continuous contract klines(candles) for a symbol futures
      */
-    subscribeContinuousContractKlines(symbol, contractType, interval, market, forceNewConnection) {
+    subscribeContinuousContractKlines(symbol, contractType, interval, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'continuousKline';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol, interval);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) +
-            `/ws/${lowerCaseSymbol}_${contractType}@${streamName}_${interval}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}_${contractType}@${streamName}_${interval}`, wsKey);
     }
     /**
      * Subscribe to index klines(candles) for a symbol in a coinm futures
      */
-    subscribeIndexKlines(symbol, interval, forceNewConnection) {
+    subscribeIndexKlines(symbol, interval) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'indexPriceKline';
         const market = 'coinm';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol, interval);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) +
-            `/ws/${lowerCaseSymbol}@${streamName}_${interval}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}_${interval}`, wsKey);
     }
     /**
      * Subscribe to index klines(candles) for a symbol in a coinm futures
      */
-    subscribeMarkPriceKlines(symbol, interval, forceNewConnection) {
+    subscribeMarkPriceKlines(symbol, interval) {
         const lowerCaseSymbol = symbol.toLowerCase();
-        const streamName = 'markPrice_kline';
+        const streamName = 'markPriceKline';
         const market = 'coinm';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol, interval);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) +
-            `/ws/${lowerCaseSymbol}@${streamName}_${interval}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}_${interval}`, wsKey);
     }
     /**
      * Subscribe to mini 24hr ticker for a symbol in market category.
      */
-    subscribeSymbolMini24hrTicker(symbol, market, forceNewConnection) {
+    subscribeSymbolMini24hrTicker(symbol, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'miniTicker';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${lowerCaseSymbol}@${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}`, wsKey);
     }
     /**
      * Subscribe to mini 24hr mini ticker in market category.
      */
-    subscribeAllMini24hrTickers(market, forceNewConnection) {
+    subscribeAllMini24hrTickers(market) {
         const streamName = 'miniTicker';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/!${streamName}@arr`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`!${streamName}@arr`, wsKey);
     }
     /**
      * Subscribe to 24hr ticker for a symbol in any market.
      */
-    subscribeSymbol24hrTicker(symbol, market, forceNewConnection) {
+    subscribeSymbol24hrTicker(symbol, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'ticker';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${lowerCaseSymbol}@${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}`, wsKey);
     }
     /**
      * Subscribe to 24hr ticker in any market.
      */
-    subscribeAll24hrTickers(market, forceNewConnection) {
+    subscribeAll24hrTickers(market) {
         const streamName = 'ticker';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/!${streamName}@arr`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`!${streamName}@arr`, wsKey);
     }
     /**
      * Subscribe to rolling window ticker statistics for all market symbols,
@@ -847,45 +1109,44 @@ class WebsocketClient extends events_1.EventEmitter {
      * - Supported window sizes: 1h,4h,1d.
      * - Supported markets: spot
      */
-    subscribeAllRollingWindowTickers(market, windowSize, forceNewConnection) {
+    subscribeAllRollingWindowTickers(market, windowSize) {
         const streamName = 'ticker';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, windowSize);
-        const wsUrl = this.getWsBaseUrl(market, wsKey) + `/ws/!${streamName}_${windowSize}@arr`;
-        return this.connectToWsUrl(wsUrl, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`!${streamName}_${windowSize}@arr`, wsKey);
     }
     /**
      * Subscribe to best bid/ask for symbol in spot markets.
      */
-    subscribeSymbolBookTicker(symbol, market, forceNewConnection) {
+    subscribeSymbolBookTicker(symbol, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'bookTicker';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${lowerCaseSymbol}@${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}`, wsKey);
     }
     /**
      * Subscribe to best bid/ask for all symbols in spot markets.
      */
-    subscribeAllBookTickers(market, forceNewConnection) {
+    subscribeAllBookTickers(market) {
         const streamName = 'bookTicker';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/!${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`!${streamName}`, wsKey);
     }
     /**
      * Subscribe to best bid/ask for symbol in spot markets.
      */
-    subscribeSymbolLiquidationOrders(symbol, market, forceNewConnection) {
+    subscribeSymbolLiquidationOrders(symbol, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'forceOrder';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${lowerCaseSymbol}@${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}`, wsKey);
     }
     /**
      * Subscribe to best bid/ask for all symbols in spot markets.
      */
-    subscribeAllLiquidationOrders(market, forceNewConnection) {
+    subscribeAllLiquidationOrders(market) {
         const streamName = 'forceOrder@arr';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/!${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`!${streamName}`, wsKey);
     }
     /**
      * Subscribe to partial book depths (snapshots).
@@ -893,16 +1154,13 @@ class WebsocketClient extends events_1.EventEmitter {
      * Note:
      * - spot only supports 1000ms or 100ms for updateMs
      * - futures only support 100, 250 or 500ms for updateMs
-     *
-     * Use getContextFromWsKey(data.wsKey) to extract symbol from events
      */
-    subscribePartialBookDepths(symbol, levels, updateMs, market, forceNewConnection) {
+    subscribePartialBookDepths(symbol, levels, updateMs, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
         const streamName = 'depth';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName, lowerCaseSymbol);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
         const updateMsSuffx = typeof updateMs === 'number' ? `@${updateMs}ms` : '';
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) +
-            `/ws/${lowerCaseSymbol}@${streamName}${levels}${updateMsSuffx}`, wsKey, forceNewConnection);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}${levels}${updateMsSuffx}`, wsKey);
     }
     /**
      * Subscribe to orderbook depth updates to locally manage an order book.
@@ -911,24 +1169,21 @@ class WebsocketClient extends events_1.EventEmitter {
      *
      * - Spot: https://binance-docs.github.io/apidocs/spot/en/#diff-depth-stream
      * - USDM Futures: https://binance-docs.github.io/apidocs/futures/en/#diff-book-depth-streams
-     *
-     * Use getContextFromWsKey(data.wsKey) to extract symbol from events
      */
-    subscribeDiffBookDepth(symbol, updateMs = 100, market, forceNewConnection) {
+    subscribeDiffBookDepth(symbol, updateMs = 100, market) {
         const lowerCaseSymbol = symbol.toLowerCase();
-        const streamName = 'depth';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, 'diffBookDepth', lowerCaseSymbol, String(updateMs));
+        const streamName = market === 'spot' ? 'depth' : 'diffBookDepth';
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
         const updateMsSuffx = typeof updateMs === 'number' ? `@${updateMs}ms` : '';
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) +
-            `/ws/${lowerCaseSymbol}@${streamName}${updateMsSuffx}`, wsKey, forceNewConnection);
+        return this.subscribe(`${lowerCaseSymbol}@${streamName}${updateMsSuffx}`, wsKey);
     }
     /**
      * Subscribe to best bid/ask for all symbols in spot markets.
      */
-    subscribeContractInfoStream(market, forceNewConnection) {
+    subscribeContractInfoStream(market) {
         const streamName = '!contractInfo';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, streamName);
-        return this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${streamName}`, wsKey, forceNewConnection);
+        const wsKey = (0, websocket_util_1.resolveWsKeyForLegacyMarket)(market);
+        return this.subscribe(`${streamName}`, wsKey);
     }
     /**
      * --------------------------
@@ -938,224 +1193,62 @@ class WebsocketClient extends events_1.EventEmitter {
     /**
      * Subscribe to aggregate trades for a symbol in spot markets.
      */
-    subscribeSpotAggregateTrades(symbol, forceNewConnection) {
-        return this.subscribeAggregateTrades(symbol, 'spot', forceNewConnection);
+    subscribeSpotAggregateTrades(symbol) {
+        return this.subscribeAggregateTrades(symbol, 'spot');
     }
     /**
      * Subscribe to trades for a symbol in spot markets.
      */
-    subscribeSpotTrades(symbol, forceNewConnection) {
-        return this.subscribeTrades(symbol, 'spot', forceNewConnection);
+    subscribeSpotTrades(symbol) {
+        return this.subscribeTrades(symbol, 'spot');
     }
     /**
      * Subscribe to candles for a symbol in spot markets.
      */
-    subscribeSpotKline(symbol, interval, forceNewConnection) {
-        return this.subscribeKlines(symbol, interval, 'spot', forceNewConnection);
+    subscribeSpotKline(symbol, interval) {
+        return this.subscribeKlines(symbol, interval, 'spot');
     }
     /**
      * Subscribe to mini 24hr ticker for a symbol in spot markets.
      */
-    subscribeSpotSymbolMini24hrTicker(symbol, forceNewConnection) {
-        return this.subscribeSymbolMini24hrTicker(symbol, 'spot', forceNewConnection);
+    subscribeSpotSymbolMini24hrTicker(symbol) {
+        return this.subscribeSymbolMini24hrTicker(symbol, 'spot');
     }
     /**
      * Subscribe to mini 24hr mini ticker in spot markets.
      */
-    subscribeSpotAllMini24hrTickers(forceNewConnection) {
-        return this.subscribeAllMini24hrTickers('spot', forceNewConnection);
+    subscribeSpotAllMini24hrTickers() {
+        return this.subscribeAllMini24hrTickers('spot');
     }
     /**
      * Subscribe to 24hr ticker for a symbol in spot markets.
      */
-    subscribeSpotSymbol24hrTicker(symbol, forceNewConnection) {
-        return this.subscribeSymbol24hrTicker(symbol, 'spot', forceNewConnection);
+    subscribeSpotSymbol24hrTicker(symbol) {
+        return this.subscribeSymbol24hrTicker(symbol, 'spot');
     }
     /**
      * Subscribe to 24hr ticker in spot markets.
      */
-    subscribeSpotAll24hrTickers(forceNewConnection) {
-        return this.subscribeAll24hrTickers('spot', forceNewConnection);
+    subscribeSpotAll24hrTickers() {
+        return this.subscribeAll24hrTickers('spot');
     }
     /**
      * Subscribe to best bid/ask for symbol in spot markets.
      */
-    subscribeSpotSymbolBookTicker(symbol, forceNewConnection) {
-        return this.subscribeSymbolBookTicker(symbol, 'spot', forceNewConnection);
-    }
-    /**
-     * Subscribe to best bid/ask for all symbols in spot markets.
-     */
-    subscribeSpotAllBookTickers(forceNewConnection) {
-        return this.subscribeAllBookTickers('spot', forceNewConnection);
+    subscribeSpotSymbolBookTicker(symbol) {
+        return this.subscribeSymbolBookTicker(symbol, 'spot');
     }
     /**
      * Subscribe to top bid/ask levels for symbol in spot markets.
      */
-    subscribeSpotPartialBookDepth(symbol, levels, updateMs = 1000, forceNewConnection) {
-        return this.subscribePartialBookDepths(symbol, levels, updateMs, 'spot', forceNewConnection);
+    subscribeSpotPartialBookDepth(symbol, levels, updateMs = 1000) {
+        return this.subscribePartialBookDepths(symbol, levels, updateMs, 'spot');
     }
     /**
      * Subscribe to spot orderbook depth updates to locally manage an order book.
      */
-    subscribeSpotDiffBookDepth(symbol, updateMs = 1000, forceNewConnection) {
-        return this.subscribeDiffBookDepth(symbol, updateMs, 'spot', forceNewConnection);
-    }
-    /**
-     * Subscribe to a spot user data stream. Use REST client to generate and persist listen key.
-     * Supports spot, margin & isolated margin listen keys.
-     */
-    subscribeSpotUserDataStreamWithListenKey(listenKey, forceNewConnection, isReconnecting) {
-        const market = 'spot';
-        const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, 'userData', undefined, listenKey);
-        if (!forceNewConnection && this.wsStore.isWsConnecting(wsKey)) {
-            this.logger.silly('Existing spot user data connection in progress for listen key. Avoiding duplicate');
-            return this.getWs(wsKey);
-        }
-        this.setWsState(wsKey, isReconnecting
-            ? WsStore_1.WsConnectionStateEnum.RECONNECTING
-            : WsStore_1.WsConnectionStateEnum.CONNECTING);
-        const ws = this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${listenKey}`, wsKey, forceNewConnection);
-        // Start & store timer to keep alive listen key (and handle expiration)
-        this.setKeepAliveListenKeyTimer(listenKey, market, ws, wsKey);
-        return ws;
-    }
-    /**
-     * Subscribe to spot user data stream - listen key is automatically generated. Calling multiple times only opens one connection.
-     */
-    subscribeSpotUserDataStream(forceNewConnection, isReconnecting) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const { listenKey } = yield this.getSpotRestClient().getSpotUserDataListenKey();
-                return this.subscribeSpotUserDataStreamWithListenKey(listenKey, forceNewConnection, isReconnecting);
-            }
-            catch (e) {
-                this.logger.error('Failed to connect to spot user data', Object.assign(Object.assign({}, loggerCategory), { error: e }));
-                this.emit('error', { wsKey: 'spot' + '_' + 'userData', error: e });
-            }
-        });
-    }
-    /**
-     * Subscribe to margin user data stream - listen key is automatically generated.
-     */
-    subscribeMarginUserDataStream(forceNewConnection, isReconnecting) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const { listenKey } = yield this.getSpotRestClient().getMarginUserDataListenKey();
-                const market = 'margin';
-                const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, 'userData', undefined, listenKey);
-                if (!forceNewConnection && this.wsStore.isWsConnecting(wsKey)) {
-                    this.logger.silly('Existing margin user data connection in progress for listen key. Avoiding duplicate');
-                    return this.getWs(wsKey);
-                }
-                this.setWsState(wsKey, isReconnecting
-                    ? WsStore_1.WsConnectionStateEnum.RECONNECTING
-                    : WsStore_1.WsConnectionStateEnum.CONNECTING);
-                const ws = this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${listenKey}`, wsKey, forceNewConnection);
-                // Start & store timer to keep alive listen key (and handle expiration)
-                this.setKeepAliveListenKeyTimer(listenKey, market, ws, wsKey);
-                return ws;
-            }
-            catch (e) {
-                this.logger.error('Failed to connect to margin user data', Object.assign(Object.assign({}, loggerCategory), { error: e }));
-                this.emit('error', { wsKey: 'margin' + '_' + 'userData', error: e });
-            }
-        });
-    }
-    /**
-     * Subscribe to isolated margin user data stream - listen key is automatically generated.
-     */
-    subscribeIsolatedMarginUserDataStream(symbol, forceNewConnection, isReconnecting) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const lowerCaseSymbol = symbol.toLowerCase();
-                const { listenKey } = yield this.getSpotRestClient().getIsolatedMarginUserDataListenKey({
-                    symbol: lowerCaseSymbol,
-                });
-                const market = 'isolatedMargin';
-                const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, 'userData', lowerCaseSymbol, listenKey);
-                if (!forceNewConnection && this.wsStore.isWsConnecting(wsKey)) {
-                    this.logger.silly('Existing isolated margin user data connection in progress for listen key. Avoiding duplicate');
-                    return this.getWs(wsKey);
-                }
-                this.setWsState(wsKey, isReconnecting
-                    ? WsStore_1.WsConnectionStateEnum.RECONNECTING
-                    : WsStore_1.WsConnectionStateEnum.CONNECTING);
-                const ws = this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${listenKey}`, wsKey, forceNewConnection);
-                // Start & store timer to keep alive listen key (and handle expiration)
-                this.setKeepAliveListenKeyTimer(listenKey, market, ws, wsKey, symbol);
-                return ws;
-            }
-            catch (e) {
-                this.logger.error('Failed to connect to isolated margin user data', Object.assign(Object.assign({}, loggerCategory), { error: e, symbol }));
-                this.emit('error', {
-                    wsKey: 'isolatedMargin' + '_' + 'userData',
-                    error: e,
-                });
-            }
-        });
-    }
-    /**
-     * --------------------------
-     * End of SPOT market websocket streams
-     * --------------------------
-     **/
-    /**
-     * Subscribe to USD-M Futures user data stream - listen key is automatically generated.
-     */
-    subscribeUsdFuturesUserDataStream(isTestnet, forceNewConnection, isReconnecting) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const restClient = this.getUSDMRestClient(isTestnet);
-                const { listenKey } = yield restClient.getFuturesUserDataListenKey();
-                const market = isTestnet ? 'usdmTestnet' : 'usdm';
-                const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, 'userData', undefined, listenKey);
-                if (!forceNewConnection && this.wsStore.isWsConnecting(wsKey)) {
-                    this.logger.silly('Existing usd futures user data connection in progress for listen key. Avoiding duplicate');
-                    return this.getWs(wsKey);
-                }
-                // Necessary so client knows this is a reconnect
-                this.setWsState(wsKey, isReconnecting
-                    ? WsStore_1.WsConnectionStateEnum.RECONNECTING
-                    : WsStore_1.WsConnectionStateEnum.CONNECTING);
-                const ws = this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${listenKey}`, wsKey, forceNewConnection);
-                // Start & store timer to keep alive listen key (and handle expiration)
-                this.setKeepAliveListenKeyTimer(listenKey, market, ws, wsKey, undefined, isTestnet);
-                return ws;
-            }
-            catch (e) {
-                this.logger.error('Failed to connect to USD Futures user data', Object.assign(Object.assign({}, loggerCategory), { error: e }));
-                this.emit('error', { wsKey: 'usdm' + '_' + 'userData', error: e });
-            }
-        });
-    }
-    /**
-     * Subscribe to COIN-M Futures user data stream - listen key is automatically generated.
-     */
-    subscribeCoinFuturesUserDataStream(isTestnet, forceNewConnection, isReconnecting) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const { listenKey } = yield this.getCOINMRestClient(isTestnet).getFuturesUserDataListenKey();
-                const market = isTestnet ? 'coinmTestnet' : 'coinm';
-                const wsKey = (0, requestUtils_1.getWsKeyWithContext)(market, 'userData', undefined, listenKey);
-                if (!forceNewConnection && this.wsStore.isWsConnecting(wsKey)) {
-                    this.logger.silly('Existing usd futures user data connection in progress for listen key. Avoiding duplicate');
-                    return this.getWs(wsKey);
-                }
-                // Necessary so client knows this is a reconnect
-                this.setWsState(wsKey, isReconnecting
-                    ? WsStore_1.WsConnectionStateEnum.RECONNECTING
-                    : WsStore_1.WsConnectionStateEnum.CONNECTING);
-                const ws = this.connectToWsUrl(this.getWsBaseUrl(market, wsKey) + `/ws/${listenKey}`, wsKey, forceNewConnection);
-                // Start & store timer to keep alive listen key (and handle expiration)
-                this.setKeepAliveListenKeyTimer(listenKey, market, ws, wsKey, undefined, isTestnet);
-                return ws;
-            }
-            catch (e) {
-                this.logger.error('Failed to connect to COIN Futures user data', Object.assign(Object.assign({}, loggerCategory), { error: e }));
-                this.emit('error', { wsKey: 'coinm' + '_' + 'userData', error: e });
-            }
-        });
+    subscribeSpotDiffBookDepth(symbol, updateMs = 1000) {
+        return this.subscribeDiffBookDepth(symbol, updateMs, 'spot');
     }
 }
 exports.WebsocketClient = WebsocketClient;