binance 3.0.0-beta.1 → 3.0.0-beta.11

package/lib/websocket-client.js

@@ -8,6 +8,17 @@ 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 };
 };
@@ -15,9 +26,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebsocketClient = void 0;
 const BaseWSClient_1 = require("./util/BaseWSClient");
 const beautifier_1 = __importDefault(require("./util/beautifier"));
+const node_support_1 = require("./util/node-support");
 const requestUtils_1 = require("./util/requestUtils");
 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");
@@ -44,16 +55,36 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
         super(options, logger);
         this.restClientCache = new rest_client_cache_1.RestClientCache();
         this.beautifier = new beautifier_1.default({
-            warnKeyMissingInMap: true,
+            warnKeyMissingInMap: false,
         });
         this.respawnTimeoutCache = {};
+        if (options === null || options === void 0 ? void 0 : options.beautifyWarnIfMissing) {
+            this.beautifier.setWarnIfMissing(options.beautifyWarnIfMissing);
+        }
+        /**
+         * Binance uses native WebSocket ping/pong frames, which cannot be directly used in
+         * some environents (e.g. most browsers do not support sending raw ping/pong frames).
+         *
+         * This disables heartbeats in those environments, if ping/pong frames are unavailable.
+         *
+         * Some browsers may still handle these automatically. Some discussion around this can
+         * be found here: https://stackoverflow.com/questions/10585355/sending-websocket-ping-pong-frame-from-browser
+         */
+        if (!(0, websocket_util_1.isWSPingFrameAvailable)()) {
+            this.logger.info('Disabled WS heartbeats. WS.ping() is not available in your environment.');
+            this.options.disableHeartbeat = true;
+        }
         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),
+            respawnUserDataFn: (wsKey, market, context = {}) => {
+                return this.respawnUserDataStream(wsKey, market, context);
+            },
+            getWsUrlFn: (wsKey, connectionType) => {
+                return this.getWsUrl(wsKey, connectionType);
+            },
             getRestClientOptionsFn: () => this.getRestClientOptions(),
             getWsClientOptionsfn: () => this.options,
             closeWsFn: (wsKey, force) => this.close(wsKey, force),
@@ -64,25 +95,17 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
         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 });
+        return Object.assign(Object.assign(Object.assign({}, this.options), this.options.restOptions), { testnet: this.options.testnet, api_key: this.options.api_key, api_secret: this.options.api_secret });
     }
     /**
      * 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?
+     * for automatic connection by SDK.
+     *
+     * For the Binance SDK, this will only open public connections (without auth), but is almost definitely overkill if you're only working with one product group.
      */
     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.
@@ -95,18 +118,24 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
             this.connect(websocket_util_1.WS_KEY_MAP.eoptions),
         ];
     }
+    /**
+     * This function serves no purpose in the Binance SDK
+     */
     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;
         });
     }
+    /**
+     * 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 subscription to one or more topics. Pass topics as either an array of strings,
      * or array of objects (if the topic has parameters).
@@ -135,54 +164,75 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
         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
+             * Spot: https://developers.binance.com/docs/binance-spot-api-docs/websocket-api/general-api-information
+             * USDM Futures: https://developers.binance.com/docs/derivatives/usds-margined-futures/websocket-api-general-info
+             * COINM Futures: https://developers.binance.com/docs/derivatives/coin-margined-futures/websocket-api-general-info
              */
-            // 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');
+            var _a, _b;
+            // If testnet, enforce testnet wskey for WS API calls
+            const resolvedWsKey = this.options.testnet ? (0, websocket_util_1.getTestnetWsKey)(wsKey) : wsKey;
+            // this.logger.trace(`sendWSAPIRequest(): assertIsConnected("${wsKey}")...`);
+            const timestampBeforeAuth = Date.now();
+            yield this.assertIsConnected(resolvedWsKey);
+            // this.logger.trace('sendWSAPIRequest(): assertIsConnected(${wsKey}) ok');
+            // this.logger.trace('sendWSAPIRequest(): assertIsAuthenticated(${wsKey})...');
+            yield this.assertIsAuthenticated(resolvedWsKey);
+            const timestampAfterAuth = Date.now();
+            // this.logger.trace('sendWSAPIRequest(): assertIsAuthenticated(${wsKey}) ok');
             const request = {
                 id: this.getNewRequestId(),
                 method: operation,
-                params: Object.assign({ timestamp: Date.now(), recvWindow: this.options.recvWindow }, params),
+                params: Object.assign({}, params),
             };
-            if ((0, requestUtils_1.requiresWSAPINewClientOID)(request, wsKey)) {
-                (0, requestUtils_1.validateWSAPINewClientOID)(request, wsKey);
+            /**
+             * Some WS API requests require a timestamp to be included. assertIsConnected and assertIsAuthenticated
+             * can introduce a small delay before the actual request is sent, if not connected before that request is
+             * made. This can lead to a curious race condition, where the request timestamp is before
+             * the "authorizedSince" timestamp - as such, binance does not recognise the session as already authenticated.
+             *
+             * The below mechanism measures any delay introduced from the assert calls, and if the request includes a timestamp,
+             * it offsets that timestamp by the delay.
+             */
+            const delayFromAuthAssert = timestampAfterAuth - timestampBeforeAuth;
+            if (delayFromAuthAssert && ((_a = request.params) === null || _a === void 0 ? void 0 : _a.timestamp)) {
+                request.params.timestamp += delayFromAuthAssert;
+                this.logger.trace(`sendWSAPIRequest(): adjust timestamp - delay seen by connect/auth assert and delayed request includes timestamp, adjusting timestamp by ${delayFromAuthAssert}ms`);
+            }
+            if ((0, requestUtils_1.requiresWSAPINewClientOID)(request, resolvedWsKey)) {
+                (0, requestUtils_1.validateWSAPINewClientOID)(request, resolvedWsKey);
             }
             // 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);
+            const promiseRef = (0, websocket_util_1.getPromiseRefForWSAPIRequest)(resolvedWsKey, signedEvent);
+            const deferredPromise = this.getWsStore().createDeferredPromise(resolvedWsKey, promiseRef, false);
+            (_b = deferredPromise.promise) === null || _b === void 0 ? void 0 : _b.then((res) => {
+                if (!Array.isArray(res)) {
+                    res.request = Object.assign({ wsKey: resolvedWsKey }, signedEvent);
+                }
+                return res;
+            }).catch((e) => {
+                if (typeof e === 'string') {
+                    this.logger.error('unexpcted string', { e });
+                    return e;
+                }
+                e.request = {
+                    wsKey: resolvedWsKey,
+                    operation,
+                    params: signedEvent.params,
+                };
+                // throw e;
+                return e;
+            });
             // this.logger.trace(
             //   `sendWSAPIRequest(): sending raw request: ${JSON.stringify(signedEvent)} with promiseRef(${promiseRef})`,
             // );
-            // Send event
-            this.tryWsSend(wsKey, JSON.stringify(signedEvent));
+            // Send event.
+            const throwExceptions = true;
+            this.tryWsSend(resolvedWsKey, JSON.stringify(signedEvent), throwExceptions);
             this.logger.trace(`sendWSAPIRequest(): sent "${operation}" event with promiseRef(${promiseRef})`);
             // Return deferred promise, so caller can await this call
             return deferredPromise.promise;
@@ -210,13 +260,35 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
             if (typeof this.options.customSignMessageFn === 'function') {
                 return this.options.customSignMessageFn(paramsStr, secret);
             }
-            return yield (0, webCryptoAPI_1.signMessage)(paramsStr, secret, method, algorithm);
+            return yield (0, node_support_1.signMessage)(paramsStr, secret, method, algorithm);
+            // return await signMessageWebCryptoAPI(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.
+            if (!requestEvent.params) {
+                return requestEvent;
+            }
+            /**
+             *
+             */
+            // Not needed for most commands on binance Binance. Auth happens only on connection open, automatically.
             // Faster than performing auth for every request
+            // However, some commands don't work without this for some reason...
+            const _a = requestEvent.params, { signRequest } = _a, otherParams = __rest(_a, ["signRequest"]);
+            if (signRequest) {
+                const strictParamValidation = true;
+                const encodeValues = true;
+                const filterUndefinedParams = true;
+                const semiFinalRequestParams = Object.assign({ apiKey: this.options.api_key }, otherParams);
+                const serialisedParams = (0, requestUtils_1.serialiseParams)(semiFinalRequestParams, strictParamValidation, encodeValues, filterUndefinedParams);
+                const signature = yield this.signMessage(serialisedParams, this.options.api_secret, 'base64', 'SHA-256');
+                console.log('signWSAPIRequest()', {
+                    semiFinalRequestParams,
+                    serialisedParams,
+                });
+                return Object.assign(Object.assign({}, requestEvent), { params: Object.assign(Object.assign({}, semiFinalRequestParams), { signature }) });
+            }
             return requestEvent;
         });
     }
@@ -227,22 +299,21 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                 // 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 recvWindow = this.options.recvWindow || 0;
+                const timestamp = Date.now() + (this.getTimeOffsetMs() || 0); // + recvWindow;
                 const strictParamValidation = true;
                 const encodeValues = true;
                 const filterUndefinedParams = true;
-                const authParams = {
+                const params = {
                     apiKey: this.options.api_key,
                     timestamp,
                 };
-                const serialisedParams = (0, requestUtils_1.serialiseParams)(authParams, strictParamValidation, encodeValues, filterUndefinedParams);
+                const serialisedParams = (0, requestUtils_1.serialiseParams)(params, 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 }),
+                    params: Object.assign(Object.assign({}, params), { signature }),
                 };
                 return request;
             }
@@ -252,36 +323,12 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
             }
         });
     }
-    // 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 {
+            if (!(0, websocket_util_1.isWSPingFrameAvailable)()) {
+                this.logger.trace('Unable to send WS ping frame. Not available in this environment.', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey }));
+                return;
+            }
             // this.logger.trace(`Sending upstream ping: `, { ...loggerCategory, wsKey });
             if (!wsKey) {
                 throw new Error('No wsKey provided');
@@ -304,8 +351,11 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
         }
     }
     sendPongEvent(wsKey) {
-        // ws.pong();
         try {
+            if (!(0, websocket_util_1.isWSPongFrameAvailable)()) {
+                this.logger.trace('Unable to send WS pong frame. Not available in this environment.', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey }));
+                return;
+            }
             // this.logger.trace(`Sending upstream ping: `, { ...loggerCategory, wsKey });
             if (!wsKey) {
                 throw new Error('No wsKey provided');
@@ -347,6 +397,8 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                         params: topics,
                         id: req_id,
                     };
+                    // Cache midflight subs on the req ID
+                    // Enrich response with subs for that req ID
                     const midflightWsEvent = {
                         requestKey: wsEvent.id,
                         requestEvent: wsEvent,
@@ -354,9 +406,6 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                     wsRequestEvents.push(Object.assign({}, midflightWsEvent));
                     break;
                 }
-                // default: {
-                // throw neverGuard(wsKey, `Unhandled wsKey "${wsKey}"`);
-                // }
             }
             if (wsRequestBuildingErrors.length) {
                 const label = wsRequestBuildingErrors.length === requests.length ? 'all' : 'some';
@@ -402,28 +451,71 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
      * Abstraction called to sort ws events into emittable event types (response to a request, data update, etc)
      */
     resolveEmittableEvents(wsKey, event) {
-        var _a, _b, _c;
+        var _a, _b;
+        this.logger.trace(`resolveEmittableEvents(${wsKey}): `, event === null || event === void 0 ? void 0 : event.data);
         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);
+            /**
+             *
+             * Extract event from JSON
+             *
+             */
+            const parsedEvent = (0, websocket_util_1.parseRawWsMessage)(event);
+            /**
+             *
+             * Minor data normalisation & preparation
+             *
+             */
+            // ws consumers: { data: ... }
+            // ws api consumers (user data): { event: ... }
+            // other responses: { ... }
+            const eventData = (parsedEvent === null || parsedEvent === void 0 ? void 0 : parsedEvent.data) || (parsedEvent === null || parsedEvent === void 0 ? void 0 : parsedEvent.event) || parsedEvent;
+            const parsedEventId = parsedEvent === null || parsedEvent === void 0 ? void 0 : parsedEvent.id;
+            const parsedEventErrorCode = (_a = parsedEvent === null || parsedEvent === void 0 ? void 0 : parsedEvent.error) === null || _a === void 0 ? void 0 : _a.code;
+            const streamName = parsedEvent === null || parsedEvent === void 0 ? void 0 : parsedEvent.stream;
+            const eventType = 
+            // First try, the child node
+            (0, websocket_util_1.parseEventTypeFromMessage)(wsKey, eventData) ||
+                // Second try, the parent
+                (0, websocket_util_1.parseEventTypeFromMessage)(wsKey, parsedEvent);
             // 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);
+            (0, requestUtils_1.appendEventIfMissing)(eventData, wsKey, eventType);
             const legacyContext = (0, websocket_util_1.getLegacyWsKeyContext)(wsKey);
-            if (legacyContext) {
-                parsed.wsMarket = legacyContext.market;
+            const wsMarket = legacyContext
+                ? legacyContext.market
+                : (0, websocket_util_1.resolveUserDataMarketForWsKey)(wsKey);
+            // This attaches `wsMarket` and `streamName` to incoming events
+            // If the event is an array, it's attached to each element in the array
+            if (Array.isArray(eventData)) {
+                for (const row of eventData) {
+                    row.wsMarket = wsMarket;
+                    if (streamName && !row.streamName) {
+                        row.streamName = streamName;
+                    }
+                }
             }
-            // const eventType = eventType; //parsed?.stream;
-            // const eventOperation = parsed?.op;
+            else {
+                eventData.wsMarket = wsMarket;
+                if (streamName && !eventData.streamName) {
+                    eventData.streamName = streamName;
+                }
+            }
+            /**
+             *
+             *
+             * Main parsing logic below:
+             *
+             *
+             */
             const traceEmittable = false;
             if (traceEmittable) {
-                this.logger.trace('resolveEmittableEvents', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey,
-                    eventType, parsed: JSON.stringify(parsed) }));
+                this.logger.trace('resolveEmittableEvents', Object.assign(Object.assign({}, WS_LOGGER_CATEGORY), { wsKey, parsedEvent: JSON.stringify(parsedEvent), parsedEventData: JSON.stringify(eventData), eventType, properties: {
+                        parsedEventId,
+                        parsedEventErrorCode,
+                    } }));
             }
-            const reqId = parsed.id;
-            const isWSAPIResponse = typeof parsed.id === 'number';
+            const isWSAPIResponse = typeof parsedEventId === 'number';
             const EVENTS_AUTHENTICATED = ['auth'];
             const EVENTS_RESPONSES = [
                 'subscribe',
@@ -433,9 +525,7 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                 '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):
                  *
@@ -444,86 +534,92 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                  *     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
+                 * Currently there's no simple way to tell this apart from an actual WS API response with
+                 * error. So subscribe/unsubscribe requests will simply look like a WS API response internally,
+                 * but that will not affect usage.
                  *
-                 * Example wsapi error:
+                 * Unrelated, example wsapi error for reference:
                  *
-        {
-          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
-        }
+                    {
+                      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
+                    }
                  */
-                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;
+                const isError = typeof parsedEventErrorCode === 'number' &&
+                    parsedEventErrorCode !== 0;
                 // This is the counterpart to getPromiseRefForWSAPIRequest
-                const promiseRef = [wsKey, reqId].join('_');
-                if (!reqId) {
+                const promiseRef = [wsKey, parsedEventId].join('_');
+                if (!parsedEventId) {
                     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,
+                        parsedEvent: eventData,
                     });
                 }
                 // WS API Exception
                 if (isError) {
                     try {
-                        this.getWsStore().rejectDeferredPromise(wsKey, promiseRef, Object.assign({ wsKey }, parsed), true);
+                        this.getWsStore().rejectDeferredPromise(wsKey, promiseRef, Object.assign({ wsKey }, eventData), true);
                     }
                     catch (e) {
                         this.logger.error('Exception trying to reject WSAPI promise', {
                             wsKey,
                             promiseRef,
-                            parsedEvent: parsed,
+                            parsedEvent: eventData,
+                            e,
                         });
                     }
                     results.push({
                         eventType: 'exception',
-                        event: parsed,
+                        event: eventData,
                         isWSAPIResponse: isWSAPIResponse,
                     });
                     return results;
                 }
                 // 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 ((_b = eventData.result) === null || _b === void 0 ? void 0 : _b.apiKey) {
+                    // Note: Without this check, this will also trigger "onWsAuthenticated()" for session.status requests
                     if (this.getWsStore().getAuthenticationInProgressPromise(wsKey)) {
                         results.push({
                             eventType: 'authenticated',
-                            event: parsed,
+                            event: eventData,
                             isWSAPIResponse: isWSAPIResponse,
                         });
                     }
                 }
                 // WS API Success
                 try {
-                    this.getWsStore().resolveDeferredPromise(wsKey, promiseRef, Object.assign({ wsKey }, parsed), true);
+                    this.getWsStore().resolveDeferredPromise(wsKey, promiseRef, Object.assign({ wsKey }, eventData), true);
                 }
                 catch (e) {
                     this.logger.error('Exception trying to resolve WSAPI promise', {
                         wsKey,
                         promiseRef,
-                        parsedEvent: parsed,
+                        parsedEvent: eventData,
+                        e,
                     });
                 }
                 results.push({
                     eventType: 'response',
-                    event: parsed,
+                    event: Object.assign(Object.assign({}, eventData), { request: this.getCachedMidFlightRequest(wsKey, `${parsedEventId}`) }),
                     isWSAPIResponse: isWSAPIResponse,
                 });
+                this.removeCachedMidFlightRequest(wsKey, `${parsedEventId}`);
                 return results;
             }
             // Handle incoming event that listen key expired
@@ -533,16 +629,16 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                     // 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);
+                this.logger.info(`${legacyContext.market} listenKey EXPIRED - attempting to respawn user data stream: ${wsKey}`, eventData);
                 // 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');
             }
             if (this.options.beautify) {
-                const beautifiedMessage = this.beautifier.beautifyWsMessage(parsed, eventType, false, 
+                const beautifiedMessage = this.beautifier.beautifyWsMessage(eventData, eventType, false, 
                 // Suffix all events for the beautifier, if market is options
-                // Options has some conflicting keys with different intentions
+                // Options has some conflicting keys with different intentions, so will be suffixed
                 wsKey === 'eoptions' ? 'Options' : '');
                 results.push({
                     eventType: 'formattedMessage',
@@ -551,19 +647,7 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                 });
                 // 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)) {
+                    if (websocket_util_1.EVENT_TYPES_USER_DATA.includes(eventType)) {
                         results.push({
                             eventType: 'formattedUserDataMessage',
                             event: beautifiedMessage,
@@ -576,17 +660,17 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
             if (typeof eventType === 'string') {
                 results.push({
                     eventType: 'message',
-                    event: (parsed === null || parsed === void 0 ? void 0 : parsed.data) ? parsed.data : parsed,
+                    event: (eventData === null || eventData === void 0 ? void 0 : eventData.data) ? eventData.data : eventData,
                 });
                 return results;
             }
             // 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) {
+                if (eventData.success === false) {
                     results.push({
                         eventType: 'exception',
-                        event: parsed,
+                        event: eventData,
                     });
                     return results;
                 }
@@ -594,7 +678,7 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                 if (EVENTS_RESPONSES.includes(eventType)) {
                     results.push({
                         eventType: 'response',
-                        event: parsed,
+                        event: eventData,
                     });
                     return results;
                 }
@@ -602,19 +686,19 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                 if (EVENTS_AUTHENTICATED.includes(eventType)) {
                     results.push({
                         eventType: 'authenticated',
-                        event: parsed,
+                        event: eventData,
                     });
                     return results;
                 }
-                this.logger.error(`!! Unhandled string operation type "${eventType}". Defaulting to "update" channel...`, parsed);
+                this.logger.error(`!! Unhandled string operation type "${eventType}". Defaulting to "update" channel... raw event:`, JSON.stringify(parsedEvent));
             }
             else {
-                this.logger.error(`!!!! Unhandled non-string event type "${eventType}". Defaulting to "update" channel...`, parsed);
+                this.logger.error(`!!!! Unhandled non-string event type "${eventType}". Defaulting to "update" channel... raw event:`, JSON.stringify(parsedEvent));
             }
             // In case of catastrophic failure, fallback to noisy emit update
             results.push({
                 eventType: 'message',
-                event: parsed,
+                event: eventData,
             });
         }
         catch (e) {
@@ -748,7 +832,6 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
     }
     triggerCustomReconnectionWorkflow(legacyWsKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log(`triggerCustomReconnectionWorkflow(${legacyWsKey})`);
             if (legacyWsKey.includes('userData')) {
                 return this.getUserDataStreamManager().triggerUserDataReconnectionWorkflow(legacyWsKey);
             }
@@ -790,13 +873,13 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
                         ws = yield this.subscribeUsdFuturesUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'usdmTestnet':
-                        ws = yield this.subscribeUsdFuturesUserDataStream('usdmTestnet', forceNewConnection, miscConnectionState);
+                        ws = yield this.subscribeUsdFuturesUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'coinm':
                         ws = yield this.subscribeCoinFuturesUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'coinmTestnet':
-                        ws = yield this.subscribeCoinFuturesUserDataStream('coinmTestnet', forceNewConnection, miscConnectionState);
+                        ws = yield this.subscribeCoinFuturesUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
                         break;
                     case 'portfoliom':
                         ws = yield this.subscribePortfolioMarginUserDataStream(realWsKey, forceNewConnection, miscConnectionState);
@@ -849,7 +932,7 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
         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 restClient = this.restClientCache.getUSDMRestClient(this.getRestClientOptions(), this.options.requestOptions);
                 const { listenKey } = yield restClient.getFuturesUserDataListenKey();
                 const market = isTestnet ? 'usdmTestnet' : 'usdm';
                 return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, market, listenKey, forceNewConnection, miscState);
@@ -861,6 +944,18 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
             }
         });
     }
+    closeUserDataStream() {
+        return __awaiter(this, arguments, void 0, function* (wsKey = 'usdm') {
+            const wsKeys = this.getWsStore().getKeys();
+            const userDataWsKey = wsKeys.find((key) => {
+                return key === wsKey || key.startsWith(wsKey + '_userData');
+            });
+            if (!userDataWsKey) {
+                throw new Error(`No matching connection found with wsKey "${wsKey}". Active connections: [${JSON.stringify(wsKey)}]`);
+            }
+            this.close(userDataWsKey);
+        });
+    }
     /**
      * Subscribe to COIN-M Futures user data stream - listen key is automatically generated.
      */
@@ -870,7 +965,7 @@ class WebsocketClient extends BaseWSClient_1.BaseWebsocketClient {
             try {
                 const isTestnet = wsKey === websocket_util_1.WS_KEY_MAP.coinmTestnet;
                 const { listenKey } = yield this.restClientCache
-                    .getCOINMRestClient(this.getRestClientOptions(), this.options.requestOptions, isTestnet)
+                    .getCOINMRestClient(this.getRestClientOptions(), this.options.requestOptions)
                     .getFuturesUserDataListenKey();
                 const market = isTestnet ? 'coinmTestnet' : 'coinm';
                 return this.getUserDataStreamManager().subscribeGeneralUserDataStreamWithListenKey(wsKey, market, listenKey, forceNewConnection, miscState);