bybit-api 4.5.3 → 4.6.1

package/lib/util/BaseWSClient.js

@@ -33,6 +33,31 @@ const logger_1 = require("./logger");
 const webCryptoAPI_1 = require("./webCryptoAPI");
 const websockets_1 = require("./websockets");
 const WsStore_1 = require("./websockets/WsStore");
+/**
+ * Appends wsKey and isWSAPIResponse to all events.
+ * Some events are arrays, this handles that nested scenario too.
+ */
+function getFinalEmittable(emittable, wsKey, isWSAPIResponse) {
+    if (Array.isArray(emittable)) {
+        return emittable.map((subEvent) => getFinalEmittable(subEvent, wsKey, isWSAPIResponse));
+    }
+    if (Array.isArray(emittable.event)) {
+        // Some topics just emit an array.
+        // This is consistent with how it was before the WS API upgrade:
+        return emittable.event.map((subEvent) => getFinalEmittable(subEvent, wsKey, isWSAPIResponse));
+        // const { event, ...others } = emittable;
+        // return {
+        //   ...others,
+        //   event: event.map((subEvent) =>
+        //     getFinalEmittable(subEvent, wsKey, isWSAPIResponse),
+        //   ),
+        // };
+    }
+    if (emittable.event) {
+        return Object.assign(Object.assign({}, emittable.event), { wsKey: wsKey, isWSAPIResponse: !!isWSAPIResponse });
+    }
+    return Object.assign(Object.assign({}, emittable), { wsKey: wsKey, isWSAPIResponse: !!isWSAPIResponse });
+}
 /**
  * Base WebSocket abstraction layer. Handles connections, tracking each connection as a unique "WS Key"
  */
@@ -48,6 +73,9 @@ class BaseWebsocketClient extends events_1.default {
          */
         this.pendingTopicSubscriptionRequests = {};
         this.logger = logger || logger_1.DefaultLogger;
+        this.WS_LOGGER_CATEGORY = {
+            category: (options === null || options === void 0 ? void 0 : options.wsLoggerCategory) || 'WsClient',
+        };
         this.wsStore = new WsStore_1.WsStore(this.logger);
         this.options = Object.assign({ 
             // Some defaults:
@@ -57,11 +85,19 @@ class BaseWebsocketClient extends events_1.default {
             // Calls to subscribeV5() are wrapped in a promise, allowing you to await a subscription request.
             // Note: due to internal complexity, it's only recommended if you connect before subscribing.
             promiseSubscribeRequests: false, 
+            // Requires a confirmation "response" from the ws connection before assuming it is ready
+            requireConnectionReadyConfirmation: false, 
             // Automatically send an authentication op/request after a connection opens, for private connections.
             authPrivateConnectionsOnConnect: true, 
-            // Individual requests do not require a signature, so this is disabled.
-            authPrivateRequests: false }, options);
-        // Check Web Crypto API support when credentials are provided and no custom sign function is used
+            // Automatically include auth/sign/token with every WS request.
+            // Automatically handled during getWsRequestEvents.
+            authPrivateRequests: false, 
+            // Automatically re-auth WS API, if we were auth'd before and get reconnected
+            reauthWSAPIOnReconnect: true, 
+            // Whether to use native heartbeats (depends on the exchange)
+            useNativeHeartbeats: false }, options);
+        // Check Web Crypto API support
+        //  when credentials are provided and no custom sign function is used
         if (this.options.key &&
             this.options.secret &&
             !this.options.customSignMessageFn) {
@@ -179,7 +215,7 @@ class BaseWebsocketClient extends events_1.default {
                 /**
                  * Are we in the process of connection? Nothing to send yet.
                  */
-                this.logger.trace('WS not connected - requests queued for retry once connected.', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey,
+                this.logger.trace('WS not connected - requests queued for retry once connected.', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey,
                     wsTopicRequests }));
                 return isConnectionInProgress;
             }
@@ -192,6 +228,7 @@ class BaseWebsocketClient extends events_1.default {
                  *
                  * Auth should already automatically be in progress, so no action needed from here. Topics will automatically subscribe post-auth success.
                  */
+                this.logger.trace('WS connected but not authenticated yet - awaiting auth before subscribing');
                 return false;
             }
             // Finally, request subscription to topics if the connection is healthy and ready
@@ -250,7 +287,7 @@ class BaseWebsocketClient extends events_1.default {
         return this.wsStore;
     }
     close(wsKey, force) {
-        this.logger.info('Closing connection', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+        this.logger.info('Closing connection', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
         this.setWsState(wsKey, websockets_1.WsConnectionStateEnum.CLOSING);
         this.clearTimers(wsKey);
         const ws = this.getWs(wsKey);
@@ -277,11 +314,11 @@ class BaseWebsocketClient extends events_1.default {
             var _a, _b;
             try {
                 if (this.wsStore.isWsOpen(wsKey)) {
-                    this.logger.error('Refused to connect to ws with existing active connection', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
-                    return { wsKey };
+                    this.logger.error('Refused to connect to ws with existing active connection', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
+                    return { wsKey, ws: this.wsStore.getWs(wsKey) };
                 }
                 if (this.wsStore.isConnectionState(wsKey, websockets_1.WsConnectionStateEnum.CONNECTING)) {
-                    this.logger.error('Refused to connect to ws, connection attempt already active', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+                    this.logger.error('Refused to connect to ws, connection attempt already active', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
                     return (_a = this.wsStore.getConnectionInProgressPromise(wsKey)) === null || _a === void 0 ? void 0 : _a.promise;
                 }
                 if (!this.wsStore.getConnectionState(wsKey) ||
@@ -291,23 +328,34 @@ class BaseWebsocketClient extends events_1.default {
                 if (!this.wsStore.getConnectionInProgressPromise(wsKey)) {
                     this.wsStore.createConnectionInProgressPromise(wsKey, false);
                 }
-                const url = customUrl || (yield this.getWsUrl(wsKey));
-                const ws = this.connectToWsUrl(url, wsKey);
-                this.wsStore.setWs(wsKey, ws);
-                return (_b = this.wsStore.getConnectionInProgressPromise(wsKey)) === null || _b === void 0 ? void 0 : _b.promise;
+                try {
+                    const url = customUrl || (yield this.getWsUrl(wsKey));
+                    const ws = this.connectToWsUrl(url, wsKey);
+                    this.wsStore.setWs(wsKey, ws);
+                }
+                catch (e) {
+                    this.logger.error('Exception fetching WS URL', e);
+                    throw e;
+                }
             }
             catch (err) {
-                this.parseWsError('Connection failed', err, wsKey);
-                this.reconnectWithDelay(wsKey, this.options.reconnectTimeout);
+                const canRetry = this.parseWsError('Connection failed', err, wsKey);
+                if (canRetry) {
+                    this.reconnectWithDelay(wsKey, this.options.reconnectTimeout);
+                }
+                else {
+                    this.logger.info('Preventing retry due to error type to prevent deadlock');
+                }
                 if (throwOnError) {
                     throw err;
                 }
             }
+            return (_b = this.wsStore.getConnectionInProgressPromise(wsKey)) === null || _b === void 0 ? void 0 : _b.promise;
         });
     }
     connectToWsUrl(url, wsKey) {
         var _a;
-        this.logger.trace(`Opening WS connection to URL: ${url}`, Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+        this.logger.trace(`Opening WS connection to URL: ${url}`, Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
         // Support both wsOptions (new) and requestOptions (legacy, for backwards compatibility)
         const wsOptionsConfig = this.options.wsOptions || {};
         const legacyAgent = (_a = this.options.requestOptions) === null || _a === void 0 ? void 0 : _a.agent;
@@ -316,56 +364,81 @@ class BaseWebsocketClient extends events_1.default {
         const finalWsOptions = !wsOptions.agent && legacyAgent
             ? Object.assign(Object.assign({}, wsOptions), { agent: legacyAgent }) : wsOptions;
         const ws = new isomorphic_ws_1.default(url, protocols, finalWsOptions);
-        ws.onopen = (event) => this.onWsOpen(event, wsKey);
+        ws.onopen = (event) => this.onWsOpen(event, wsKey, url, ws);
         ws.onmessage = (event) => this.onWsMessage(event, wsKey, ws);
         ws.onerror = (event) => this.parseWsError('Websocket onWsError', event, wsKey);
         ws.onclose = (event) => this.onWsClose(event, wsKey);
         ws.wsKey = wsKey;
+        if (this.options.useNativeHeartbeats) {
+            if (typeof ws.on === 'function') {
+                ws.on('ping', (event) => this.onWsPing(event, wsKey, ws, 'frame'));
+                ws.on('pong', (event) => this.onWsPong(event, wsKey, 'frame'));
+            }
+        }
         return ws;
     }
     parseWsError(context, error, wsKey) {
+        if (this.wsStore.isConnectionAttemptInProgress(wsKey)) {
+            this.setWsState(wsKey, websockets_1.WsConnectionStateEnum.ERROR);
+        }
+        // Allow retry by default (in some places that call this). Prevent deadloop in hard failure (401)
+        let canRetry = true;
         if (!error.message) {
             this.logger.error(`${context} due to unexpected error: `, error);
             this.emit('response', Object.assign(Object.assign({}, error), { wsKey }));
             this.emit('exception', Object.assign(Object.assign({}, error), { wsKey }));
-            return;
+            return canRetry;
         }
         switch (error.message) {
             case 'Unexpected server response: 401':
-                this.logger.error(`${context} due to 401 authorization failure.`, Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+                this.logger.error(`${context} due to 401 authorization failure.`, Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
+                canRetry = false;
                 break;
             default:
                 if (this.wsStore.getConnectionState(wsKey) !==
                     websockets_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({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey, error }));
+                    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({}, this.WS_LOGGER_CATEGORY), { wsKey, error }));
                     this.executeReconnectableClose(wsKey, 'unhandled onWsError');
                 }
                 else {
                     this.logger.info(`${wsKey} socket forcefully closed. Will not reconnect.`);
                 }
+                canRetry = true;
                 break;
         }
         this.logger.error(`parseWsError(${context}, ${error}, ${wsKey}) `, error);
         this.emit('response', Object.assign(Object.assign({}, error), { wsKey }));
         this.emit('exception', Object.assign(Object.assign({}, error), { wsKey }));
+        return canRetry;
     }
     /** Get a signature, build the auth request and send it */
-    sendAuthRequest(wsKey) {
+    sendAuthRequest(wsKey, eventToAuth) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             try {
-                this.logger.trace('Sending auth request...', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+                this.logger.trace('Sending auth request...', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey,
+                    eventToAuth }));
                 yield this.assertIsConnected(wsKey);
+                // If not required, this won't return anything
+                const request = yield this.getWsAuthRequestEvent(wsKey, eventToAuth);
+                if (!request) {
+                    // Short-circuit this for the next time it's called
+                    const wsState = this.wsStore.get(wsKey, true);
+                    wsState.isAuthenticated = true;
+                    return;
+                }
                 if (!this.wsStore.getAuthenticationInProgressPromise(wsKey)) {
                     this.wsStore.createAuthenticationInProgressPromise(wsKey, false);
                 }
-                const request = yield this.getWsAuthRequestEvent(wsKey);
+                if (request === 'waitForEvent') {
+                    return (_a = this.wsStore.getAuthenticationInProgressPromise(wsKey)) === null || _a === void 0 ? void 0 : _a.promise;
+                }
                 // console.log('ws auth req', request);
-                this.tryWsSend(wsKey, JSON.stringify(request));
-                return (_a = this.wsStore.getAuthenticationInProgressPromise(wsKey)) === null || _a === void 0 ? void 0 : _a.promise;
+                this.tryWsSend(wsKey, typeof request === 'string' ? request : JSON.stringify(request));
+                return (_b = this.wsStore.getAuthenticationInProgressPromise(wsKey)) === null || _b === void 0 ? void 0 : _b.promise;
             }
             catch (e) {
-                this.logger.trace(e, Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+                this.logger.trace(e, Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
             }
         });
     }
@@ -375,14 +448,20 @@ class BaseWebsocketClient extends events_1.default {
         if (!this.wsStore.isConnectionAttemptInProgress(wsKey)) {
             this.setWsState(wsKey, websockets_1.WsConnectionStateEnum.RECONNECTING);
         }
-        this.logger.info('Reconnecting to websocket with delay...', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey,
+        this.logger.info('Reconnecting to websocket with delay...', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { 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.logger.info('Reconnecting to websocket now', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
             this.clearReconnectTimer(wsKey);
+            // Some streams need a specialist reconnection workflow.
+            // E.g. the user data stream can't just be reconnected as is.
+            if (this.isCustomReconnectionNeeded(wsKey)) {
+                this.wsStore.delete(wsKey);
+                return this.triggerCustomReconnectionWorkflow(wsKey);
+            }
+            this.logger.info('Reconnecting to websocket now', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
             this.connect(wsKey);
         }, connectionDelayMs);
     }
@@ -391,7 +470,7 @@ class BaseWebsocketClient extends events_1.default {
             return;
         }
         this.clearPongTimer(wsKey);
-        this.logger.trace('Sending ping', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+        this.logger.trace('Sending ping', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
         const ws = this.wsStore.get(wsKey, true).ws;
         if (!ws) {
             this.logger.error(`Unable to send ping for wsKey "${wsKey}" - no connection found`);
@@ -405,7 +484,7 @@ class BaseWebsocketClient extends events_1.default {
      * If closed, trigger a reconnect immediately
      */
     executeReconnectableClose(wsKey, reason) {
-        this.logger.info(`${reason} - closing socket to reconnect`, Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey,
+        this.logger.info(`${reason} - closing socket to reconnect`, Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey,
             reason }));
         const wasOpen = this.wsStore.isWsOpen(wsKey);
         this.clearPingTimer(wsKey);
@@ -416,7 +495,7 @@ class BaseWebsocketClient extends events_1.default {
             (0, websockets_1.safeTerminateWs)(ws, false);
         }
         if (!wasOpen) {
-            this.logger.info(`${reason} - socket already closed - trigger immediate reconnect`, Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey,
+            this.logger.info(`${reason} - socket already closed - trigger immediate reconnect`, Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey,
                 reason }));
             this.reconnectWithDelay(wsKey, this.options.reconnectTimeout);
         }
@@ -468,6 +547,7 @@ class BaseWebsocketClient extends events_1.default {
             }
             // Events that are ready to send (usually stringified JSON)
             const requestEvents = [];
+            // Can be dynamic via this.getWsMarketForWsKey(wsKey) in other SDKs
             const market = 'all';
             const maxTopicsPerEvent = this.getMaxTopicsPerSubscribeEvent(wsKey);
             if (maxTopicsPerEvent &&
@@ -541,7 +621,7 @@ class BaseWebsocketClient extends events_1.default {
      */
     tryWsSend(wsKey, wsMessage, throwExceptions) {
         try {
-            this.logger.trace('Sending upstream ws message: ', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsMessage,
+            this.logger.trace('Sending upstream ws message: ', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsMessage,
                 wsKey }));
             if (!wsKey) {
                 throw new Error('Cannot send message due to no known websocket for this wsKey');
@@ -553,42 +633,69 @@ class BaseWebsocketClient extends events_1.default {
             ws.send(wsMessage);
         }
         catch (e) {
-            this.logger.error('Failed to send WS message', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsMessage,
+            this.logger.error('Failed to send WS message', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsMessage,
                 wsKey, exception: e }));
             if (throwExceptions) {
                 throw e;
             }
         }
     }
-    onWsOpen(event, wsKey) {
+    onWsOpen(event, wsKey, url, ws) {
         return __awaiter(this, void 0, void 0, function* () {
+            const isReconnectionAttempt = this.wsStore.isConnectionState(wsKey, websockets_1.WsConnectionStateEnum.RECONNECTING) || this.wsStore.isConnectionState(wsKey, websockets_1.WsConnectionStateEnum.ERROR);
             const isFreshConnectionAttempt = this.wsStore.isConnectionState(wsKey, websockets_1.WsConnectionStateEnum.CONNECTING);
-            const isReconnectionAttempt = this.wsStore.isConnectionState(wsKey, websockets_1.WsConnectionStateEnum.RECONNECTING);
             if (isFreshConnectionAttempt) {
-                this.logger.info('Websocket connected', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey, testnet: this.options.testnet === true, market: this.options.market }));
-                this.emit('open', { wsKey, event });
+                this.logger.info('Websocket connected', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey, testnet: this.options.testnet === true, market: this.options.market }));
+                this.emit('open', { wsKey, event, wsUrl: url, ws });
             }
             else if (isReconnectionAttempt) {
-                this.logger.info('Websocket reconnected', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey, testnet: this.options.testnet === true, market: this.options.market }));
-                this.emit('reconnected', { wsKey, event });
+                this.logger.info('Websocket reconnected', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey, testnet: this.options.testnet === true, market: this.options.market }));
+                this.emit('reconnected', { wsKey, event, wsUrl: url, ws });
             }
             this.setWsState(wsKey, websockets_1.WsConnectionStateEnum.CONNECTED);
-            this.logger.trace('Enabled ping timer', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+            this.logger.trace('Enabled ping timer', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
             this.wsStore.get(wsKey, true).activePingTimer = setInterval(() => this.ping(wsKey), this.options.pingInterval);
-            // Resolve & cleanup deferred "connection attempt in progress" promise
-            try {
-                const connectionInProgressPromise = this.wsStore.getConnectionInProgressPromise(wsKey);
-                if (connectionInProgressPromise === null || connectionInProgressPromise === void 0 ? void 0 : connectionInProgressPromise.resolve) {
-                    connectionInProgressPromise.resolve({
-                        wsKey,
-                    });
-                }
+            if (!this.options.requireConnectionReadyConfirmation) {
+                return yield this.onWsReadyForEvents(wsKey);
             }
-            catch (e) {
-                this.logger.error('Exception trying to resolve "connectionInProgress" promise', e);
+            else {
+                this.resolveConnectionInProgressPromise(wsKey);
             }
             // Remove before continuing, in case there's more requests queued
             this.wsStore.removeConnectingInProgressPromise(wsKey);
+        });
+    }
+    resolveConnectionInProgressPromise(wsKey) {
+        try {
+            // Resolve & cleanup deferred "connection attempt in progress" promise
+            const connectionInProgressPromise = this.wsStore.getConnectionInProgressPromise(wsKey);
+            if (connectionInProgressPromise === null || connectionInProgressPromise === void 0 ? void 0 : connectionInProgressPromise.resolve) {
+                connectionInProgressPromise.resolve({
+                    wsKey,
+                    ws: this.wsStore.getWs(wsKey),
+                });
+            }
+        }
+        catch (e) {
+            this.logger.error('Exception trying to resolve "connectionInProgress" promise', e);
+        }
+    }
+    /**
+     * Called automatically once a connection is ready.
+     * - Some exchanges are ready immediately after the connections open.
+     * - Some exchanges send an event to confirm the connection is ready for us.
+     *
+     * This method is called to act when the connection is ready. Use `requireConnectionReadyConfirmation` to control how this is called.
+     */
+    onWsReadyForEvents(wsKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.resolveConnectionInProgressPromise(wsKey);
+            this.wsStore.removeConnectingInProgressPromise(wsKey);
+            // Some websockets require an auth packet to be sent after opening the connection
+            if (this.isAuthOnConnectWsKey(wsKey) &&
+                this.authPrivateConnectionsOnConnect(wsKey)) {
+                yield this.assertIsAuthenticated(wsKey);
+            }
             // Reconnect to topics known before it connected
             const { privateReqs, publicReqs } = this.sortTopicRequestsIntoPublicPrivate([...this.wsStore.getTopics(wsKey)], wsKey);
             // Request sub to public topics, if any
@@ -599,8 +706,8 @@ class BaseWebsocketClient extends events_1.default {
                 this.logger.error(`onWsOpen(): exception in public requestSubscribeTopics(${wsKey}): `, publicReqs, e);
             }
             // Request sub to private topics, if auth on connect isn't needed
-            // Else, this is automatic after authentication is successfully confirmed
-            if (!this.options.authPrivateConnectionsOnConnect) {
+            if (!this.authPrivateConnectionsOnConnect(wsKey) ||
+                !this.isAuthOnConnectWsKey(wsKey)) {
                 try {
                     this.requestSubscribeTopics(wsKey, privateReqs);
                 }
@@ -608,11 +715,6 @@ class BaseWebsocketClient extends events_1.default {
                     this.logger.error(`onWsOpen(): exception in private requestSubscribeTopics(${wsKey}: `, privateReqs, e);
                 }
             }
-            // Some websockets require an auth packet to be sent after opening the connection
-            if (this.isAuthOnConnectWsKey(wsKey) &&
-                this.options.authPrivateConnectionsOnConnect) {
-                yield this.sendAuthRequest(wsKey);
-            }
         });
     }
     /**
@@ -630,6 +732,7 @@ class BaseWebsocketClient extends events_1.default {
                 inProgressPromise.resolve({
                     wsKey,
                     event,
+                    ws: wsState.ws,
                 });
             }
         }
@@ -638,13 +741,32 @@ class BaseWebsocketClient extends events_1.default {
         }
         // Remove before continuing, in case there's more requests queued
         this.wsStore.removeAuthenticationInProgressPromise(wsKey);
-        if (this.options.authPrivateConnectionsOnConnect) {
+        if (this.authPrivateConnectionsOnConnect(wsKey)) {
             const topics = [...this.wsStore.getTopics(wsKey)];
             const privateTopics = topics.filter((topic) => this.isPrivateTopicRequest(topic, wsKey));
             if (privateTopics.length) {
                 this.subscribeTopicsForWsKey(privateTopics, wsKey);
             }
         }
+        // Can be passed by the WebsocketClient's integration layer, if necessary, to dynamically track the auth channel
+        if (event === null || event === void 0 ? void 0 : event.isWSAPI) {
+            wsState.didAuthWSAPI = true;
+            if (event === null || event === void 0 ? void 0 : event.WSAPIAuthChannel) {
+                wsState.WSAPIAuthChannel = event.WSAPIAuthChannel;
+            }
+        }
+    }
+    onWsPing(event, wsKey, ws, source) {
+        this.logger.trace(`Received PING ${source}`, Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey,
+            event,
+            source }));
+        this.sendPongEvent(wsKey, ws);
+    }
+    onWsPong(event, wsKey, source) {
+        this.logger.trace(`Received PONG ${source}`, Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey, event: event === null || event === void 0 ? void 0 : event.data, source }));
+        // Necessary when native heartbeats are used
+        this.clearPongTimer(wsKey);
+        return;
     }
     onWsMessage(event, wsKey, ws) {
         try {
@@ -652,14 +774,10 @@ class BaseWebsocketClient extends events_1.default {
             // any message can clear the pong timer - wouldn't get a message if the ws wasn't working
             this.clearPongTimer(wsKey);
             if (this.isWsPong(event)) {
-                this.logger.trace('Received pong', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey, event: event === null || event === void 0 ? void 0 : event.data }));
-                return;
+                return this.onWsPong(event, wsKey, 'event');
             }
             if (this.isWsPing(event)) {
-                this.logger.trace('Received ping', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey,
-                    event }));
-                this.sendPongEvent(wsKey, ws);
-                return;
+                return this.onWsPing(event, wsKey, ws, 'event');
             }
             if ((0, types_1.isMessageEvent)(event)) {
                 const data = event.data;
@@ -667,20 +785,37 @@ class BaseWebsocketClient extends events_1.default {
                 const emittableEvents = this.resolveEmittableEvents(wsKey, event);
                 if (!emittableEvents.length) {
                     // console.log(`raw event: `, { data, dataType, emittableEvents });
-                    this.logger.error('Unhandled/unrecognised ws event message - returned no emittable data', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { message: data || 'no message', dataType,
+                    this.logger.error('Unhandled/unrecognised ws event message - returned no emittable data', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { message: data || 'no message', dataType,
                         event,
                         wsKey }));
                     return this.emit('update', Object.assign(Object.assign({}, event), { wsKey }));
                 }
                 for (const emittable of emittableEvents) {
-                    if (this.isWsPong(emittable)) {
-                        this.logger.trace('Received pong2', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey,
+                    if (this.isWsPong(emittable) || emittable.eventType === 'pong') {
+                        this.logger.trace('Received pong2', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey,
                             data }));
                         continue;
                     }
-                    const emittableFinalEvent = Object.assign(Object.assign({}, emittable.event), { wsKey, isWSAPIResponse: emittable.isWSAPIResponse });
+                    const emittableFinalEvent = getFinalEmittable(emittable, wsKey, emittable.isWSAPIResponse);
+                    if (emittable.eventType === 'connectionReady') {
+                        this.logger.trace('Successfully connected - connection ready for events', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey,
+                            emittable }));
+                        const wsState = this.wsStore.get(wsKey);
+                        if (wsState && !this.authPrivateConnectionsOnConnect(wsKey)) {
+                            wsState.isAuthenticated = true;
+                        }
+                        this.emit('response', emittableFinalEvent);
+                        this.onWsReadyForEvents(wsKey);
+                        continue;
+                    }
+                    // Not used for bybit
+                    if (emittable.eventType === 'connectionReadyForAuth') {
+                        this.logger.trace('Ready for auth - requesting auth submission...', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
+                        this.sendAuthRequest(wsKey, emittable.event);
+                        continue;
+                    }
                     if (emittable.eventType === 'authenticated') {
-                        this.logger.trace('Successfully authenticated', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey,
+                        this.logger.trace('Successfully authenticated', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey,
                             emittable }));
                         this.emit(emittable.eventType, emittableFinalEvent);
                         this.onWsAuthenticated(wsKey, emittable.event);
@@ -703,19 +838,21 @@ class BaseWebsocketClient extends events_1.default {
                 }
                 return;
             }
-            this.logger.error('Unhandled/unrecognised ws event message - unexpected message format', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { message: event || 'no message', event,
+            this.logger.error('Unhandled/unrecognised ws event message - unexpected message format', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { message: event || 'no message', event,
                 wsKey }));
         }
         catch (e) {
-            this.logger.error('Failed to parse ws event message', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { error: e, event,
+            this.logger.error('Failed to parse ws event message', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { error: e, event,
                 wsKey }));
         }
     }
     onWsClose(event, wsKey) {
-        this.logger.info('Websocket connection closed', Object.assign(Object.assign({}, websockets_1.WS_LOGGER_CATEGORY), { wsKey }));
+        this.logger.info('Websocket connection closed', Object.assign(Object.assign({}, this.WS_LOGGER_CATEGORY), { wsKey }));
         const wsState = this.wsStore.get(wsKey, true);
         wsState.isAuthenticated = false;
-        if (this.wsStore.getConnectionState(wsKey) !== websockets_1.WsConnectionStateEnum.CLOSING) {
+        const wsConnectionState = this.wsStore.getConnectionState(wsKey);
+        if (wsConnectionState !== websockets_1.WsConnectionStateEnum.CLOSING) {
+            // unintentional close, attempt recovery
             this.logger.trace(`onWsClose(${wsKey}): rejecting all deferred promises...`);
             // clean up any pending promises for this connection
             this.getWsStore().rejectAllDeferredPromises(wsKey, 'connection lost, reconnecting');
@@ -725,6 +862,7 @@ class BaseWebsocketClient extends events_1.default {
             this.emit('reconnect', { wsKey, event });
         }
         else {
+            // intentional close - clean up
             // clean up any pending promises for this connection
             this.logger.trace(`onWsClose(${wsKey}): rejecting all deferred promises...`);
             this.getWsStore().rejectAllDeferredPromises(wsKey, 'disconnected');
@@ -746,20 +884,21 @@ class BaseWebsocketClient extends events_1.default {
     assertIsConnected(wsKey) {
         return __awaiter(this, void 0, void 0, function* () {
             const isConnected = this.getWsStore().isConnectionState(wsKey, websockets_1.WsConnectionStateEnum.CONNECTED);
-            if (!isConnected) {
-                const inProgressPromise = this.getWsStore().getConnectionInProgressPromise(wsKey);
-                // Already in progress? Await shared promise and retry
-                if (inProgressPromise) {
-                    this.logger.trace('assertIsConnected(): awaiting...');
-                    yield inProgressPromise.promise;
-                    this.logger.trace('assertIsConnected(): connected!');
-                    return inProgressPromise.promise;
-                }
-                // Start connection, it should automatically store/return a promise.
-                this.logger.trace('assertIsConnected(): connecting...');
-                yield this.connect(wsKey);
-                this.logger.trace('assertIsConnected(): newly connected!');
+            if (isConnected) {
+                return true;
+            }
+            const inProgressPromise = this.getWsStore().getConnectionInProgressPromise(wsKey);
+            // Already in progress? Await shared promise and retry
+            if (inProgressPromise) {
+                this.logger.trace('assertIsConnected(): awaiting...');
+                yield inProgressPromise.promise;
+                this.logger.trace('assertIsConnected(): awaiting...connected!');
+                return inProgressPromise.promise;
             }
+            // Start connection, it should automatically store/return a promise.
+            this.logger.trace('assertIsConnected(): connecting...');
+            yield this.connect(wsKey);
+            this.logger.trace('assertIsConnected(): connecting...newly connected!');
         });
     }
     /**