binance 3.0.0-beta.4 → 3.0.0-beta.6

package/lib/websocket-api-client.js

@@ -35,65 +35,25 @@ function getFuturesMarketWsKey(market) {
  * Refer to the WS API promises example for a more detailed example on using sendWSAPIRequest() directly:
  * https://github.com/tiagosiebler/binance/blob/wsapi/examples/ws-api-promises.ts#L52-L61
  */
-class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
+class WebsocketAPIClient {
     constructor(options, logger) {
-        super(options, logger);
         /**
          * Minimal state store around automating sticky "userDataStream.subscribe" sessions
          */
         this.subscribedUserDataStreamState = {};
-        this.wsAPIClientOptions = Object.assign({ onReconnectResubscribeUserDataStream: false, resubscribeUserDataStreamDelaySeconds: 2 }, this.options);
-        this.on('reconnected', ({ wsKey }) => {
-            var _a;
-            // Delay existing timer, if exists
-            if (this.wsAPIClientOptions.onReconnectResubscribeUserDataStream &&
-                (0, typeGuards_1.isWSAPIWsKey)(wsKey) &&
-                this.subscribedUserDataStreamState[wsKey]) {
-                if ((_a = this.subscribedUserDataStreamState[wsKey]) === null || _a === void 0 ? void 0 : _a.respawnTimeout) {
-                    clearTimeout(this.subscribedUserDataStreamState[wsKey].respawnTimeout);
-                    delete this.subscribedUserDataStreamState[wsKey].respawnTimeout;
-                    this.logger.error('tryResubscribeUserDataStream(): Respawn timer already active while trying to queue respawn...delaying existing timer further...', Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), { wsKey }));
-                }
-                this.logger.error('tryResubscribeUserDataStream(): queued resubscribe for wsKey user data stream', Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), { wsKey }));
-                // Queue resubscribe workflow
-                this.subscribedUserDataStreamState[wsKey].respawnTimeout = setTimeout(() => {
-                    this.tryResubscribeUserDataStream(wsKey);
-                }, 1000 * this.wsAPIClientOptions.resubscribeUserDataStreamDelaySeconds);
-                return;
-            }
+        this.wsClient = new websocket_client_1.WebsocketClient(options, logger);
+        this.options = Object.assign({ resubscribeUserDataStreamAfterReconnect: true, resubscribeUserDataStreamDelaySeconds: 2, attachEventListeners: true }, options);
+        this.logger = this.wsClient.logger;
+        this.setupDefaultEventListeners();
+        this.wsClient.on('reconnected', ({ wsKey }) => {
+            this.handleWSReconnectedEvent({ wsKey });
         });
     }
-    tryResubscribeUserDataStream(wsKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const subscribeState = this.getSubscribedUserDataStreamState(wsKey);
-            const respawnDelayInSeconds = this.wsAPIClientOptions.resubscribeUserDataStreamDelaySeconds;
-            this.logger.error('tryResubscribeUserDataStream(): resubscribing to user data stream....', Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), { wsKey }));
-            try {
-                if ((_a = this.subscribedUserDataStreamState[wsKey]) === null || _a === void 0 ? void 0 : _a.respawnTimeout) {
-                    clearTimeout(this.subscribedUserDataStreamState[wsKey].respawnTimeout);
-                    delete this.subscribedUserDataStreamState[wsKey].respawnTimeout;
-                }
-                subscribeState.subscribeAttempt++;
-                yield this.requestSubscribeUserDataStream(wsKey);
-                this.subscribedUserDataStreamState[wsKey] = Object.assign(Object.assign({}, subscribeState), { subscribedAt: new Date(), subscribeAttempt: 0 });
-                this.logger.info('tryResubscribeUserDataStream()->ok', Object.assign(Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), subscribeState), { wsKey }));
-            }
-            catch (e) {
-                this.logger.error('tryResubscribeUserDataStream() exception - retry after timeout', Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), { wsKey, exception: e, subscribeState }));
-                subscribeState.respawnTimeout = setTimeout(() => {
-                    this.tryResubscribeUserDataStream(wsKey);
-                }, 1000 * respawnDelayInSeconds);
-                this.subscribedUserDataStreamState[wsKey] = Object.assign({}, subscribeState);
-            }
-        });
+    getWSClient() {
+        return this.wsClient;
     }
-    getSubscribedUserDataStreamState(wsKey) {
-        const subscribedState = this.subscribedUserDataStreamState[wsKey] || {
-            subscribedAt: new Date(),
-            subscribeAttempt: 0,
-        };
-        return subscribedState;
+    setTimeOffsetMs(newOffset) {
+        return this.getWSClient().setTimeOffsetMs(newOffset);
     }
     /*
      *
@@ -104,22 +64,22 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * Test connectivity to the WebSocket API
      */
     testSpotConnectivity(wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ping');
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ping');
     }
     /**
      * Test connectivity to the WebSocket API and get the current server time
      */
     getSpotServerTime(wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'time');
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'time');
     }
     /**
      * Query current exchange trading rules, rate limits, and symbol information
      */
     getSpotExchangeInfo(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'exchangeInfo', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'exchangeInfo', params);
     }
     getSpotSessionStatus(wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'session.status');
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'session.status');
     }
     /*
      *
@@ -131,82 +91,82 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * Note: If you need to continuously monitor order book updates, consider using WebSocket Streams
      */
     getSpotOrderBook(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'depth', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'depth', params);
     }
     /**
      * Get recent trades
      * Note: If you need access to real-time trading activity, consider using WebSocket Streams
      */
     getSpotRecentTrades(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'trades.recent', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'trades.recent', params);
     }
     /**
      * Get historical trades
      * Note: If fromId is not specified, the most recent trades are returned
      */
     getSpotHistoricalTrades(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'trades.historical', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'trades.historical', params);
     }
     /**
      * Get aggregate trades
      * Note: An aggregate trade represents one or more individual trades that fill at the same time
      */
     getSpotAggregateTrades(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'trades.aggregate', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'trades.aggregate', params);
     }
     /**
      * Get klines (candlestick bars)
      * Note: If you need access to real-time kline updates, consider using WebSocket Streams
      */
     getSpotKlines(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'klines', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'klines', params);
     }
     /**
      * Get klines (candlestick bars) optimized for presentation
      * Note: This request is similar to klines, having the same parameters and response
      */
     getSpotUIKlines(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'uiKlines', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'uiKlines', params);
     }
     /**
      * Get current average price for a symbol
      */
     getSpotAveragePrice(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'avgPrice', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'avgPrice', params);
     }
     /**
      * Get 24-hour rolling window price change statistics
      * Note: If you need to continuously monitor trading statistics, consider using WebSocket Streams
      */
     getSpot24hrTicker(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker.24hr', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker.24hr', params);
     }
     /**
      * Get price change statistics for a trading day
      */
     getSpotTradingDayTicker(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker.tradingDay', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker.tradingDay', params);
     }
     /**
      * Get rolling window price change statistics with a custom window
      * Note: Window size precision is limited to 1 minute
      */
     getSpotTicker(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker', params);
     }
     /**
      * Get the latest market price for a symbol
      * Note: If you need access to real-time price updates, consider using WebSocket Streams
      */
     getSpotSymbolPriceTicker(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker.price', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker.price', params);
     }
     /**
      * Get the current best price and quantity on the order book
      * Note: If you need access to real-time order book ticker updates, consider using WebSocket Streams
      */
     getSpotSymbolOrderBookTicker(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker.book', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'ticker.book', params);
     }
     /*
      *
@@ -217,112 +177,112 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * Submit a spot order
      */
     submitNewSpotOrder(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.place', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.place', params);
     }
     /**
      * Test order placement
      * Note: Validates new order parameters and verifies your signature but does not send the order into the matching engine
      */
     testSpotOrder(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.test', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.test', params);
     }
     /**
      * Check execution status of an order
      * Note: If both orderId and origClientOrderId parameters are specified, only orderId is used
      */
     getSpotOrderStatus(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.status', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.status', params);
     }
     /**
      * Cancel an active order
      * Note: If both orderId and origClientOrderId parameters are specified, only orderId is used
      */
     cancelSpotOrder(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.cancel', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.cancel', params);
     }
     /**
      * Cancel an existing order and immediately place a new order
      * Note: If both cancelOrderId and cancelOrigClientOrderId parameters are specified, only cancelOrderId is used
      */
     cancelReplaceSpotOrder(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.cancelReplace', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'order.cancelReplace', params);
     }
     /**
      * Query execution status of all open orders
      * Note: If you need to continuously monitor order status updates, consider using WebSocket Streams
      */
     getSpotOpenOrders(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'openOrders.status', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'openOrders.status', params);
     }
     /**
      * Cancel all open orders on a symbol
      * Note: This includes orders that are part of an order list
      */
     cancelAllSpotOpenOrders(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'openOrders.cancelAll', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'openOrders.cancelAll', params);
     }
     /**
      * Place a new order list
      * Note: This is a deprecated endpoint, consider using placeOCOOrderList instead
      */
     placeSpotOrderList(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.place', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.place', params);
     }
     /**
      * Place a new OCO (One-Cancels-the-Other) order list
      * Note: Activation of one order immediately cancels the other
      */
     placeSpotOCOOrderList(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.place.oco', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.place.oco', params);
     }
     /**
      * Place a new OTO (One-Triggers-the-Other) order list
      * Note: The pending order is placed only when the working order is fully filled
      */
     placeSpotOTOOrderList(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.place.oto', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.place.oto', params);
     }
     /**
      * Place a new OTOCO (One-Triggers-One-Cancels-the-Other) order list
      * Note: The pending orders are placed only when the working order is fully filled
      */
     placeSpotOTOCOOrderList(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.place.otoco', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.place.otoco', params);
     }
     /**
      * Check execution status of an order list
      * Note: If both origClientOrderId and orderListId parameters are specified, only origClientOrderId is used
      */
     getSpotOrderListStatus(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.status', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.status', params);
     }
     /**
      * Cancel an active order list
      * Note: If both orderListId and listClientOrderId parameters are specified, only orderListId is used
      */
     cancelSpotOrderList(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.cancel', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'orderList.cancel', params);
     }
     /**
      * Query execution status of all open order lists
      * Note: If you need to continuously monitor order status updates, consider using WebSocket Streams
      */
     getSpotOpenOrderLists(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'openOrderLists.status', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'openOrderLists.status', params);
     }
     /**
      * Place a new order using Smart Order Routing (SOR)
      * Note: Only supports LIMIT and MARKET orders. quoteOrderQty is not supported
      */
     placeSpotSOROrder(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'sor.order.place', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'sor.order.place', params);
     }
     /**
      * Test new order creation and signature/recvWindow using Smart Order Routing (SOR)
      * Note: Creates and validates a new order but does not send it into the matching engine
      */
     testSpotSOROrder(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'sor.order.test', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'sor.order.test', params);
     }
     /*
      *
@@ -334,56 +294,56 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * Note: Weight: 20
      */
     getSpotAccountStatus(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'account.status', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'account.status', params);
     }
     /**
      * Query your current unfilled order count for all intervals
      * Note: Weight: 40
      */
     getSpotOrderRateLimits(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'account.rateLimits.orders', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'account.rateLimits.orders', params);
     }
     /**
      * Query information about all your orders – active, canceled, filled – filtered by time range
      * Note: Weight: 20
      */
     getSpotAllOrders(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'allOrders', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'allOrders', params);
     }
     /**
      * Query information about all your order lists, filtered by time range
      * Note: Weight: 20
      */
     getSpotAllOrderLists(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'allOrderLists', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'allOrderLists', params);
     }
     /**
      * Query information about all your trades, filtered by time range
      * Note: Weight: 20
      */
     getSpotMyTrades(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'myTrades', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'myTrades', params);
     }
     /**
      * Displays the list of orders that were expired due to STP
      * Note: Weight varies based on query type (2-20)
      */
     getSpotPreventedMatches(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'myPreventedMatches', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'myPreventedMatches', params);
     }
     /**
      * Retrieves allocations resulting from SOR order placement
      * Note: Weight: 20
      */
     getSpotAllocations(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'myAllocations', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'myAllocations', params);
     }
     /**
      * Get current account commission rates
      * Note: Weight: 20
      */
     getSpotAccountCommission(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'account.commission', params);
+        return this.wsClient.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'account.commission', params);
     }
     /*
      *
@@ -395,21 +355,21 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * Note: If you need to continuously monitor order book updates, consider using WebSocket Streams
      */
     getFuturesOrderBook(params) {
-        return this.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'depth', params);
+        return this.wsClient.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'depth', params);
     }
     /**
      * Get latest price for a futures symbol or symbols
      * Note: If symbol is not provided, prices for all symbols will be returned
      */
     getFuturesSymbolPriceTicker(params) {
-        return this.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'ticker.price', params);
+        return this.wsClient.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'ticker.price', params);
     }
     /**
      * Get best price/qty on the order book for a futures symbol or symbols
      * Note: If symbol is not provided, bookTickers for all symbols will be returned
      */
     getFuturesSymbolOrderBookTicker(params) {
-        return this.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'ticker.book', params);
+        return this.wsClient.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'ticker.book', params);
     }
     /*
      *
@@ -422,7 +382,7 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * This endpoint is used for both USDM and COINM futures.
      */
     submitNewFuturesOrder(market, params) {
-        return this.sendWSAPIRequest(getFuturesMarketWsKey(market), 'order.place', params);
+        return this.wsClient.sendWSAPIRequest(getFuturesMarketWsKey(market), 'order.place', params);
     }
     /**
      * Modify an existing futures order
@@ -430,7 +390,7 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * This endpoint is used for both USDM and COINM futures.
      */
     modifyFuturesOrder(market, params) {
-        return this.sendWSAPIRequest(getFuturesMarketWsKey(market), 'order.modify', params);
+        return this.wsClient.sendWSAPIRequest(getFuturesMarketWsKey(market), 'order.modify', params);
     }
     /**
      * Cancel a futures order
@@ -438,7 +398,7 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * This endpoint is used for both USDM and COINM futures.
      */
     cancelFuturesOrder(market, params) {
-        return this.sendWSAPIRequest(getFuturesMarketWsKey(market), 'order.cancel', params);
+        return this.wsClient.sendWSAPIRequest(getFuturesMarketWsKey(market), 'order.cancel', params);
     }
     /**
      * Query futures order status
@@ -446,14 +406,14 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * This endpoint is used for both USDM and COINM futures.
      */
     getFuturesOrderStatus(market, params) {
-        return this.sendWSAPIRequest(getFuturesMarketWsKey(market), 'order.status', params);
+        return this.wsClient.sendWSAPIRequest(getFuturesMarketWsKey(market), 'order.status', params);
     }
     /**
      * Get current position information (V2)
      * Note: Only symbols that have positions or open orders will be returned
      */
     getFuturesPositionV2(params) {
-        return this.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'v2/account.position', params);
+        return this.wsClient.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'v2/account.position', params);
     }
     /**
      * Get current position information
@@ -462,7 +422,7 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * This endpoint is used for both USDM and COINM futures.
      */
     getFuturesPosition(market, params) {
-        return this.sendWSAPIRequest(getFuturesMarketWsKey(market), 'account.position', params);
+        return this.wsClient.sendWSAPIRequest(getFuturesMarketWsKey(market), 'account.position', params);
     }
     /*
      *
@@ -474,7 +434,7 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * Note: Returns balance information for all assets
      */
     getFuturesAccountBalanceV2(params) {
-        return this.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'v2/account.balance', params);
+        return this.wsClient.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'v2/account.balance', params);
     }
     /**
      * Get account balance information
@@ -483,14 +443,14 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * This endpoint is used for both USDM and COINM futures.
      */
     getFuturesAccountBalance(market, params) {
-        return this.sendWSAPIRequest(getFuturesMarketWsKey(market), 'account.balance', params);
+        return this.wsClient.sendWSAPIRequest(getFuturesMarketWsKey(market), 'account.balance', params);
     }
     /**
      * Get account information (V2)
      * Note: Returns detailed account information including positions and assets
      */
     getFuturesAccountStatusV2(params) {
-        return this.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'v2/account.status', params);
+        return this.wsClient.sendWSAPIRequest(websocket_util_1.WS_KEY_MAP.usdmWSAPI, 'v2/account.status', params);
     }
     /**
      * Get account information
@@ -499,38 +459,173 @@ class WebsocketAPIClient extends websocket_client_1.WebsocketClient {
      * This endpoint is used for both USDM and COINM futures.
      */
     getFuturesAccountStatus(market, params) {
-        return this.sendWSAPIRequest(getFuturesMarketWsKey(market), 'account.status', params);
+        return this.wsClient.sendWSAPIRequest(getFuturesMarketWsKey(market), 'account.status', params);
     }
     /*
      *
      * User data stream requests
      *
      */
-    startSpotUserDataStream(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'userDataStream.start', params);
+    /**
+     * Start the user data stream for an apiKey (passed as param).
+     *
+     * Note: for "Spot" markets, the listenKey workflow is deprecated, use `subscribeUserDataStream()` instead.
+     *
+     * @param params
+     * @param wsKey
+     * @returns listenKey
+     */
+    startUserDataStreamForKey(params, wsKey = websocket_util_1.WS_KEY_MAP.mainWSAPI) {
+        return this.wsClient.sendWSAPIRequest(wsKey, 'userDataStream.start', params);
     }
-    pingSpotUserDataStream(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'userDataStream.ping', params);
+    /**
+     * Attempt to "ping" a listen key.
+     *
+     * Note: for "Spot" markets, the listenKey workflow is deprecated, use `subscribeUserDataStream()` instead.
+     *
+     * @param params
+     * @param wsKey
+     * @returns
+     */
+    pingUserDataStreamForKey(params, wsKey = websocket_util_1.WS_KEY_MAP.mainWSAPI) {
+        return this.wsClient.sendWSAPIRequest(wsKey, 'userDataStream.ping', params);
     }
-    stopSpotUserDataStream(params, wsKey) {
-        return this.sendWSAPIRequest(wsKey || websocket_util_1.WS_KEY_MAP.mainWSAPI, 'userDataStream.stop', params);
+    /**
+     * Stop the user data stream listen key.
+     *
+     * @param params
+     * @param wsKey
+     * @returns
+     */
+    stopUserDataStreamForKey(params, wsKey = websocket_util_1.WS_KEY_MAP.mainWSAPI) {
+        return this.wsClient.sendWSAPIRequest(wsKey, 'userDataStream.stop', params);
     }
     /**
-     * Request user data stream subscription on the currently authenticated connection
+     * Request user data stream subscription on the currently authenticated connection.
+     *
+     * If reconnected, this will automatically resubscribe unless you unsubscribe manually.
      */
-    requestSubscribeUserDataStream(wsKey) {
+    subscribeUserDataStream(wsKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.sendWSAPIRequest(wsKey, 'userDataStream.subscribe');
-            this.subscribedUserDataStreamState[wsKey] = {
+            const resolvedWsKey = this.options.testnet ? (0, websocket_util_1.getTestnetWsKey)(wsKey) : wsKey;
+            const res = yield this.wsClient.sendWSAPIRequest(resolvedWsKey, 'userDataStream.subscribe');
+            // Used to track whether this connection had the general "userDataStream.subscribe" called.
+            // Used as part of `resubscribeUserDataStreamAfterReconnect` to know which connections to resub.
+            this.subscribedUserDataStreamState[resolvedWsKey] = {
                 subscribedAt: new Date(),
                 subscribeAttempt: 0,
             };
             return res;
         });
     }
-    requestUnsubscribeUserDataStream(wsKey) {
-        delete this.subscribedUserDataStreamState[wsKey];
-        return this.sendWSAPIRequest(wsKey, 'userDataStream.unsubscribe');
+    /**
+     * Unsubscribe from the user data stream subscription on the currently authenticated connection.
+     *
+     * If reconnected, this will also stop it from automatically resubscribing after reconnect.
+     */
+    unsubscribeUserDataStream(wsKey) {
+        const resolvedWsKey = this.options.testnet ? (0, websocket_util_1.getTestnetWsKey)(wsKey) : wsKey;
+        delete this.subscribedUserDataStreamState[resolvedWsKey];
+        return this.wsClient.sendWSAPIRequest(resolvedWsKey, 'userDataStream.unsubscribe');
+    }
+    /**
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     * Private methods for handling some of the convenience/automation provided by the WS API Client
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     */
+    setupDefaultEventListeners() {
+        if (this.options.attachEventListeners) {
+            /**
+             * General event handlers for monitoring the WebsocketClient
+             */
+            this.wsClient
+                .on('open', (data) => {
+                console.log(new Date(), 'ws connected', data.wsKey);
+            })
+                .on('reconnecting', ({ wsKey }) => {
+                console.log(new Date(), 'ws automatically reconnecting.... ', wsKey);
+            })
+                .on('reconnected', (data) => {
+                console.log(new Date(), 'ws has reconnected ', data === null || data === void 0 ? void 0 : data.wsKey);
+            })
+                .on('authenticated', (data) => {
+                console.info(new Date(), 'ws has authenticated ', data === null || data === void 0 ? void 0 : data.wsKey);
+            })
+                .on('exception', (data) => {
+                console.error(new Date(), 'ws exception: ', JSON.stringify(data));
+            });
+        }
+    }
+    tryResubscribeUserDataStream(wsKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const subscribeState = this.getSubscribedUserDataStreamState(wsKey);
+            const respawnDelayInSeconds = this.options.resubscribeUserDataStreamDelaySeconds;
+            this.logger.error('tryResubscribeUserDataStream(): resubscribing to user data stream....', Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), { wsKey }));
+            try {
+                if ((_a = this.subscribedUserDataStreamState[wsKey]) === null || _a === void 0 ? void 0 : _a.respawnTimeout) {
+                    clearTimeout(this.subscribedUserDataStreamState[wsKey].respawnTimeout);
+                    delete this.subscribedUserDataStreamState[wsKey].respawnTimeout;
+                }
+                subscribeState.subscribeAttempt++;
+                yield this.subscribeUserDataStream(wsKey);
+                this.subscribedUserDataStreamState[wsKey] = Object.assign(Object.assign({}, subscribeState), { subscribedAt: new Date(), subscribeAttempt: 0 });
+                this.logger.info('tryResubscribeUserDataStream()->ok', Object.assign(Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), subscribeState), { wsKey }));
+            }
+            catch (e) {
+                this.logger.error('tryResubscribeUserDataStream() exception - retry after timeout', Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), { wsKey, exception: e, subscribeState }));
+                subscribeState.respawnTimeout = setTimeout(() => {
+                    this.tryResubscribeUserDataStream(wsKey);
+                }, 1000 * respawnDelayInSeconds);
+                this.subscribedUserDataStreamState[wsKey] = Object.assign({}, subscribeState);
+            }
+        });
+    }
+    getSubscribedUserDataStreamState(wsKey) {
+        const subscribedState = this.subscribedUserDataStreamState[wsKey] || {
+            subscribedAt: new Date(),
+            subscribeAttempt: 0,
+        };
+        return subscribedState;
+    }
+    handleWSReconnectedEvent(params) {
+        var _a;
+        const wsKey = params.wsKey;
+        // Not a WS API connection
+        if (!(0, typeGuards_1.isWSAPIWsKey)(wsKey)) {
+            return;
+        }
+        const fnName = 'handleWSReconnectedEvent()';
+        // For the workflow without the listen key
+        if (
+        // Feature enabled
+        this.options.resubscribeUserDataStreamAfterReconnect &&
+            // Was subscribed to user data stream (without listen key)
+            this.subscribedUserDataStreamState[wsKey]) {
+            // Delay existing timer, if exists
+            if ((_a = this.subscribedUserDataStreamState[wsKey]) === null || _a === void 0 ? void 0 : _a.respawnTimeout) {
+                clearTimeout(this.subscribedUserDataStreamState[wsKey].respawnTimeout);
+                delete this.subscribedUserDataStreamState[wsKey].respawnTimeout;
+                this.logger.error(`${fnName} -> resubUserData(): Respawn timer already active while trying to queue respawn...delaying existing timer further...`, Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), { wsKey }));
+            }
+            this.logger.trace(`${fnName} -> resubUserData():: queued resubscribe for wsKey user data stream`, Object.assign(Object.assign({}, websocket_util_1.WS_LOGGER_CATEGORY), { wsKey }));
+            // Queue resubscribe workflow
+            this.subscribedUserDataStreamState[wsKey].respawnTimeout = setTimeout(() => {
+                this.tryResubscribeUserDataStream(wsKey);
+            }, 1000 * this.options.resubscribeUserDataStreamDelaySeconds);
+        }
     }
 }
 exports.WebsocketAPIClient = WebsocketAPIClient;