@pythnetwork/pyth-lazer-sdk 4.0.0 → 5.2.0

package/README.md

@@ -3,3 +3,60 @@
 ## Contributing & Development
 
 See [contributing.md](docs/contributing/contributing.md) for information on how to develop or contribute to this project!
+
+## How to use
+
+```javascript
+import { PythLazerClient } from "@pythnetwork/pyth-lazer-sdk";
+
+const c = await PythLazerClient.create({
+  token: "YOUR-AUTH-TOKEN-HERE",
+  logger: console, // Optionally log operations (to the console in this case.)
+  webSocketPoolConfig: {
+    numConnections: 4, // Optionally specify number of parallel redundant connections to reduce the chance of dropped messages. The connections will round-robin across the provided URLs. Default is 4.
+    onError: (error) => {
+      console.error("⛔️ WebSocket error:", error.message);
+    },
+    // Optional configuration for resilient WebSocket connections
+    rwsConfig: {
+      heartbeatTimeoutDurationMs: 5000, // Optional heartbeat timeout duration in milliseconds
+      maxRetryDelayMs: 1000, // Optional maximum retry delay in milliseconds
+      logAfterRetryCount: 10, // Optional log after how many retries
+    },
+  },
+});
+
+c.addMessageListener((message) => {
+  console.info("received the following from the Lazer stream:", message);
+});
+
+// Monitor for all connections in the pool being down simultaneously (e.g. if the internet goes down)
+// The connections may still try to reconnect in the background. To shut down the client completely, call shutdown().
+c.addAllConnectionsDownListener(() => {
+  console.error("All connections are down!");
+});
+
+// Create and remove one or more subscriptions on the fly
+c.subscribe({
+  type: "subscribe",
+  subscriptionId: 1,
+  priceFeedIds: [1, 2],
+  properties: ["price"],
+  formats: ["solana"],
+  deliveryFormat: "binary",
+  channel: "fixed_rate@200ms",
+  parsed: false,
+  jsonBinaryEncoding: "base64",
+});
+c.subscribe({
+  type: "subscribe",
+  subscriptionId: 2,
+  priceFeedIds: [1, 2, 3, 4, 5],
+  properties: ["price", "exponent", "publisherCount", "confidence"],
+  formats: ["evm"],
+  deliveryFormat: "json",
+  channel: "fixed_rate@200ms",
+  parsed: true,
+  jsonBinaryEncoding: "hex",
+});
+```

package/dist/cjs/client.cjs

@@ -0,0 +1,229 @@
+"use strict";
+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;
+class PythLazerClient {
+    token;
+    metadataServiceUrl;
+    priceServiceUrl;
+    logger;
+    wsp;
+    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp){
+        this.token = token;
+        this.metadataServiceUrl = metadataServiceUrl;
+        this.priceServiceUrl = priceServiceUrl;
+        this.logger = logger;
+        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() {
+        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) {
+        const token = config.token;
+        // Collect and remove trailing slash from URLs
+        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 _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) {
+        const wsp = this.getWebSocketPool();
+        wsp.addMessageListener(async (data)=>{
+            if (typeof data == "string") {
+                handler({
+                    type: "json",
+                    value: JSON.parse(data)
+                });
+                return;
+            }
+            const buffData = await (0, _bufferutil.bufferFromWebsocketData)(data);
+            let pos = 0;
+            const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
+            pos += UINT32_NUM_BYTES;
+            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();
+                pos += UINT16_NUM_BYTES;
+                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.FORMAT_MAGICS_LE.SOLANA) {
+                    value.solana = buffData.subarray(pos, pos + len);
+                } else if (magic == _protocol.FORMAT_MAGICS_LE.LE_ECDSA) {
+                    value.leEcdsa = buffData.subarray(pos, pos + len);
+                } else if (magic == _protocol.FORMAT_MAGICS_LE.LE_UNSIGNED) {
+                    value.leUnsigned = buffData.subarray(pos, pos + len);
+                } else if (magic == _protocol.FORMAT_MAGICS_LE.JSON) {
+                    value.parsed = JSON.parse(buffData.subarray(pos + UINT32_NUM_BYTES, pos + len).toString());
+                } else {
+                    throw new Error(`unknown magic:  ${magic.toString()}`);
+                }
+                pos += len;
+            }
+            handler({
+                type: "binary",
+                value
+            });
+        });
+    }
+    subscribe(request) {
+        const wsp = this.getWebSocketPool();
+        if (request.type !== "subscribe") {
+            throw new Error("Request must be a subscribe request");
+        }
+        wsp.addSubscription(request);
+    }
+    unsubscribe(subscriptionId) {
+        const wsp = this.getWebSocketPool();
+        wsp.removeSubscription(subscriptionId);
+    }
+    send(request) {
+        const wsp = this.getWebSocketPool();
+        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) {
+        const wsp = this.getWebSocketPool();
+        wsp.addAllConnectionsDownListener(handler);
+    }
+    shutdown() {
+        const wsp = this.getWebSocketPool();
+        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 = {}) {
+        const headers = {
+            Authorization: `Bearer ${this.token}`,
+            ...options.headers
+        };
+        return fetch(url, {
+            ...options,
+            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) {
+        const url = new URL(`${this.metadataServiceUrl}/v1/symbols`);
+        if (params?.query) {
+            url.searchParams.set("query", params.query);
+        }
+        if (params?.asset_type) {
+            url.searchParams.set("asset_type", params.asset_type);
+        }
+        try {
+            const response = await this.authenticatedFetch(url.toString());
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
+            }
+            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) {
+        const url = `${this.priceServiceUrl}/v1/latest_price`;
+        try {
+            const body = JSON.stringify(params);
+            this.logger.debug("getLatestPrice", {
+                url,
+                body
+            });
+            const response = await this.authenticatedFetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: body
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
+            }
+            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) {
+        const url = `${this.priceServiceUrl}/v1/price`;
+        try {
+            const body = JSON.stringify(params);
+            this.logger.debug("getPrice", {
+                url,
+                body
+            });
+            const response = await this.authenticatedFetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: body
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
+            }
+            return await response.json();
+        } catch (error) {
+            throw new Error(`Failed to fetch price: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

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";
@@ -122,3 +122,6 @@ export type JsonUpdate = {
     leEcdsa?: JsonBinaryData;
     leUnsigned?: JsonBinaryData;
 };
+export declare enum CustomSocketClosureCodes {
+    CLIENT_TIMEOUT_BUT_RECONNECTING = 4000
+}

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

@@ -1,11 +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");
+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;
@@ -26,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;
@@ -34,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.`);
         }
     }
@@ -80,34 +87,36 @@ class ResilientWebSocket {
             clearTimeout(this.retryTimeout);
             this.retryTimeout = undefined;
         }
-        this.wsClient = new isomorphic_ws_1.default(this.endpoint, this.wsOptions);
-        this.wsClient.addEventListener("open", () => {
+        // 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 _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();
             });
@@ -117,9 +126,19 @@ class ResilientWebSocket {
         if (this.heartbeatTimeout !== undefined) {
             clearTimeout(this.heartbeatTimeout);
         }
-        this.heartbeatTimeout = setTimeout(() => {
-            this.logger.warn("Connection timed out. Reconnecting...");
-            this.wsClient?.terminate();
+        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 {
+                    // 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.CustomSocketClosureCodes.CLIENT_TIMEOUT_BUT_RECONNECTING, warnMsg);
+                }
+            }
             this.handleReconnect();
         }, this.heartbeatTimeoutDurationMs);
     }
@@ -138,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());
     }
@@ -154,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;

package/dist/cjs/socket/resilient-websocket.d.ts

@@ -10,6 +10,19 @@ export type ResilientWebSocketConfig = {
     maxRetryDelayMs?: number;
     logAfterRetryCount?: number;
 };
+/**
+ * the isomorphic-ws package ships with some slightly-erroneous typings.
+ * namely, it returns a WebSocket with typings that indicate the "terminate()" function
+ * is available on all platforms.
+ * Given that, under the hood, it is using the globalThis.WebSocket class, if it's available,
+ * and falling back to using the https://www.npmjs.com/package/ws package, this
+ * means there are API differences between the native WebSocket (the one in a web browser)
+ * and the server-side version from the "ws" package.
+ *
+ * This type creates a WebSocket type reference we use to indicate the unknown
+ * nature of the env in which is code is run.
+ */
+type UnsafeWebSocket = Omit<WebSocket, "terminate"> & Partial<Pick<WebSocket, "terminate">>;
 export declare class ResilientWebSocket {
     private endpoint;
     private wsOptions?;
@@ -17,7 +30,7 @@ export declare class ResilientWebSocket {
     private heartbeatTimeoutDurationMs;
     private maxRetryDelayMs;
     private logAfterRetryCount;
-    wsClient: undefined | WebSocket;
+    wsClient: UnsafeWebSocket | undefined;
     wsUserClosed: boolean;
     private wsFailedAttempts;
     private heartbeatTimeout?;
@@ -47,3 +60,4 @@ export declare class ResilientWebSocket {
      */
     private retryDelayMs;
 }
+export {};