@siebly/kraken-api 0.0.9

package/dist/cjs/WebsocketClient.js

@@ -0,0 +1,669 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketClient = void 0;
+const BaseWSClient_js_1 = require("./lib/BaseWSClient.js");
+const misc_util_js_1 = require("./lib/misc-util.js");
+const webCryptoAPI_js_1 = require("./lib/webCryptoAPI.js");
+const rest_client_cache_js_1 = require("./lib/websocket/rest-client-cache.js");
+const websocket_util_js_1 = require("./lib/websocket/websocket-util.js");
+const ws_api_js_1 = require("./types/websockets/ws-api.js");
+const ws_subscriptions_js_1 = require("./types/websockets/ws-subscriptions.js");
+const WS_LOGGER_CATEGORY_ID = 'kraken-ws';
+const WS_LOGGER_CATEGORY = {
+    category: WS_LOGGER_CATEGORY_ID,
+};
+class WebsocketClient extends BaseWSClient_js_1.BaseWebsocketClient {
+    restClientCache = new rest_client_cache_js_1.RestClientCache();
+    wsChallengeCache = new Map();
+    constructor(options, logger) {
+        super({ ...options, wsLoggerCategory: WS_LOGGER_CATEGORY_ID }, logger);
+        this.restClientCache.setLogger(this.logger, WS_LOGGER_CATEGORY);
+    }
+    /**
+     * Request connection of all dependent (public & private) websockets, instead of waiting for automatic connection by library.
+     *
+     * Returns array of promises that individually resolve when each connection is successfully opened.
+     */
+    connectAll() {
+        return [this.connect(websocket_util_js_1.WS_KEY_MAP.spotPrivateV2)];
+    }
+    /**
+     * Ensures the WS API connection is active and ready.
+     *
+     * You do not need to call this, but if you call this before making any WS API requests,
+     * it can accelerate the first request (by preparing the connection in advance).
+     */
+    connectWSAPI(wsKey, skipAuth) {
+        if (skipAuth) {
+            return this.assertIsConnected(wsKey);
+        }
+        /** This call automatically ensures the connection is active AND authenticated before resolving */
+        return this.assertIsAuthenticated(wsKey);
+    }
+    /**
+     * Request subscription to one or more topics. Pass topics as either an array of strings, or array of objects (if the topic has parameters).
+     * Objects should be formatted as {topic: string, params: object}.
+     *
+     * - Subscriptions are automatically routed to the correct websocket connection.
+     * - Authentication/connection is automatic.
+     * - Resubscribe after network issues is automatic.
+     *
+     * Call `unsubscribe(topics)` to remove topics
+     */
+    subscribe(requests, wsKey) {
+        if (!Array.isArray(requests)) {
+            this.subscribeTopicsForWsKey([requests], wsKey);
+            return;
+        }
+        if (requests.length) {
+            this.subscribeTopicsForWsKey(requests, wsKey);
+        }
+    }
+    /**
+     * Unsubscribe from one or more topics. Similar to subscribe() but in reverse.
+     *
+     * - Requests are automatically routed to the correct websocket connection.
+     * - These topics will be removed from the topic cache, so they won't be subscribed to again.
+     */
+    unsubscribe(requests, wsKey) {
+        if (!Array.isArray(requests)) {
+            this.unsubscribeTopicsForWsKey([requests], wsKey);
+            return;
+        }
+        if (requests.length) {
+            this.unsubscribeTopicsForWsKey(requests, wsKey);
+        }
+    }
+    async sendWSAPIRequest(wsKey, operation, params, requestFlags) {
+        /**
+         * Base Info:
+         * - https://docs.kraken.com/api/docs/websocket-v2/add_order
+         *
+         * Currently only supported for Spot markets
+         */
+        this.logger.trace(`sendWSAPIRequest(): assert "${wsKey}" is connected`, {
+            ...WS_LOGGER_CATEGORY,
+        });
+        await this.assertIsConnected(wsKey);
+        // Some commands don't require authentication.
+        if (requestFlags?.authIsOptional !== true) {
+            this.logger.trace('sendWSAPIRequest(): assertIsAuthenticated(${wsKey})...');
+            await this.assertIsAuthenticated(wsKey);
+            this.logger.trace('sendWSAPIRequest(): assertIsAuthenticated(${wsKey}) ok');
+        }
+        const requestEvent = {
+            method: operation,
+            params: params,
+            req_id: this.getNewRequestId(),
+        };
+        // Sign request
+        const signedEvent = await this.signWSAPIRequest(requestEvent);
+        // Store deferred promise
+        const promiseRef = (0, websocket_util_js_1.getPromiseRefForWSAPIRequest)(wsKey, requestEvent);
+        const deferredPromise = this.getWsStore().createDeferredPromise(wsKey, promiseRef, false);
+        // Enrich returned promise with request context for easier debugging
+        deferredPromise.promise
+            ?.then((res) => {
+            if (!Array.isArray(res)) {
+                res.request = {
+                    wsKey: wsKey,
+                    ...signedEvent,
+                };
+            }
+            return res;
+        })
+            .catch((e) => {
+            if (typeof e === 'string') {
+                this.logger.error('unexpcted string', { e });
+                return e;
+            }
+            e.request = {
+                wsKey: wsKey,
+                operation,
+                payload: signedEvent.params,
+            };
+            return e;
+        });
+        // Send event
+        const throwExceptions = true;
+        this.tryWsSend(wsKey, JSON.stringify(signedEvent), throwExceptions);
+        this.logger.trace(`sendWSAPIRequest(): sent "${operation}" event with promiseRef(${promiseRef})`, signedEvent);
+        // Return deferred promise, so caller can await this call
+        return deferredPromise.promise;
+    }
+    /**
+     *
+     * Internal methods - not intended for public use
+     *
+     */
+    getRestClientOptions() {
+        return {
+            ...this.options,
+            ...this.options.restOptions,
+            apiKey: this.options.apiKey,
+            apiSecret: this.options.apiSecret,
+        };
+    }
+    /**
+     * Note: implementing this method will wipe the WsStore state for this WsKey, once this method returns
+     */
+    isCustomReconnectionNeeded() {
+        return false;
+    }
+    async triggerCustomReconnectionWorkflow() {
+        return;
+    }
+    async getWsUrl(wsKey) {
+        if (this.options.wsUrl) {
+            return this.options.wsUrl;
+        }
+        switch (wsKey) {
+            /**
+             * https://docs.kraken.com/api/docs/guides/spot-ws-intro/
+             *
+             * Note: Kraken's v2 WebSockets clean up a number idiosyncrasies and ambiguities from v1 with the overall aim to enable easier integration with applications. It is intended that v1 will be maintained but future enhancements will be developed in v2.
+             *
+             * Given the above, we are only integrating with V2 for now.
+             *
+             * V2 SpotWebSocket Reference: https://docs.kraken.com/api/docs/websocket-v2/add_order/
+             */
+            case websocket_util_js_1.WS_KEY_MAP.spotPublicV2: {
+                return 'wss://ws.kraken.com/v2';
+            }
+            case websocket_util_js_1.WS_KEY_MAP.spotPrivateV2: {
+                return 'wss://ws-auth.kraken.com/v2';
+            }
+            case websocket_util_js_1.WS_KEY_MAP.spotBetaPublicV2: {
+                return 'wss://beta-ws.kraken.com/v2';
+            }
+            case websocket_util_js_1.WS_KEY_MAP.spotBetaPrivateV2: {
+                return 'wss://beta-ws-auth.kraken.com/v2';
+            }
+            // Uses the same URL, but we maintain separate connections for easier management
+            case websocket_util_js_1.WS_KEY_MAP.derivativesPublicV1:
+            case websocket_util_js_1.WS_KEY_MAP.derivativesPrivateV1: {
+                if (this.options.testnet) {
+                    return 'wss://demo-futures.kraken.com/ws/v1';
+                }
+                return 'wss://futures.kraken.com/ws/v1';
+            }
+            default: {
+                throw (0, misc_util_js_1.neverGuard)(wsKey, `Unhandled WsKey "${wsKey}"`);
+            }
+        }
+    }
+    sendPingEvent(wsKey) {
+        // let pingChannel: WsRequestPing['channel'];
+        switch (wsKey) {
+            case websocket_util_js_1.WS_KEY_MAP.derivativesPublicV1:
+            case websocket_util_js_1.WS_KEY_MAP.derivativesPrivateV1: {
+                const ws = this.getWsStore().get(wsKey)?.ws;
+                if (ws) {
+                    ws.ping();
+                }
+                break;
+            }
+            case websocket_util_js_1.WS_KEY_MAP.spotPublicV2:
+            case websocket_util_js_1.WS_KEY_MAP.spotPrivateV2:
+            case websocket_util_js_1.WS_KEY_MAP.spotBetaPublicV2:
+            case websocket_util_js_1.WS_KEY_MAP.spotBetaPrivateV2: {
+                // Spot: https://docs.kraken.com/api/docs/websocket-v2/ping
+                return this.tryWsSend(wsKey, `{ "method": "ping", "req_id": ${this.getNewRequestId()} }`);
+            }
+            default: {
+                throw (0, misc_util_js_1.neverGuard)(wsKey, `Unhandled WsKey "${wsKey}"`);
+            }
+        }
+    }
+    sendPongEvent(wsKey) {
+        try {
+            this.logger.trace('Sending upstream ws PONGFRAME: ', {
+                ...WS_LOGGER_CATEGORY,
+                wsMessage: 'PONGFRAME',
+                wsKey,
+            });
+            if (!wsKey) {
+                throw new Error('Cannot send PONGFRAME, no wsKey provided');
+            }
+            const wsState = this.getWsStore().get(wsKey);
+            if (!wsState || !wsState?.ws) {
+                throw new Error(`Cannot send PONGFRAME, ${wsKey} socket not connected yet`);
+            }
+            // Send a protocol layer pong
+            wsState.ws.pong();
+        }
+        catch (e) {
+            this.logger.error('Failed to send WS PONG', {
+                ...WS_LOGGER_CATEGORY,
+                wsMessage: 'PONGFRAME',
+                wsKey,
+                exception: e,
+            });
+        }
+    }
+    // NOT IN USE for kraken
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isWsPing(_msg) {
+        return false;
+    }
+    isWsPong(msg) {
+        // Pre-parsed in resolveEmittableEvents into "pong" eventType:
+        if (msg?.eventType) {
+            if (msg?.eventType === 'pong') {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Parse incoming events into categories, before emitting to the user
+     */
+    resolveEmittableEvents(wsKey, event) {
+        const results = [];
+        try {
+            const parsed = JSON.parse(event.data);
+            // derivatives sends 'challenge' on successful auth-init (used for sign during subscribe)
+            const responseEvents = [
+                // spot confirmation for subscription success
+                'subscribe',
+                'unsubscribe',
+                'info',
+                // derivatives confirmation for subscription success
+                'subscribed',
+                'unsubscribed',
+            ];
+            const authenticatedEvents = ['challenge'];
+            const derivativesEventAction = parsed.event || parsed.feed;
+            const spotEventAction = parsed.method ||
+                parsed.type ||
+                parsed.event ||
+                parsed?.header?.data ||
+                parsed.channel;
+            const eventAction = spotEventAction || derivativesEventAction;
+            const promiseRef = [wsKey, eventAction, parsed?.req_id].join('_');
+            // WS API
+            if (ws_api_js_1.WS_API_Operations.includes(eventAction)) {
+                const isError = parsed.success !== true;
+                // WS API Exception
+                if (isError) {
+                    try {
+                        this.getWsStore().rejectDeferredPromise(wsKey, promiseRef, {
+                            wsKey,
+                            ...parsed,
+                        }, true);
+                    }
+                    catch (e) {
+                        this.logger.error('Exception trying to reject WSAPI promise', {
+                            wsKey,
+                            promiseRef,
+                            parsedEvent: parsed,
+                            error: e,
+                        });
+                    }
+                    results.push({
+                        eventType: 'exception',
+                        event: parsed,
+                        isWSAPIResponse: true,
+                    });
+                    return results;
+                }
+                // WS API Success
+                try {
+                    this.getWsStore().resolveDeferredPromise(wsKey, promiseRef, {
+                        wsKey,
+                        ...parsed,
+                    }, true);
+                }
+                catch (e) {
+                    this.logger.error('Exception trying to resolve WSAPI promise', {
+                        wsKey,
+                        promiseRef,
+                        parsedEvent: parsed,
+                        error: e,
+                    });
+                }
+                results.push({
+                    eventType: 'response',
+                    event: parsed,
+                    isWSAPIResponse: true,
+                });
+                return results;
+            } // end of WS API response processing
+            if (typeof eventAction === 'string') {
+                if (parsed.success === false) {
+                    results.push({
+                        eventType: 'exception',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // exceptions with derivatives v1 WS. E.g. { event: 'alert', message: 'Bad websocket message' }
+                if (eventAction === 'alert') {
+                    results.push({
+                        eventType: 'exception',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // Most events use event: "update" or "snapshot" for topic updates
+                if (['update', 'snapshot'].includes(eventAction)) {
+                    results.push({
+                        eventType: 'message',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // These are request/reply pattern events (e.g. after subscribing to topics or authenticating)
+                // e.g. "method":"subscribe"
+                if (responseEvents.includes(eventAction)) {
+                    results.push({
+                        eventType: 'response',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // derivatives events include the "feed" property to identify the channel name
+                if (typeof parsed.feed === 'string') {
+                    results.push({
+                        eventType: 'message',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                // Request/reply pattern for authentication success
+                if (authenticatedEvents.includes(eventAction)) {
+                    if (wsKey === websocket_util_js_1.WS_KEY_MAP.derivativesPrivateV1) {
+                        const challenge = parsed.message;
+                        if (challenge) {
+                            this.logger.trace(`Stored challenge for derivatives auth on wsKey "${wsKey}": "${challenge}"`);
+                            this.wsChallengeCache.set(wsKey, challenge);
+                        }
+                    }
+                    results.push({
+                        eventType: 'authenticated',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                if (eventAction === 'heartbeat' || eventAction === 'pong') {
+                    results.push({
+                        eventType: 'pong',
+                        event: parsed,
+                    });
+                    return results;
+                }
+                this.logger.error(`!! Unhandled string "eventAction" "${eventAction}". Defaulting to "message" channel... Parsed:`, parsed);
+            }
+            else {
+                this.logger.error(`!! Unhandled non-string "eventAction" "${eventAction}". Defaulting to "message" channel... Parsed:`, parsed);
+            }
+            results.push({
+                eventType: 'message',
+                event: parsed,
+            });
+        }
+        catch (e) {
+            results.push({
+                event: {
+                    message: 'Failed to parse event data due to exception',
+                    exception: e,
+                    eventData: event.data,
+                },
+                eventType: 'exception',
+            });
+            this.logger.error('Failed to parse event data due to exception: ', {
+                exception: e,
+                eventData: event.data,
+            });
+        }
+        return results;
+    }
+    /**
+     * Determines if a topic is for a private channel, using a hardcoded list of strings
+     */
+    isPrivateTopicRequest(request) {
+        const topicName = request?.topic?.toLowerCase();
+        if (!topicName) {
+            return false;
+        }
+        if (ws_subscriptions_js_1.WS_SPOT_PRIVATE_TOPICS.includes(topicName)) {
+            return true;
+        }
+        if (ws_subscriptions_js_1.WS_DERIVATIVES_PRIVATE_TOPICS.includes(topicName)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Not in use for Kraken
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getWsMarketForWsKey(_wsKey) {
+        return 'futures';
+    }
+    /**
+     * Whether key represents a private connection. Feeds into automatic auth on connect.
+     */
+    getPrivateWSKeys() {
+        return [
+            websocket_util_js_1.WS_KEY_MAP.spotPrivateV2,
+            websocket_util_js_1.WS_KEY_MAP.spotBetaPrivateV2,
+            websocket_util_js_1.WS_KEY_MAP.derivativesPrivateV1,
+        ];
+    }
+    isAuthOnConnectWsKey(wsKey) {
+        return this.getPrivateWSKeys().includes(wsKey);
+    }
+    /** Force subscription requests to be sent in smaller batches, if a number is returned */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getMaxTopicsPerSubscribeEvent(_wsKey) {
+        return 1;
+    }
+    authPrivateConnectionsOnConnect(wsKey) {
+        // derivatives require you to send a challenge on connect
+        if (wsKey === websocket_util_js_1.WS_KEY_MAP.derivativesPrivateV1) {
+            return true;
+        }
+        return this.options.authPrivateConnectionsOnConnect;
+    }
+    /**
+     * @returns one or more correctly structured request events for performing a operations over WS. This can vary per exchange spec.
+     */
+    async getWsRequestEvents(wsKey, operation, requests) {
+        const wsRequestEvents = [];
+        const wsRequestBuildingErrors = [];
+        // Previously used to track topics in a request. Keeping this for subscribe/unsubscribe requests, no need for incremental values
+        for (const topicRequest of requests) {
+            const req_id = this.getNewRequestId();
+            switch (wsKey) {
+                case websocket_util_js_1.WS_KEY_MAP.spotPublicV2:
+                case websocket_util_js_1.WS_KEY_MAP.spotPrivateV2:
+                case websocket_util_js_1.WS_KEY_MAP.spotBetaPublicV2:
+                case websocket_util_js_1.WS_KEY_MAP.spotBetaPrivateV2: {
+                    const wsEvent = {
+                        method: operation,
+                        params: {
+                            channel: topicRequest.topic,
+                            ...topicRequest.payload,
+                        },
+                        req_id: req_id,
+                    };
+                    if (this.options.authPrivateRequests &&
+                        (wsKey === websocket_util_js_1.WS_KEY_MAP.spotPrivateV2 ||
+                            wsKey === websocket_util_js_1.WS_KEY_MAP.spotBetaPrivateV2)) {
+                        // Get token from REST client cache
+                        const tokenResult = await this.restClientCache.fetchSpotWebSocketToken(this.getRestClientOptions(), this.options.requestOptions);
+                        if (!tokenResult?.token) {
+                            wsRequestBuildingErrors.push(new Error(`No WS auth token could be retrieved for private spot WS request for topic "${topicRequest.topic}"`));
+                            continue;
+                        }
+                        wsEvent.params.token = tokenResult.token;
+                    }
+                    // Cache midflight subs on the req ID
+                    // Enrich response with subs for that req ID
+                    const midflightWsEvent = {
+                        requestKey: wsEvent.req_id,
+                        requestEvent: wsEvent,
+                    };
+                    wsRequestEvents.push({
+                        ...midflightWsEvent,
+                    });
+                    break;
+                }
+                // No auth needed, it's public topics only here
+                case websocket_util_js_1.WS_KEY_MAP.derivativesPublicV1: {
+                    const wsEvent = {
+                        event: operation,
+                        feed: topicRequest.topic,
+                        ...topicRequest.payload,
+                        req_id: req_id,
+                    };
+                    // Cache midflight subs on the req ID
+                    // Enrich response with subs for that req ID
+                    const midflightWsEvent = {
+                        requestKey: wsEvent.req_id,
+                        requestEvent: wsEvent,
+                    };
+                    wsRequestEvents.push({
+                        ...midflightWsEvent,
+                    });
+                    break;
+                }
+                case websocket_util_js_1.WS_KEY_MAP.derivativesPrivateV1: {
+                    const wsEvent = {
+                        event: operation,
+                        feed: topicRequest.topic,
+                        ...topicRequest.payload,
+                        req_id: req_id,
+                    };
+                    // https://docs.kraken.com/api/docs/guides/futures-websockets
+                    // Authenticated requests must include both the original challenge message (original_challenge) and the signed (signed_challenge) in JSON format.
+                    if (!this.wsChallengeCache.has(wsKey)) {
+                        this.logger.trace(`No challenge key cached for wsKey ${wsKey}, asserting authentication...`, { ...WS_LOGGER_CATEGORY, wsKey });
+                        await this.assertIsAuthenticated(wsKey);
+                    }
+                    const challengeKey = this.wsChallengeCache.get(wsKey);
+                    if (!challengeKey) {
+                        this.logger.error(`Auth-check passed but no challenge key could be retrieved from cache for wsKey ${wsKey}`, { ...WS_LOGGER_CATEGORY, wsKey });
+                        throw new Error('No challenge key cached, cannot send authenticated request');
+                    }
+                    wsEvent.original_challenge = challengeKey;
+                    wsEvent.api_key = this.options.apiKey;
+                    const hashedChallenge = await (0, webCryptoAPI_js_1.hashMessage)(challengeKey, 'binary', 'SHA-256');
+                    if (!this.options.apiSecret) {
+                        throw new Error('API Secret missing, cannot sign challenge for authenticated WS request');
+                    }
+                    const challengeSign = await this.signMessage(hashedChallenge, this.options.apiSecret, 'base64', 'SHA-512', {
+                        isSecretB64Encoded: true,
+                        isInputBinaryString: true,
+                    });
+                    wsEvent.signed_challenge = challengeSign;
+                    // Cache midflight subs on the req ID
+                    // Enrich response with subs for that req ID
+                    const midflightWsEvent = {
+                        requestKey: wsEvent.req_id,
+                        requestEvent: wsEvent,
+                    };
+                    wsRequestEvents.push({
+                        ...midflightWsEvent,
+                    });
+                    break;
+                }
+                default: {
+                    throw (0, misc_util_js_1.neverGuard)(wsKey, `Unhandled WsKey "${wsKey}"`);
+                }
+            }
+        }
+        if (wsRequestBuildingErrors.length) {
+            const label = wsRequestBuildingErrors.length === requests.length ? 'all' : 'some';
+            this.logger.error(`Failed to build/send ${wsRequestBuildingErrors.length} event(s) for ${label} WS requests due to exceptions`, {
+                ...WS_LOGGER_CATEGORY,
+                wsRequestBuildingErrors,
+                wsRequestBuildingErrorsStringified: JSON.stringify(wsRequestBuildingErrors, null, 2),
+            });
+        }
+        return wsRequestEvents;
+    }
+    async signMessage(paramsStr, secret, method, algorithm, options) {
+        if (typeof this.options.customSignMessageFn === 'function') {
+            return this.options.customSignMessageFn(paramsStr, secret);
+        }
+        return await (0, webCryptoAPI_js_1.signMessage)(paramsStr, secret, method, algorithm, options);
+    }
+    async getWsAuthRequestEvent(wsKey, eventToAuth) {
+        try {
+            switch (wsKey) {
+                case websocket_util_js_1.WS_KEY_MAP.spotPrivateV2:
+                case websocket_util_js_1.WS_KEY_MAP.spotBetaPrivateV2: {
+                    // Not needed here, handled automatically with request during subscribe
+                    this.logger.trace(`getWsAuthRequestEvent(${wsKey}): no auth request required for private WS...`);
+                    return;
+                }
+                case websocket_util_js_1.WS_KEY_MAP.spotPublicV2:
+                case websocket_util_js_1.WS_KEY_MAP.spotBetaPublicV2:
+                case websocket_util_js_1.WS_KEY_MAP.derivativesPublicV1: {
+                    // Public WS - no auth
+                    this.logger.trace(`getWsAuthRequestEvent(${wsKey}): no auth required for public WS...`);
+                    return;
+                }
+                case websocket_util_js_1.WS_KEY_MAP.derivativesPrivateV1: {
+                    // cleanup old challenge key (in case we were reconnected)
+                    this.wsChallengeCache.delete(wsKey);
+                    // https://docs.kraken.com/api/docs/futures-api/websocket/challenge/
+                    this.logger.trace(`getWsAuthRequestEvent(${wsKey}): preparing auth challenge request...`, { ...WS_LOGGER_CATEGORY, wsKey });
+                    const challengeRequest = {
+                        event: 'challenge',
+                        api_key: this.options.apiKey,
+                    };
+                    return challengeRequest;
+                }
+                default: {
+                    throw (0, misc_util_js_1.neverGuard)(wsKey, `Unhandled WsKey "${wsKey}"`);
+                }
+            }
+        }
+        catch (e) {
+            this.logger.error(`getWsAuthRequestEvent(${wsKey}): Exception preparing auth request: `, {
+                wsKey,
+                eventToAuth,
+                exception: e,
+                exceptionBody: e?.body,
+                stack: e?.stack,
+            });
+            throw e;
+        }
+    }
+    /**
+     *
+     * @param requestEvent
+     * @returns A signed updated WS API request object, ready to be sent
+     */
+    async signWSAPIRequest(requestEvent) {
+        if (!this.options.apiSecret) {
+            throw new Error('API Secret missing');
+        }
+        // Get token from REST client cache
+        const tokenResult = await this.restClientCache.fetchSpotWebSocketToken(this.getRestClientOptions(), this.options.requestOptions);
+        if (!tokenResult?.token) {
+            const error = new Error(`No WS auth token could be retrieved for private spot WS request for topic "${requestEvent.method}"`);
+            error.cause = tokenResult;
+            throw error;
+        }
+        const authParams = {};
+        if (tokenResult.token) {
+            authParams.token = tokenResult.token;
+        }
+        if (requestEvent.method === 'add_order') {
+            // authParams.broker = APIIDMain;
+        }
+        return {
+            ...requestEvent,
+            params: {
+                ...requestEvent.params,
+                ...authParams,
+            },
+        };
+    }
+}
+exports.WebsocketClient = WebsocketClient;
+//# sourceMappingURL=WebsocketClient.js.map