@pythnetwork/pyth-lazer-sdk 5.0.0 → 5.2.0

package/dist/cjs/{client.js → client.cjs}

@@ -1,11 +1,18 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PythLazerClient = void 0;
-const ts_log_1 = require("ts-log");
-const constants_js_1 = require("./constants.js");
-const protocol_js_1 = require("./protocol.js");
-const websocket_pool_js_1 = require("./socket/websocket-pool.js");
-const buffer_util_js_1 = require("./util/buffer-util.js");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PythLazerClient", {
+    enumerable: true,
+    get: function() {
+        return PythLazerClient;
+    }
+});
+const _tslog = require("ts-log");
+const _constants = require("./constants.cjs");
+const _protocol = require("./protocol.cjs");
+const _websocketpool = require("./socket/websocket-pool.cjs");
+const _bufferutil = require("./util/buffer-util.cjs");
 const UINT16_NUM_BYTES = 2;
 const UINT32_NUM_BYTES = 4;
 const UINT64_NUM_BYTES = 8;
@@ -15,7 +22,7 @@ class PythLazerClient {
     priceServiceUrl;
     logger;
     wsp;
-    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp) {
+    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp){
         this.token = token;
         this.metadataServiceUrl = metadataServiceUrl;
         this.priceServiceUrl = priceServiceUrl;
@@ -23,91 +30,82 @@ class PythLazerClient {
         this.wsp = wsp;
     }
     /**
-     * Gets the WebSocket pool. If the WebSocket pool is not configured, an error is thrown.
-     * @throws Error if WebSocket pool is not configured
-     * @returns The WebSocket pool
-     */
-    getWebSocketPool() {
+   * Gets the WebSocket pool. If the WebSocket pool is not configured, an error is thrown.
+   * @throws Error if WebSocket pool is not configured
+   * @returns The WebSocket pool
+   */ getWebSocketPool() {
         if (!this.wsp) {
             throw new Error("WebSocket pool is not available. Make sure to provide webSocketPoolConfig when creating the client.");
         }
         return this.wsp;
     }
     /**
-     * Creates a new PythLazerClient instance.
-     * @param config - Configuration including token, metadata service URL, and price service URL, and WebSocket pool configuration
-     */
-    static async create(config) {
+   * Creates a new PythLazerClient instance.
+   * @param config - Configuration including token, metadata service URL, and price service URL, and WebSocket pool configuration
+   */ static async create(config) {
         const token = config.token;
         // Collect and remove trailing slash from URLs
-        const metadataServiceUrl = (config.metadataServiceUrl ?? constants_js_1.DEFAULT_METADATA_SERVICE_URL).replace(/\/+$/, "");
-        const priceServiceUrl = (config.priceServiceUrl ?? constants_js_1.DEFAULT_PRICE_SERVICE_URL).replace(/\/+$/, "");
-        const logger = config.logger ?? ts_log_1.dummyLogger;
+        const metadataServiceUrl = (config.metadataServiceUrl ?? _constants.DEFAULT_METADATA_SERVICE_URL).replace(/\/+$/, "");
+        const priceServiceUrl = (config.priceServiceUrl ?? _constants.DEFAULT_PRICE_SERVICE_URL).replace(/\/+$/, "");
+        const logger = config.logger ?? _tslog.dummyLogger;
         // If webSocketPoolConfig is provided, create a WebSocket pool and block until at least one connection is established.
         let wsp;
         if (config.webSocketPoolConfig) {
-            wsp = await websocket_pool_js_1.WebSocketPool.create(config.webSocketPoolConfig, token, logger);
+            wsp = await _websocketpool.WebSocketPool.create(config.webSocketPoolConfig, token, logger);
         }
         return new PythLazerClient(token, metadataServiceUrl, priceServiceUrl, logger, wsp);
     }
     /**
-     * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
-     * The listener will be called for each message received, with deduplication across redundant connections.
-     * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
-     * or a binary response containing EVM, Solana, or parsed payload data.
-     */
-    addMessageListener(handler) {
+   * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
+   * The listener will be called for each message received, with deduplication across redundant connections.
+   * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
+   * or a binary response containing EVM, Solana, or parsed payload data.
+   */ addMessageListener(handler) {
         const wsp = this.getWebSocketPool();
-        wsp.addMessageListener(async (data) => {
+        wsp.addMessageListener(async (data)=>{
             if (typeof data == "string") {
                 handler({
                     type: "json",
-                    value: JSON.parse(data),
+                    value: JSON.parse(data)
                 });
                 return;
             }
-            const buffData = await (0, buffer_util_js_1.bufferFromWebsocketData)(data);
+            const buffData = await (0, _bufferutil.bufferFromWebsocketData)(data);
             let pos = 0;
-            const magic = buffData
-                .subarray(pos, pos + UINT32_NUM_BYTES)
-                .readUint32LE();
+            const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
             pos += UINT32_NUM_BYTES;
-            if (magic != protocol_js_1.BINARY_UPDATE_FORMAT_MAGIC_LE) {
+            if (magic != _protocol.BINARY_UPDATE_FORMAT_MAGIC_LE) {
                 throw new Error("binary update format magic mismatch");
             }
             // TODO: some uint64 values may not be representable as Number.
             const subscriptionId = Number(buffData.subarray(pos, pos + UINT64_NUM_BYTES).readBigInt64BE());
             pos += UINT64_NUM_BYTES;
-            const value = { subscriptionId };
-            while (pos < buffData.length) {
-                const len = buffData
-                    .subarray(pos, pos + UINT16_NUM_BYTES)
-                    .readUint16BE();
+            const value = {
+                subscriptionId
+            };
+            while(pos < buffData.length){
+                const len = buffData.subarray(pos, pos + UINT16_NUM_BYTES).readUint16BE();
                 pos += UINT16_NUM_BYTES;
-                const magic = buffData
-                    .subarray(pos, pos + UINT32_NUM_BYTES)
-                    .readUint32LE();
-                if (magic == protocol_js_1.FORMAT_MAGICS_LE.EVM) {
+                const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
+                if (magic == _protocol.FORMAT_MAGICS_LE.EVM) {
                     value.evm = buffData.subarray(pos, pos + len);
-                }
-                else if (magic == protocol_js_1.FORMAT_MAGICS_LE.SOLANA) {
+                } else if (magic == _protocol.FORMAT_MAGICS_LE.SOLANA) {
                     value.solana = buffData.subarray(pos, pos + len);
-                }
-                else if (magic == protocol_js_1.FORMAT_MAGICS_LE.LE_ECDSA) {
+                } else if (magic == _protocol.FORMAT_MAGICS_LE.LE_ECDSA) {
                     value.leEcdsa = buffData.subarray(pos, pos + len);
-                }
-                else if (magic == protocol_js_1.FORMAT_MAGICS_LE.LE_UNSIGNED) {
+                } else if (magic == _protocol.FORMAT_MAGICS_LE.LE_UNSIGNED) {
                     value.leUnsigned = buffData.subarray(pos, pos + len);
-                }
-                else if (magic == protocol_js_1.FORMAT_MAGICS_LE.JSON) {
+                } else if (magic == _protocol.FORMAT_MAGICS_LE.JSON) {
                     value.parsed = JSON.parse(buffData.subarray(pos + UINT32_NUM_BYTES, pos + len).toString());
-                }
-                else {
+                } else {
                     throw new Error(`unknown magic:  ${magic.toString()}`);
                 }
                 pos += len;
             }
-            handler({ type: "binary", value });
+            handler({
+                type: "binary",
+                value
+            });
         });
     }
     subscribe(request) {
@@ -126,11 +124,10 @@ class PythLazerClient {
         wsp.sendRequest(request);
     }
     /**
-     * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.
-     * The connections may still try to reconnect in the background. To shut down the pool, call `shutdown()`.
-     * @param handler - Function to be called when all connections are down
-     */
-    addAllConnectionsDownListener(handler) {
+   * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.
+   * The connections may still try to reconnect in the background. To shut down the pool, call `shutdown()`.
+   * @param handler - Function to be called when all connections are down
+   */ addAllConnectionsDownListener(handler) {
         const wsp = this.getWebSocketPool();
         wsp.addAllConnectionsDownListener(handler);
     }
@@ -139,27 +136,25 @@ class PythLazerClient {
         wsp.shutdown();
     }
     /**
-     * Private helper method to make authenticated HTTP requests with Bearer token
-     * @param url - The URL to fetch
-     * @param options - Additional fetch options
-     * @returns Promise resolving to the fetch Response
-     */
-    async authenticatedFetch(url, options = {}) {
+   * Private helper method to make authenticated HTTP requests with Bearer token
+   * @param url - The URL to fetch
+   * @param options - Additional fetch options
+   * @returns Promise resolving to the fetch Response
+   */ async authenticatedFetch(url, options = {}) {
         const headers = {
             Authorization: `Bearer ${this.token}`,
-            ...options.headers,
+            ...options.headers
         };
         return fetch(url, {
             ...options,
-            headers,
+            headers
         });
     }
     /**
-     * Queries the symbols endpoint to get available price feed symbols.
-     * @param params - Optional query parameters to filter symbols
-     * @returns Promise resolving to array of symbol information
-     */
-    async getSymbols(params) {
+   * Queries the symbols endpoint to get available price feed symbols.
+   * @param params - Optional query parameters to filter symbols
+   * @returns Promise resolving to array of symbol information
+   */ async getSymbols(params) {
         const url = new URL(`${this.metadataServiceUrl}/v1/symbols`);
         if (params?.query) {
             url.searchParams.set("query", params.query);
@@ -172,63 +167,63 @@ class PythLazerClient {
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch symbols: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * Queries the latest price endpoint to get current price data.
-     * @param params - Parameters for the latest price request
-     * @returns Promise resolving to JsonUpdate with current price data
-     */
-    async getLatestPrice(params) {
+   * Queries the latest price endpoint to get current price data.
+   * @param params - Parameters for the latest price request
+   * @returns Promise resolving to JsonUpdate with current price data
+   */ async getLatestPrice(params) {
         const url = `${this.priceServiceUrl}/v1/latest_price`;
         try {
             const body = JSON.stringify(params);
-            this.logger.debug("getLatestPrice", { url, body });
+            this.logger.debug("getLatestPrice", {
+                url,
+                body
+            });
             const response = await this.authenticatedFetch(url, {
                 method: "POST",
                 headers: {
-                    "Content-Type": "application/json",
+                    "Content-Type": "application/json"
                 },
-                body: body,
+                body: body
             });
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch latest price: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * Queries the price endpoint to get historical price data at a specific timestamp.
-     * @param params - Parameters for the price request including timestamp
-     * @returns Promise resolving to JsonUpdate with price data at the specified time
-     */
-    async getPrice(params) {
+   * Queries the price endpoint to get historical price data at a specific timestamp.
+   * @param params - Parameters for the price request including timestamp
+   * @returns Promise resolving to JsonUpdate with price data at the specified time
+   */ async getPrice(params) {
         const url = `${this.priceServiceUrl}/v1/price`;
         try {
             const body = JSON.stringify(params);
-            this.logger.debug("getPrice", { url, body });
+            this.logger.debug("getPrice", {
+                url,
+                body
+            });
             const response = await this.authenticatedFetch(url, {
                 method: "POST",
                 headers: {
-                    "Content-Type": "application/json",
+                    "Content-Type": "application/json"
                 },
-                body: body,
+                body: body
             });
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch price: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 }
-exports.PythLazerClient = PythLazerClient;

package/dist/cjs/constants.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_METADATA_SERVICE_URL () {
+        return DEFAULT_METADATA_SERVICE_URL;
+    },
+    get DEFAULT_PRICE_SERVICE_URL () {
+        return DEFAULT_PRICE_SERVICE_URL;
+    },
+    get DEFAULT_STREAM_SERVICE_0_URL () {
+        return DEFAULT_STREAM_SERVICE_0_URL;
+    },
+    get DEFAULT_STREAM_SERVICE_1_URL () {
+        return DEFAULT_STREAM_SERVICE_1_URL;
+    },
+    get SOLANA_LAZER_PROGRAM_ID () {
+        return SOLANA_LAZER_PROGRAM_ID;
+    },
+    get SOLANA_LAZER_STORAGE_ID () {
+        return SOLANA_LAZER_STORAGE_ID;
+    }
+});
+const SOLANA_LAZER_PROGRAM_ID = "pytd2yyk641x7ak7mkaasSJVXh6YYZnC7wTmtgAyxPt";
+const SOLANA_LAZER_STORAGE_ID = "3rdJbqfnagQ4yx9HXJViD4zc4xpiSqmFsKpPuSCQVyQL";
+const DEFAULT_METADATA_SERVICE_URL = "https://history.pyth-lazer.dourolabs.app/history";
+const DEFAULT_PRICE_SERVICE_URL = "https://pyth-lazer-0.dourolabs.app";
+const DEFAULT_STREAM_SERVICE_0_URL = "wss://pyth-lazer-0.dourolabs.app/v1/stream";
+const DEFAULT_STREAM_SERVICE_1_URL = "wss://pyth-lazer-1.dourolabs.app/v1/stream";

package/dist/cjs/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./client.cjs"), exports);
+_export_star(require("./protocol.cjs"), exports);
+_export_star(require("./constants.cjs"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/package.json

@@ -1 +1 @@
-{"type":"commonjs"}
+{ "type": "commonjs" }

package/dist/cjs/protocol.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get BINARY_UPDATE_FORMAT_MAGIC_LE () {
+        return BINARY_UPDATE_FORMAT_MAGIC_LE;
+    },
+    get CustomSocketClosureCodes () {
+        return CustomSocketClosureCodes;
+    },
+    get FORMAT_MAGICS_LE () {
+        return FORMAT_MAGICS_LE;
+    }
+});
+const BINARY_UPDATE_FORMAT_MAGIC_LE = 461_928_307;
+const FORMAT_MAGICS_LE = {
+    JSON: 3_302_625_434,
+    EVM: 2_593_727_018,
+    SOLANA: 2_182_742_457,
+    LE_ECDSA: 1_296_547_300,
+    LE_UNSIGNED: 1_499_680_012
+};
+var CustomSocketClosureCodes = /*#__PURE__*/ function(CustomSocketClosureCodes) {
+    CustomSocketClosureCodes[CustomSocketClosureCodes["CLIENT_TIMEOUT_BUT_RECONNECTING"] = 4000] = "CLIENT_TIMEOUT_BUT_RECONNECTING";
+    return CustomSocketClosureCodes;
+}({});

package/dist/cjs/protocol.d.ts

@@ -1,7 +1,7 @@
 export type Format = "evm" | "solana" | "leEcdsa" | "leUnsigned";
 export type DeliveryFormat = "json" | "binary";
 export type JsonBinaryEncoding = "base64" | "hex";
-export type PriceFeedProperty = "price" | "bestBidPrice" | "bestAskPrice" | "exponent" | "publisherCount" | "confidence";
+export type PriceFeedProperty = "price" | "bestBidPrice" | "bestAskPrice" | "exponent" | "publisherCount" | "confidence" | "fundingRate" | "fundingTimestamp" | "fundingRateInterval";
 export type Channel = "real_time" | "fixed_rate@50ms" | "fixed_rate@200ms";
 export type Request = {
     type: "subscribe";

package/dist/cjs/socket/{resilient-websocket.js → resilient-websocket.cjs}

@@ -1,13 +1,22 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResilientWebSocket = void 0;
-const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
-const ts_log_1 = require("ts-log");
-const protocol_js_1 = require("../protocol.js");
-const env_util_js_1 = require("../util/env-util.js");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ResilientWebSocket", {
+    enumerable: true,
+    get: function() {
+        return ResilientWebSocket;
+    }
+});
+const _isomorphicws = /*#__PURE__*/ _interop_require_default(require("isomorphic-ws"));
+const _tslog = require("ts-log");
+const _protocol = require("../protocol.cjs");
+const _envutil = require("../util/env-util.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 const DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS = 5000; // 5 seconds
 const DEFAULT_MAX_RETRY_DELAY_MS = 1000; // 1 second'
 const DEFAULT_LOG_AFTER_RETRY_COUNT = 10;
@@ -28,7 +37,7 @@ class ResilientWebSocket {
         return this._isReconnecting;
     }
     isConnected() {
-        return this.wsClient?.readyState === isomorphic_ws_1.default.OPEN;
+        return this.wsClient?.readyState === _isomorphicws.default.OPEN;
     }
     shouldLogRetry() {
         return this.wsFailedAttempts % this.logAfterRetryCount === 0;
@@ -36,33 +45,29 @@ class ResilientWebSocket {
     onError;
     onMessage;
     onReconnect;
-    constructor(config) {
+    constructor(config){
         this.endpoint = config.endpoint;
         this.wsOptions = config.wsOptions;
-        this.logger = config.logger ?? ts_log_1.dummyLogger;
-        this.heartbeatTimeoutDurationMs =
-            config.heartbeatTimeoutDurationMs ??
-                DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS;
+        this.logger = config.logger ?? _tslog.dummyLogger;
+        this.heartbeatTimeoutDurationMs = config.heartbeatTimeoutDurationMs ?? DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS;
         this.maxRetryDelayMs = config.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
-        this.logAfterRetryCount =
-            config.logAfterRetryCount ?? DEFAULT_LOG_AFTER_RETRY_COUNT;
+        this.logAfterRetryCount = config.logAfterRetryCount ?? DEFAULT_LOG_AFTER_RETRY_COUNT;
         this.wsFailedAttempts = 0;
-        this.onError = (error) => {
+        this.onError = (error)=>{
             void error;
         };
-        this.onMessage = (data) => {
+        this.onMessage = (data)=>{
             void data;
         };
-        this.onReconnect = () => {
-            // Empty function, can be set by the user.
+        this.onReconnect = ()=>{
+        // Empty function, can be set by the user.
         };
     }
     send(data) {
         this.logger.debug(`Sending message`);
         if (this.isConnected()) {
             this.wsClient.send(data);
-        }
-        else {
+        } else {
             this.logger.warn(`WebSocket to ${this.endpoint} is not connected. Cannot send message.`);
         }
     }
@@ -85,34 +90,33 @@ class ResilientWebSocket {
         // browser constructor supports a different 2nd argument for the constructor,
         // so we need to ensure it's not included if we're running in that environment:
         // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/WebSocket#protocols
-        this.wsClient = new isomorphic_ws_1.default(this.endpoint, (0, env_util_js_1.envIsBrowserOrWorker)() ? undefined : this.wsOptions);
-        this.wsClient.addEventListener("open", () => {
+        this.wsClient = new _isomorphicws.default(this.endpoint, (0, _envutil.envIsBrowserOrWorker)() ? undefined : this.wsOptions);
+        this.wsClient.addEventListener("open", ()=>{
             this.logger.info("WebSocket connection established");
             this.wsFailedAttempts = 0;
             this._isReconnecting = false;
             this.resetHeartbeat();
             this.onReconnect();
         });
-        this.wsClient.addEventListener("close", (e) => {
+        this.wsClient.addEventListener("close", (e)=>{
             if (this.wsUserClosed) {
                 this.logger.info(`WebSocket connection to ${this.endpoint} closed by user`);
-            }
-            else {
+            } else {
                 if (this.shouldLogRetry()) {
                     this.logger.warn(`WebSocket connection to ${this.endpoint} closed unexpectedly: Code: ${e.code.toString()}`);
                 }
                 this.handleReconnect();
             }
         });
-        this.wsClient.addEventListener("error", (event) => {
+        this.wsClient.addEventListener("error", (event)=>{
             this.onError(event);
         });
-        this.wsClient.addEventListener("message", (event) => {
+        this.wsClient.addEventListener("message", (event)=>{
             this.resetHeartbeat();
             this.onMessage(event.data);
         });
         if ("on" in this.wsClient) {
-            this.wsClient.on("ping", () => {
+            this.wsClient.on("ping", ()=>{
                 this.logger.info("Ping received");
                 this.resetHeartbeat();
             });
@@ -122,18 +126,17 @@ class ResilientWebSocket {
         if (this.heartbeatTimeout !== undefined) {
             clearTimeout(this.heartbeatTimeout);
         }
-        this.heartbeatTimeout = setTimeout(() => {
+        this.heartbeatTimeout = setTimeout(()=>{
             const warnMsg = "Connection timed out. Reconnecting...";
             this.logger.warn(warnMsg);
             if (this.wsClient) {
                 if (typeof this.wsClient.terminate === "function") {
                     this.wsClient.terminate();
-                }
-                else {
+                } else {
                     // terminate is an implementation detail of the node-friendly
                     // https://www.npmjs.com/package/ws package, but is not a native WebSocket API,
                     // so we have to use the close method
-                    this.wsClient.close(protocol_js_1.CustomSocketClosureCodes.CLIENT_TIMEOUT_BUT_RECONNECTING, warnMsg);
+                    this.wsClient.close(_protocol.CustomSocketClosureCodes.CLIENT_TIMEOUT_BUT_RECONNECTING, warnMsg);
                 }
             }
             this.handleReconnect();
@@ -154,11 +157,9 @@ class ResilientWebSocket {
         this.wsClient = undefined;
         this._isReconnecting = true;
         if (this.shouldLogRetry()) {
-            this.logger.error("Connection closed unexpectedly or because of timeout. Reconnecting after " +
-                String(this.retryDelayMs()) +
-                "ms.");
+            this.logger.error("Connection closed unexpectedly or because of timeout. Reconnecting after " + String(this.retryDelayMs()) + "ms.");
         }
-        this.retryTimeout = setTimeout(() => {
+        this.retryTimeout = setTimeout(()=>{
             this.startWebSocket();
         }, this.retryDelayMs());
     }
@@ -170,18 +171,16 @@ class ResilientWebSocket {
         this.wsUserClosed = true;
     }
     /**
-     * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.
-     *
-     * The delay increases exponentially with each attempt, starting at 20ms for the first attempt,
-     * and is capped at maxRetryDelayMs for attempts greater than or equal to 10.
-     *
-     * @returns The calculated delay in milliseconds before the next retry.
-     */
-    retryDelayMs() {
+   * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.
+   *
+   * The delay increases exponentially with each attempt, starting at 20ms for the first attempt,
+   * and is capped at maxRetryDelayMs for attempts greater than or equal to 10.
+   *
+   * @returns The calculated delay in milliseconds before the next retry.
+   */ retryDelayMs() {
         if (this.wsFailedAttempts >= 10) {
             return this.maxRetryDelayMs;
         }
         return Math.min(2 ** this.wsFailedAttempts * 10, this.maxRetryDelayMs);
     }
 }
-exports.ResilientWebSocket = ResilientWebSocket;