@siebly/kraken-api 0.0.9

package/dist/mjs/lib/BaseWSClient.js

@@ -0,0 +1,928 @@
+import { EventEmitter } from 'events';
+import WebSocket from 'isomorphic-ws';
+import { isMessageEvent, } from '../types/websockets/ws-events.js';
+import { checkWebCryptoAPISupported } from './webCryptoAPI.js';
+import { DefaultLogger } from './websocket/logger.js';
+import { safeTerminateWs, } from './websocket/websocket-util.js';
+import { WsStore } from './websocket/WsStore.js';
+import { WsConnectionStateEnum, } from './websocket/WsStore.types.js';
+/**
+ * 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 {
+            ...emittable.event,
+            wsKey: wsKey,
+            isWSAPIResponse: !!isWSAPIResponse,
+        };
+    }
+    return {
+        ...emittable,
+        wsKey: wsKey,
+        isWSAPIResponse: !!isWSAPIResponse,
+    };
+}
+/**
+ * Users can conveniently pass topics as strings or objects (object has topic name + optional params).
+ *
+ * This method normalises topics into objects (object has topic name + optional params).
+ */
+function getNormalisedTopicRequests(wsTopicRequests) {
+    const normalisedTopicRequests = [];
+    for (const wsTopicRequest of wsTopicRequests) {
+        // passed as string, convert to object
+        if (typeof wsTopicRequest === 'string') {
+            const topicRequest = {
+                topic: wsTopicRequest,
+                payload: undefined,
+            };
+            normalisedTopicRequests.push(topicRequest);
+            continue;
+        }
+        // already a normalised object, thanks to user
+        normalisedTopicRequests.push(wsTopicRequest);
+    }
+    return normalisedTopicRequests;
+}
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+export class BaseWebsocketClient extends EventEmitter {
+    wsStore;
+    logger;
+    options;
+    wsApiRequestId = 0;
+    timeOffsetMs = 0;
+    WS_LOGGER_CATEGORY;
+    constructor(options, logger) {
+        super();
+        this.logger = logger || DefaultLogger;
+        this.WS_LOGGER_CATEGORY = {
+            category: options?.wsLoggerCategory || 'WsClient',
+        };
+        this.wsStore = new WsStore(this.logger);
+        this.options = {
+            pongTimeout: 5000,
+            pingInterval: 10000,
+            reconnectTimeout: 500,
+            recvWindow: 5000,
+            // Requires a confirmation "response" from the ws connection before assuming it is ready
+            requireConnectionReadyConfirmation: false,
+            // Automatically auth after opening a connection?
+            authPrivateConnectionsOnConnect: false,
+            // Automatically include auth/sign/token with every WS request.
+            // Automatically handled during getWsRequestEvents.
+            authPrivateRequests: true,
+            // 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: true,
+            ...options,
+        };
+        // Check Web Crypto API support when credentials are provided and no custom sign function is used
+        if (this.options.apiKey &&
+            this.options.apiSecret &&
+            !this.options.customSignMessageFn) {
+            checkWebCryptoAPISupported();
+        }
+    }
+    isPrivateWsKey(wsKey) {
+        return this.getPrivateWSKeys().includes(wsKey);
+    }
+    /** Returns auto-incrementing request ID, used to track promise references for async requests */
+    getNewRequestId() {
+        return ++this.wsApiRequestId;
+    }
+    getTimeOffsetMs() {
+        return this.timeOffsetMs;
+    }
+    setTimeOffsetMs(newOffset) {
+        this.timeOffsetMs = newOffset;
+    }
+    /**
+     * Don't call directly! Use subscribe() instead!
+     *
+     * Subscribe to one or more topics on a WS connection (identified by WS Key).
+     *
+     * - Topics are automatically cached
+     * - Connections are automatically opened, if not yet connected
+     * - Authentication is automatically handled
+     * - Topics are automatically resubscribed to, if something happens to the connection, unless you call unsubsribeTopicsForWsKey(topics, key).
+     *
+     * @param wsTopicRequests array of topics to subscribe to
+     * @param wsKey ws key referring to the ws connection these topics should be subscribed on
+     */
+    async subscribeTopicsForWsKey(wsTopicRequests, wsKey) {
+        const normalisedTopicRequests = getNormalisedTopicRequests(wsTopicRequests);
+        // Store topics, so future automation (post-auth, post-reconnect) has everything needed to resubscribe automatically
+        for (const topic of normalisedTopicRequests) {
+            this.wsStore.addTopic(wsKey, topic);
+        }
+        const isConnected = this.wsStore.isConnectionState(wsKey, WsConnectionStateEnum.CONNECTED);
+        const isConnectionInProgress = this.wsStore.isConnectionAttemptInProgress(wsKey);
+        // start connection process if it hasn't yet begun. Topics are automatically subscribed to on-connect
+        if (!isConnected && !isConnectionInProgress) {
+            return this.connect(wsKey);
+        }
+        // Subscribe should happen automatically once connected, nothing to do here after topics are added to wsStore.
+        if (!isConnected) {
+            /**
+             * Are we in the process of connection? Nothing to send yet.
+             */
+            this.logger.trace('WS not connected - requests queued for retry once connected.', {
+                ...this.WS_LOGGER_CATEGORY,
+                wsKey,
+                wsTopicRequests,
+            });
+            return isConnectionInProgress;
+        }
+        // We're connected. Check if auth is needed and if already authenticated
+        const isPrivateConnection = this.isPrivateWsKey(wsKey);
+        const isAuthenticated = this.wsStore.get(wsKey)?.isAuthenticated;
+        if (isPrivateConnection && !isAuthenticated) {
+            /**
+             * If not authenticated yet and auth is required, don't request topics yet.
+             *
+             * 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
+        return this.requestSubscribeTopics(wsKey, normalisedTopicRequests);
+    }
+    async unsubscribeTopicsForWsKey(wsTopicRequests, wsKey) {
+        const normalisedTopicRequests = getNormalisedTopicRequests(wsTopicRequests);
+        // Store topics, so future automation (post-auth, post-reconnect) has everything needed to resubscribe automatically
+        for (const topic of normalisedTopicRequests) {
+            this.wsStore.deleteTopic(wsKey, topic);
+        }
+        const isConnected = this.wsStore.isConnectionState(wsKey, WsConnectionStateEnum.CONNECTED);
+        // If not connected, don't need to do anything.
+        // Removing the topic from the store is enough to stop it from being resubscribed to on reconnect.
+        if (!isConnected) {
+            return;
+        }
+        // We're connected. Check if auth is needed and if already authenticated
+        const isPrivateConnection = this.isPrivateWsKey(wsKey);
+        const isAuthenticated = this.wsStore.get(wsKey)?.isAuthenticated;
+        if (isPrivateConnection && !isAuthenticated) {
+            /**
+             * If not authenticated yet and auth is required, don't need to do anything.
+             * We don't subscribe to topics until auth is complete anyway.
+             */
+            return;
+        }
+        // Finally, request subscription to topics if the connection is healthy and ready
+        return this.requestUnsubscribeTopics(wsKey, normalisedTopicRequests);
+    }
+    /**
+     * Splits topic requests into two groups, public & private topic requests
+     */
+    sortTopicRequestsIntoPublicPrivate(wsTopicRequests, wsKey) {
+        const publicTopicRequests = [];
+        const privateTopicRequests = [];
+        for (const topic of wsTopicRequests) {
+            if (this.isPrivateTopicRequest(topic, wsKey)) {
+                privateTopicRequests.push(topic);
+            }
+            else {
+                publicTopicRequests.push(topic);
+            }
+        }
+        return {
+            publicReqs: publicTopicRequests,
+            privateReqs: privateTopicRequests,
+        };
+    }
+    /** Get the WsStore that tracks websockets & topics */
+    getWsStore() {
+        return this.wsStore;
+    }
+    close(wsKey, force) {
+        this.logger.info('Closing connection', {
+            ...this.WS_LOGGER_CATEGORY,
+            wsKey,
+        });
+        this.setWsState(wsKey, WsConnectionStateEnum.CLOSING);
+        this.clearTimers(wsKey);
+        const ws = this.getWs(wsKey);
+        ws?.close();
+        if (force) {
+            safeTerminateWs(ws, false);
+        }
+    }
+    closeAll(force) {
+        const keys = this.wsStore.getKeys();
+        this.logger.info(`Closing all ws connections: ${keys}`);
+        keys.forEach((key) => {
+            this.close(key, force);
+        });
+    }
+    isConnected(wsKey) {
+        return this.wsStore.isConnectionState(wsKey, WsConnectionStateEnum.CONNECTED);
+    }
+    /**
+     * Request connection to a specific websocket, instead of waiting for automatic connection.
+     */
+    async connect(wsKey, customUrl, throwOnError) {
+        try {
+            if (this.wsStore.isWsOpen(wsKey)) {
+                this.logger.error('Refused to connect to ws with existing active connection', { ...this.WS_LOGGER_CATEGORY, wsKey });
+                return { wsKey, ws: this.wsStore.getWs(wsKey) };
+            }
+            if (
+            // Important: don't check for RECONNECTING here, or this clashes with reconnectWithDelay()!
+            this.wsStore.isConnectionState(wsKey, WsConnectionStateEnum.CONNECTING)) {
+                this.logger.error('Refused to connect to ws, connection attempt already active', { ...this.WS_LOGGER_CATEGORY, wsKey });
+                return this.wsStore.getConnectionInProgressPromise(wsKey)?.promise;
+            }
+            if (!this.wsStore.getConnectionState(wsKey) ||
+                this.wsStore.isConnectionState(wsKey, WsConnectionStateEnum.INITIAL)) {
+                this.setWsState(wsKey, WsConnectionStateEnum.CONNECTING);
+            }
+            if (!this.wsStore.getConnectionInProgressPromise(wsKey)) {
+                this.wsStore.createConnectionInProgressPromise(wsKey, false);
+            }
+            try {
+                const url = customUrl || (await 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) {
+            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 this.wsStore.getConnectionInProgressPromise(wsKey)?.promise;
+    }
+    connectToWsUrl(url, wsKey) {
+        this.logger.trace(`Opening WS connection to URL: ${url}`, {
+            ...this.WS_LOGGER_CATEGORY,
+            wsKey,
+        });
+        const { protocols = [], ...wsOptions } = this.options.wsOptions || {};
+        const ws = new WebSocket(url, protocols, wsOptions);
+        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);
+        //
+        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'));
+            }
+        }
+        ws.wsKey = wsKey;
+        return ws;
+    }
+    parseWsError(context, error, wsKey) {
+        if (this.wsStore.isConnectionAttemptInProgress(wsKey)) {
+            this.setWsState(wsKey, 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', { ...error, wsKey });
+            this.emit('exception', { ...error, wsKey });
+            return canRetry;
+        }
+        switch (error.message) {
+            case 'Unexpected server response: 401':
+                this.logger.error(`${context} due to 401 authorization failure.`, {
+                    ...this.WS_LOGGER_CATEGORY,
+                    wsKey,
+                });
+                canRetry = false;
+                break;
+            default:
+                if (error?.code === 'ENOTFOUND') {
+                    this.logger.error(`${context} due to lookup exception: "${error?.msg || error?.message || error}"`, {
+                        ...this.WS_LOGGER_CATEGORY,
+                        wsKey,
+                        error,
+                        connectionState: this.wsStore.getConnectionState(wsKey),
+                    });
+                    canRetry = true;
+                    break;
+                }
+                if (error?.code === 401) {
+                    this.logger.error(`${context} due to 401 authorization failure.`, {
+                        ...this.WS_LOGGER_CATEGORY,
+                        wsKey,
+                    });
+                    canRetry = false;
+                    break;
+                }
+                if (this.wsStore.getConnectionState(wsKey) !==
+                    WsConnectionStateEnum.CLOSING) {
+                    this.logger.error(`${context} due to unexpected response error: "${error?.msg || error?.message || error}"`, { ...this.WS_LOGGER_CATEGORY, wsKey, error });
+                    canRetry = true;
+                }
+                else {
+                    this.logger.info(`${wsKey} socket forcefully closed. Will not reconnect.`);
+                }
+                break;
+        }
+        this.emit('response', { ...error, wsKey });
+        this.emit('exception', { ...error, wsKey });
+        return canRetry;
+    }
+    /** Get a signature, build the auth request and send it */
+    async sendAuthRequest(wsKey, eventToAuth) {
+        try {
+            this.logger.trace('Sending auth request...', {
+                ...this.WS_LOGGER_CATEGORY,
+                wsKey,
+                eventToAuth,
+            });
+            await this.assertIsConnected(wsKey);
+            // If not required, this won't return anything
+            const request = await 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);
+            }
+            if (request === 'waitForEvent') {
+                return this.wsStore.getAuthenticationInProgressPromise(wsKey)?.promise;
+            }
+            this.tryWsSend(wsKey, typeof request === 'string' ? request : JSON.stringify(request));
+            return this.wsStore.getAuthenticationInProgressPromise(wsKey)?.promise;
+        }
+        catch (e) {
+            this.logger.trace(e, { ...this.WS_LOGGER_CATEGORY, wsKey });
+        }
+    }
+    reconnectWithDelay(wsKey, connectionDelayMs) {
+        this.clearTimers(wsKey);
+        if (!this.wsStore.isConnectionAttemptInProgress(wsKey)) {
+            this.setWsState(wsKey, WsConnectionStateEnum.RECONNECTING);
+        }
+        this.logger.info('Reconnecting to websocket with delay...', {
+            ...this.WS_LOGGER_CATEGORY,
+            wsKey,
+            connectionDelayMs,
+        });
+        if (this.wsStore.get(wsKey)?.activeReconnectTimer) {
+            this.clearReconnectTimer(wsKey);
+        }
+        this.wsStore.get(wsKey, true).activeReconnectTimer = setTimeout(() => {
+            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', {
+                ...this.WS_LOGGER_CATEGORY,
+                wsKey,
+            });
+            this.connect(wsKey);
+        }, connectionDelayMs);
+    }
+    ping(wsKey) {
+        if (this.wsStore.get(wsKey, true).activePongTimer) {
+            return;
+        }
+        this.clearPongTimer(wsKey);
+        this.logger.trace('Sending ping', { ...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`);
+            return;
+        }
+        this.sendPingEvent(wsKey, ws);
+        this.wsStore.get(wsKey, true).activePongTimer = setTimeout(() => this.executeReconnectableClose(wsKey, 'Pong timeout'), this.options.pongTimeout);
+    }
+    /**
+     * Closes a connection, if it's even open. If open, this will trigger a reconnect asynchronously.
+     * If closed, trigger a reconnect immediately
+     */
+    executeReconnectableClose(wsKey, reason) {
+        this.logger.info(`${reason} - closing socket to reconnect`, {
+            ...this.WS_LOGGER_CATEGORY,
+            wsKey,
+            reason,
+        });
+        const wasOpen = this.wsStore.isWsOpen(wsKey);
+        this.clearPingTimer(wsKey);
+        this.clearPongTimer(wsKey);
+        const ws = this.getWs(wsKey);
+        if (ws) {
+            ws.close();
+            safeTerminateWs(ws, false);
+        }
+        if (!wasOpen) {
+            this.logger.info(`${reason} - socket already closed - trigger immediate reconnect`, {
+                ...this.WS_LOGGER_CATEGORY,
+                wsKey,
+                reason,
+            });
+            this.reconnectWithDelay(wsKey, this.options.reconnectTimeout);
+        }
+    }
+    clearTimers(wsKey) {
+        this.clearPingTimer(wsKey);
+        this.clearPongTimer(wsKey);
+        this.clearReconnectTimer(wsKey);
+    }
+    // Send a ping at intervals
+    clearPingTimer(wsKey) {
+        const wsState = this.wsStore.get(wsKey);
+        if (wsState?.activePingTimer) {
+            clearInterval(wsState.activePingTimer);
+            wsState.activePingTimer = undefined;
+        }
+    }
+    // Expect a pong within a time limit
+    clearPongTimer(wsKey) {
+        const wsState = this.wsStore.get(wsKey);
+        if (wsState?.activePongTimer) {
+            clearTimeout(wsState.activePongTimer);
+            wsState.activePongTimer = undefined;
+            // this.logger.trace(`Cleared pong timeout for "${wsKey}"`);
+        }
+        else {
+            // this.logger.trace(`No active pong timer for "${wsKey}"`);
+        }
+    }
+    clearReconnectTimer(wsKey) {
+        const wsState = this.wsStore.get(wsKey);
+        if (wsState?.activeReconnectTimer) {
+            clearTimeout(wsState.activeReconnectTimer);
+            wsState.activeReconnectTimer = undefined;
+        }
+    }
+    /**
+     * Returns a list of string events that can be individually sent upstream to complete subscribing/unsubscribing/etc to these topics
+     *
+     * If events are an object, these should be stringified (`return JSON.stringify(event);`)
+     * Each event returned by this will be sent one at a time
+     *
+     * Events are automatically split into smaller batches, by this method, if needed.
+     */
+    async getWsOperationEventsForTopics(topics, wsKey, operation) {
+        if (!topics.length) {
+            return [];
+        }
+        // Events that are ready to send (usually stringified JSON)
+        const requestEvents = [];
+        const maxTopicsPerEvent = this.getMaxTopicsPerSubscribeEvent(wsKey);
+        if (maxTopicsPerEvent &&
+            maxTopicsPerEvent !== null &&
+            topics.length > maxTopicsPerEvent) {
+            for (let i = 0; i < topics.length; i += maxTopicsPerEvent) {
+                const batch = topics.slice(i, i + maxTopicsPerEvent);
+                const subscribeRequestEvents = await this.getWsRequestEvents(wsKey, operation, batch);
+                requestEvents.push(...subscribeRequestEvents);
+            }
+            return requestEvents;
+        }
+        const subscribeRequestEvents = await this.getWsRequestEvents(wsKey, operation, topics);
+        return subscribeRequestEvents;
+    }
+    /**
+     * Simply builds and sends subscribe events for a list of topics for a ws key
+     *
+     * @private Use the `subscribe(topics)` or `subscribeTopicsForWsKey(topics, wsKey)` method to subscribe to topics. Send WS message to subscribe to topics.
+     */
+    async requestSubscribeTopics(wsKey, wsTopicRequests) {
+        if (!wsTopicRequests.length) {
+            return;
+        }
+        // Automatically splits requests into smaller batches, if needed
+        const subscribeWsMessages = await this.getWsOperationEventsForTopics(wsTopicRequests, wsKey, 'subscribe');
+        this.logger.trace(`Subscribing to ${wsTopicRequests.length} "${wsKey}" topics in ${subscribeWsMessages.length} batches.`);
+        for (const midflightRequest of subscribeWsMessages) {
+            const wsMessage = midflightRequest.requestEvent;
+            this.logger.trace(`Sending batch via message: "${JSON.stringify(wsMessage)}", cached with key "${midflightRequest.requestKey}"`);
+            try {
+                this.tryWsSend(wsKey, JSON.stringify(wsMessage), true);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                throw e;
+            }
+        }
+        this.logger.trace(`Finished subscribing to ${wsTopicRequests.length} "${wsKey}" topics in ${subscribeWsMessages.length} batches.`);
+    }
+    /**
+     * Simply builds and sends unsubscribe events for a list of topics for a ws key
+     *
+     * @private Use the `unsubscribe(topics)` method to unsubscribe from topics. Send WS message to unsubscribe from topics.
+     */
+    async requestUnsubscribeTopics(wsKey, wsTopicRequests) {
+        if (!wsTopicRequests.length) {
+            return;
+        }
+        const subscribeWsMessages = await this.getWsOperationEventsForTopics(wsTopicRequests, wsKey, 'unsubscribe');
+        this.logger.trace(`Unsubscribing to ${wsTopicRequests.length} "${wsKey}" topics in ${subscribeWsMessages.length} batches. Events: "${JSON.stringify(wsTopicRequests)}"`);
+        for (const midflightRequest of subscribeWsMessages) {
+            const wsMessage = midflightRequest.requestEvent;
+            this.logger.trace(`Sending batch via message: "${wsMessage}"`);
+            try {
+                this.tryWsSend(wsKey, JSON.stringify(wsMessage));
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                throw e;
+            }
+        }
+        this.logger.trace(`Finished unsubscribing to ${wsTopicRequests.length} "${wsKey}" topics in ${subscribeWsMessages.length} batches.`);
+    }
+    /**
+     * Try sending a string event on a WS connection (identified by the WS Key)
+     */
+    tryWsSend(wsKey, wsMessage, throwExceptions) {
+        try {
+            this.logger.trace('Sending upstream ws message: ', {
+                ...this.WS_LOGGER_CATEGORY,
+                wsMessage,
+                wsKey,
+            });
+            if (!wsKey) {
+                throw new Error('Cannot send message due to no known websocket for this wsKey');
+            }
+            const ws = this.getWs(wsKey);
+            if (!ws) {
+                throw new Error(`${wsKey} socket not connected yet, call "connectAll()" first then try again when the "open" event arrives`);
+            }
+            ws.send(wsMessage);
+        }
+        catch (e) {
+            this.logger.error('Failed to send WS message', {
+                ...this.WS_LOGGER_CATEGORY,
+                wsMessage,
+                wsKey,
+                exception: e,
+            });
+            if (throwExceptions) {
+                throw e;
+            }
+        }
+    }
+    async onWsOpen(event, wsKey, url, ws) {
+        const didReconnectSuccessfully = this.wsStore.isConnectionState(wsKey, WsConnectionStateEnum.RECONNECTING) || this.wsStore.isConnectionState(wsKey, WsConnectionStateEnum.ERROR);
+        const isFreshConnectionAttempt = this.wsStore.isConnectionState(wsKey, WsConnectionStateEnum.CONNECTING);
+        if (isFreshConnectionAttempt) {
+            this.logger.info('Websocket connected', {
+                ...this.WS_LOGGER_CATEGORY,
+                wsKey,
+            });
+            this.emit('open', { wsKey, event, wsUrl: url, ws });
+        }
+        else {
+            this.logger.info('Websocket reconnected', {
+                ...this.WS_LOGGER_CATEGORY,
+                wsKey,
+                didReconnectSuccessfully,
+            });
+            this.emit('reconnected', {
+                wsKey,
+                event,
+                wsUrl: url,
+                ws,
+            });
+        }
+        this.setWsState(wsKey, WsConnectionStateEnum.CONNECTED);
+        this.logger.trace('Enabled ping timer', {
+            ...this.WS_LOGGER_CATEGORY,
+            wsKey,
+        });
+        this.wsStore.get(wsKey, true).activePingTimer = setInterval(() => this.ping(wsKey), this.options.pingInterval);
+        if (!this.options.requireConnectionReadyConfirmation) {
+            return await this.onWsReadyForEvents(wsKey);
+        }
+        else {
+            this.resolveConnectionInProgressPromise(wsKey);
+        }
+        this.wsStore.removeConnectingInProgressPromise(wsKey);
+    }
+    resolveConnectionInProgressPromise(wsKey) {
+        try {
+            // Resolve & cleanup deferred "connection attempt in progress" promise
+            const connectionInProgressPromise = this.wsStore.getConnectionInProgressPromise(wsKey);
+            if (connectionInProgressPromise?.resolve) {
+                connectionInProgressPromise.resolve({
+                    wsKey,
+                    ws: this.wsStore.getWs(wsKey),
+                });
+            }
+        }
+        catch (e) {
+            this.logger.error('Exception trying to resolve "connectionInProgress" promise');
+        }
+    }
+    /**
+     * 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.
+     */
+    async onWsReadyForEvents(wsKey) {
+        this.resolveConnectionInProgressPromise(wsKey);
+        this.wsStore.removeConnectingInProgressPromise(wsKey);
+        // Some websockets require an auth packet to be sent after opening the connection
+        if (this.authPrivateConnectionsOnConnect(wsKey)) {
+            await 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
+        try {
+            await this.requestSubscribeTopics(wsKey, publicReqs);
+        }
+        catch (e) {
+            this.logger.error(`onWsOpen(): exception in public requestSubscribeTopics(${wsKey}): `, publicReqs, e);
+        }
+        // Request sub to private topics, if auth on connect isn't needed
+        if (!this.authPrivateConnectionsOnConnect(wsKey)) {
+            try {
+                this.requestSubscribeTopics(wsKey, privateReqs);
+            }
+            catch (e) {
+                this.logger.error(`onWsOpen(): exception in private requestSubscribeTopics(${wsKey}: `, privateReqs, e);
+            }
+        }
+    }
+    /**
+     * Handle subscription to private topics _after_ authentication successfully completes asynchronously.
+     *
+     * Only used for exchanges that require auth before sending private topic subscription requests
+     */
+    onWsAuthenticated(wsKey, event) {
+        const wsState = this.wsStore.get(wsKey, true);
+        wsState.isAuthenticated = true;
+        // Resolve & cleanup deferred "auth attempt in progress" promise
+        try {
+            const inProgressPromise = this.wsStore.getAuthenticationInProgressPromise(wsKey);
+            if (inProgressPromise?.resolve) {
+                inProgressPromise.resolve({
+                    wsKey,
+                    event,
+                    ws: wsState.ws,
+                });
+            }
+        }
+        catch (e) {
+            this.logger.error('Exception trying to resolve "authenticationInProgress" promise', e);
+        }
+        // Remove before continuing, in case there's more requests queued
+        this.wsStore.removeAuthenticationInProgressPromise(wsKey);
+        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);
+            }
+        }
+        if (event?.isWSAPI) {
+            wsState.didAuthWSAPI = true;
+            if (event?.WSAPIAuthChannel) {
+                wsState.WSAPIAuthChannel = event.WSAPIAuthChannel;
+            }
+        }
+    }
+    onWsPing(event, wsKey, ws, source) {
+        this.logger.trace(`Received PING ${source}`, {
+            ...this.WS_LOGGER_CATEGORY,
+            wsKey,
+            event,
+            source,
+        });
+        this.sendPongEvent(wsKey, ws);
+    }
+    onWsPong(event, wsKey, source) {
+        this.logger.trace(`Received PONG ${source}`, {
+            ...this.WS_LOGGER_CATEGORY,
+            wsKey,
+            event: event?.data,
+            source,
+        });
+        // Necessary when native heartbeats are used
+        this.clearPongTimer(wsKey);
+        return;
+    }
+    onWsMessage(event, wsKey, ws) {
+        try {
+            // console.log('onMessageRaw: ', (event as any).data);
+            // 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)) {
+                return this.onWsPong(event, wsKey, 'event');
+            }
+            if (this.isWsPing(event)) {
+                return this.onWsPing(event, wsKey, ws, 'event');
+            }
+            if (isMessageEvent(event)) {
+                const data = event.data;
+                const dataType = event.type;
+                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', {
+                        ...this.WS_LOGGER_CATEGORY,
+                        message: data || 'no message',
+                        dataType,
+                        event,
+                        wsKey,
+                    });
+                    return this.emit('message', { ...event, wsKey });
+                }
+                for (const emittable of emittableEvents) {
+                    if (this.isWsPong(emittable) || emittable.eventType === 'pong') {
+                        this.logger.trace('Received pong2', {
+                            ...this.WS_LOGGER_CATEGORY,
+                            wsKey,
+                            data,
+                        });
+                        continue;
+                    }
+                    this.logger.trace('getFinalEmittable()->pre(): ', JSON.stringify(emittable));
+                    const emittableFinalEvent = getFinalEmittable(emittable, wsKey, emittable.isWSAPIResponse);
+                    if (emittable.eventType === 'connectionReady') {
+                        this.logger.trace('Successfully connected - connection ready for events', {
+                            ...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 kraken. At least for spot, auth is included per req during subscribe
+                    if (emittable.eventType === 'connectionReadyForAuth') {
+                        this.logger.trace('Ready for auth - requesting auth submission...', {
+                            ...this.WS_LOGGER_CATEGORY,
+                            wsKey,
+                        });
+                        this.sendAuthRequest(wsKey, emittable.event);
+                        continue;
+                    }
+                    // Not used for kraken. At least for spot, auth is included per req during subscribe
+                    if (emittable.eventType === 'authenticated') {
+                        this.logger.trace('Successfully authenticated', {
+                            ...this.WS_LOGGER_CATEGORY,
+                            wsKey,
+                            emittable,
+                        });
+                        this.emit(emittable.eventType, emittableFinalEvent);
+                        this.onWsAuthenticated(wsKey, emittable.event);
+                        continue;
+                    }
+                    // Other event types are automatically emitted here
+                    this.logger.trace(`onWsMessage().emit(${emittable.eventType})`, emittableFinalEvent);
+                    try {
+                        this.emit(emittable.eventType, emittableFinalEvent);
+                    }
+                    catch (e) {
+                        this.logger.error(`Exception in onWsMessage().emit(${emittable.eventType}) handler:`, e);
+                    }
+                    // this.logger.trace(
+                    //   `onWsMessage().emit(${emittable.eventType}).done()`,
+                    //   emittableFinalEvent,
+                    // );
+                }
+                return;
+            }
+            this.logger.error('Unhandled/unrecognised ws event message - unexpected message format', {
+                ...this.WS_LOGGER_CATEGORY,
+                message: event || 'no message',
+                event,
+                wsKey,
+            });
+        }
+        catch (e) {
+            this.logger.error('Failed to parse ws event message', {
+                ...this.WS_LOGGER_CATEGORY,
+                error: e,
+                event,
+                wsKey,
+            });
+        }
+    }
+    onWsClose(event, wsKey) {
+        this.logger.info('Websocket connection closed', {
+            ...this.WS_LOGGER_CATEGORY,
+            wsKey,
+        });
+        const wsState = this.wsStore.get(wsKey, true);
+        wsState.isAuthenticated = false;
+        const wsConnectionState = this.wsStore.getConnectionState(wsKey);
+        if (wsConnectionState !== 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');
+            // this.clearTopicsPendingSubscriptions(wsKey, true, 'WS Closed');
+            this.setWsState(wsKey, WsConnectionStateEnum.INITIAL);
+            this.reconnectWithDelay(wsKey, this.options.reconnectTimeout);
+            this.emit('reconnecting', { 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');
+            this.setWsState(wsKey, WsConnectionStateEnum.INITIAL);
+            // This was an intentional close, delete all state for this connection, as if it never existed:
+            this.wsStore.delete(wsKey);
+            this.emit('close', { wsKey, event });
+        }
+    }
+    getWs(wsKey) {
+        return this.wsStore.getWs(wsKey);
+    }
+    setWsState(wsKey, state) {
+        this.wsStore.setConnectionState(wsKey, state);
+    }
+    /**
+     * Promise-driven method to assert that a ws has successfully connected (will await until connection is open)
+     */
+    async assertIsConnected(wsKey) {
+        const isConnected = this.getWsStore().isConnectionState(wsKey, WsConnectionStateEnum.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...');
+            await inProgressPromise.promise;
+            this.logger.trace('assertIsConnected(): awaiting...connected!');
+            return;
+        }
+        // Start connection, it should automatically store/return a promise.
+        this.logger.trace('assertIsConnected(): connecting...');
+        await this.connect(wsKey);
+        this.logger.trace('assertIsConnected(): connecting...newly connected!');
+    }
+    /**
+     * Promise-driven method to assert that a ws has been successfully authenticated (will await until auth is confirmed)
+     */
+    async assertIsAuthenticated(wsKey) {
+        const isConnected = this.getWsStore().isConnectionState(wsKey, WsConnectionStateEnum.CONNECTED);
+        if (!isConnected) {
+            this.logger.trace('assertIsAuthenticated(): connecting...');
+            await this.assertIsConnected(wsKey);
+        }
+        const inProgressPromise = this.getWsStore().getAuthenticationInProgressPromise(wsKey);
+        // Already in progress? Await shared promise and retry
+        if (inProgressPromise) {
+            this.logger.trace('assertIsAuthenticated(): awaiting...');
+            await inProgressPromise.promise;
+            this.logger.trace('assertIsAuthenticated(): authenticated!');
+            return;
+        }
+        const isAuthenticated = this.wsStore.get(wsKey)?.isAuthenticated;
+        if (isAuthenticated) {
+            this.logger.trace('assertIsAuthenticated(): ok');
+            return;
+        }
+        // Start authentication, it should automatically store/return a promise.
+        this.logger.trace('assertIsAuthenticated(): authenticating...');
+        await this.sendAuthRequest(wsKey);
+        this.logger.trace('assertIsAuthenticated(): newly authenticated!');
+    }
+}
+//# sourceMappingURL=BaseWSClient.js.map