@pythnetwork/price-service-client 1.9.1 → 1.11.0

package/dist/cjs/PriceServiceConnection.cjs

@@ -0,0 +1,322 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable unicorn/no-process-exit */ /* eslint-disable n/no-process-exit */ /* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable @typescript-eslint/no-unnecessary-condition */ /* eslint-disable @typescript-eslint/no-base-to-string */ /* eslint-disable @typescript-eslint/no-floating-promises */ /* eslint-disable @typescript-eslint/no-empty-function */ /* eslint-disable no-console */ /* eslint-disable @typescript-eslint/prefer-nullish-coalescing */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PriceServiceConnection", {
+    enumerable: true,
+    get: function() {
+        return PriceServiceConnection;
+    }
+});
+const _priceservicesdk = require("@pythnetwork/price-service-sdk");
+const _axios = /*#__PURE__*/ _interop_require_default(require("axios"));
+const _axiosretry = /*#__PURE__*/ _interop_require_default(require("axios-retry"));
+const _ResillientWebSocket = require("./ResillientWebSocket.cjs");
+const _utils = require("./utils.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class PriceServiceConnection {
+    httpClient;
+    priceFeedCallbacks;
+    wsClient;
+    wsEndpoint;
+    logger;
+    priceFeedRequestConfig;
+    accessToken;
+    /**
+   * Custom handler for web socket errors (connection and message parsing).
+   *
+   * Default handler only logs the errors.
+   */ onWsError;
+    /**
+   * Constructs a new Connection.
+   *
+   * @param endpoint - endpoint URL to the price service. Example: https://website/example/
+   * @param config - Optional PriceServiceConnectionConfig for custom configurations.
+   */ constructor(endpoint, config){
+        this.accessToken = config?.accessToken;
+        this.httpClient = _axios.default.create({
+            baseURL: endpoint,
+            timeout: config?.timeout || 5000,
+            headers: this.accessToken === undefined ? {} : {
+                Authorization: `Bearer ${this.accessToken}`
+            }
+        });
+        (0, _axiosretry.default)(this.httpClient, {
+            retries: config?.httpRetries || 3,
+            // eslint-disable-next-line import/no-named-as-default-member
+            retryDelay: _axiosretry.default.exponentialDelay.bind(_axiosretry.default)
+        });
+        this.priceFeedRequestConfig = {
+            binary: config?.priceFeedRequestConfig?.binary,
+            verbose: config?.priceFeedRequestConfig?.verbose ?? config?.verbose,
+            allowOutOfOrder: config?.priceFeedRequestConfig?.allowOutOfOrder
+        };
+        this.priceFeedCallbacks = new Map();
+        // Default logger is console for only warnings and errors.
+        this.logger = config?.logger || {
+            trace: ()=>{},
+            debug: ()=>{},
+            info: ()=>{},
+            warn: console.warn,
+            error: console.error
+        };
+        this.onWsError = (error)=>{
+            this.logger.error(error);
+            // Exit the process if it is running in node.
+            if (typeof process !== "undefined" && typeof process.exit === "function") {
+                this.logger.error("Halting the process due to the websocket error");
+                process.exit(1);
+            } else {
+                this.logger.error("Cannot halt process. Please handle the websocket error.");
+            }
+        };
+        this.wsEndpoint = (0, _utils.makeWebsocketUrl)(endpoint);
+        // Append access token as query param for WebSocket connections
+        // since browser WebSocket API does not support custom headers.
+        if (this.accessToken && this.wsEndpoint) {
+            const wsUrl = new URL(this.wsEndpoint);
+            wsUrl.searchParams.append("ACCESS_TOKEN", this.accessToken);
+            this.wsEndpoint = wsUrl.toString();
+        }
+    }
+    /**
+   * Fetch Latest PriceFeeds of given price ids.
+   * This will throw an axios error if there is a network problem or the price service returns a non-ok response (e.g: Invalid price ids)
+   *
+   * @param priceIds - Array of hex-encoded price ids.
+   * @returns Array of PriceFeeds
+   */ async getLatestPriceFeeds(priceIds) {
+        if (priceIds.length === 0) {
+            return [];
+        }
+        const response = await this.httpClient.get("/api/latest_price_feeds", {
+            params: {
+                ids: priceIds,
+                verbose: this.priceFeedRequestConfig.verbose,
+                binary: this.priceFeedRequestConfig.binary
+            }
+        });
+        const priceFeedsJson = response.data;
+        return priceFeedsJson.map((priceFeedJson)=>_priceservicesdk.PriceFeed.fromJson(priceFeedJson));
+    }
+    /**
+   * Fetch latest VAA of given price ids.
+   * This will throw an axios error if there is a network problem or the price service returns a non-ok response (e.g: Invalid price ids)
+   *
+   * This function is coupled to wormhole implemntation.
+   *
+   * @param priceIds - Array of hex-encoded price ids.
+   * @returns Array of base64 encoded VAAs.
+   */ async getLatestVaas(priceIds) {
+        const response = await this.httpClient.get("/api/latest_vaas", {
+            params: {
+                ids: priceIds
+            }
+        });
+        return response.data;
+    }
+    /**
+   * Fetch the earliest VAA of the given price id that is published since the given publish time.
+   * This will throw an error if the given publish time is in the future, or if the publish time
+   * is old and the price service endpoint does not have a db backend for historical requests.
+   * This will throw an axios error if there is a network problem or the price service returns a non-ok response (e.g: Invalid price id)
+   *
+   * This function is coupled to wormhole implemntation.
+   *
+   * @param priceId - Hex-encoded price id.
+   * @param publishTime - Epoch timestamp in seconds.
+   * @returns Tuple of VAA and publishTime.
+   */ async getVaa(priceId, publishTime) {
+        const response = await this.httpClient.get("/api/get_vaa", {
+            params: {
+                id: priceId,
+                publish_time: publishTime
+            }
+        });
+        return [
+            response.data.vaa,
+            response.data.publishTime
+        ];
+    }
+    /**
+   * Fetch the PriceFeed of the given price id that is published since the given publish time.
+   * This will throw an error if the given publish time is in the future, or if the publish time
+   * is old and the price service endpoint does not have a db backend for historical requests.
+   * This will throw an axios error if there is a network problem or the price service returns a non-ok response (e.g: Invalid price id)
+   *
+   * @param priceId - Hex-encoded price id.
+   * @param publishTime - Epoch timestamp in seconds.
+   * @returns PriceFeed
+   */ async getPriceFeed(priceId, publishTime) {
+        const response = await this.httpClient.get("/api/get_price_feed", {
+            params: {
+                id: priceId,
+                publish_time: publishTime,
+                verbose: this.priceFeedRequestConfig.verbose,
+                binary: this.priceFeedRequestConfig.binary
+            }
+        });
+        return _priceservicesdk.PriceFeed.fromJson(response.data);
+    }
+    /**
+   * Fetch the list of available price feed ids.
+   * This will throw an axios error if there is a network problem or the price service returns a non-ok response.
+   *
+   * @returns Array of hex-encoded price ids.
+   */ async getPriceFeedIds() {
+        const response = await this.httpClient.get("/api/price_feed_ids");
+        return response.data;
+    }
+    /**
+   * Subscribe to updates for given price ids.
+   *
+   * It will start a websocket connection if it's not started yet.
+   * Also, it won't throw any exception if given price ids are invalid or connection errors. Instead,
+   * it calls `connection.onWsError`. If you want to handle the errors you should set the
+   * `onWsError` function to your custom error handler.
+   *
+   * @param priceIds - Array of hex-encoded price ids.
+   * @param cb - Callback function that is called with a PriceFeed upon updates to given price ids.
+   */ async subscribePriceFeedUpdates(priceIds, cb) {
+        if (this.wsClient === undefined) {
+            await this.startWebSocket();
+        }
+        priceIds = priceIds.map((priceId)=>(0, _utils.removeLeading0xIfExists)(priceId));
+        const newPriceIds = [];
+        for (const id of priceIds){
+            if (!this.priceFeedCallbacks.has(id)) {
+                this.priceFeedCallbacks.set(id, new Set());
+                newPriceIds.push(id);
+            }
+            this.priceFeedCallbacks.get(id).add(cb);
+        }
+        const message = {
+            ids: newPriceIds,
+            type: "subscribe",
+            verbose: this.priceFeedRequestConfig.verbose,
+            binary: this.priceFeedRequestConfig.binary,
+            allow_out_of_order: this.priceFeedRequestConfig.allowOutOfOrder
+        };
+        await this.wsClient?.send(JSON.stringify(message));
+    }
+    /**
+   * Unsubscribe from updates for given price ids.
+   *
+   * It will close the websocket connection if it's not subscribed to any price feed updates anymore.
+   * Also, it won't throw any exception if given price ids are invalid or connection errors. Instead,
+   * it calls `connection.onWsError`. If you want to handle the errors you should set the
+   * `onWsError` function to your custom error handler.
+   *
+   * @param priceIds - Array of hex-encoded price ids.
+   * @param cb - Optional callback, if set it will only unsubscribe this callback from updates for given price ids.
+   */ async unsubscribePriceFeedUpdates(priceIds, cb) {
+        if (this.wsClient === undefined) {
+            await this.startWebSocket();
+        }
+        priceIds = priceIds.map((priceId)=>(0, _utils.removeLeading0xIfExists)(priceId));
+        const removedPriceIds = [];
+        for (const id of priceIds){
+            if (this.priceFeedCallbacks.has(id)) {
+                let idRemoved = false;
+                if (cb === undefined) {
+                    this.priceFeedCallbacks.delete(id);
+                    idRemoved = true;
+                } else {
+                    this.priceFeedCallbacks.get(id).delete(cb);
+                    if (this.priceFeedCallbacks.get(id).size === 0) {
+                        this.priceFeedCallbacks.delete(id);
+                        idRemoved = true;
+                    }
+                }
+                if (idRemoved) {
+                    removedPriceIds.push(id);
+                }
+            }
+        }
+        const message = {
+            ids: removedPriceIds,
+            type: "unsubscribe"
+        };
+        await this.wsClient?.send(JSON.stringify(message));
+        if (this.priceFeedCallbacks.size === 0) {
+            this.closeWebSocket();
+        }
+    }
+    /**
+   * Starts connection websocket.
+   *
+   * This function is called automatically upon subscribing to price feed updates.
+   */ async startWebSocket() {
+        if (this.wsEndpoint === undefined) {
+            throw new Error("Websocket endpoint is undefined.");
+        }
+        this.wsClient = new _ResillientWebSocket.ResilientWebSocket(this.wsEndpoint, this.logger);
+        this.wsClient.onError = this.onWsError;
+        this.wsClient.onReconnect = ()=>{
+            if (this.priceFeedCallbacks.size > 0) {
+                const message = {
+                    ids: [
+                        ...this.priceFeedCallbacks.keys()
+                    ],
+                    type: "subscribe",
+                    verbose: this.priceFeedRequestConfig.verbose,
+                    binary: this.priceFeedRequestConfig.binary,
+                    allow_out_of_order: this.priceFeedRequestConfig.allowOutOfOrder
+                };
+                this.logger.info("Resubscribing to existing price feeds.");
+                this.wsClient?.send(JSON.stringify(message));
+            }
+        };
+        this.wsClient.onMessage = (data)=>{
+            this.logger.info(`Received message ${data.toString()}`);
+            let message;
+            try {
+                message = JSON.parse(data.toString());
+            } catch (error) {
+                this.logger.error(`Error parsing message ${data.toString()} as JSON.`);
+                this.logger.error(error);
+                this.onWsError(error);
+                return;
+            }
+            if (message.type === "response") {
+                if (message.status === "error") {
+                    this.logger.error(`Error response from the websocket server ${message.error}.`);
+                    this.onWsError(new Error(message.error));
+                }
+            } else if (message.type === "price_update") {
+                let priceFeed;
+                try {
+                    priceFeed = _priceservicesdk.PriceFeed.fromJson(message.price_feed);
+                } catch (error) {
+                    this.logger.error(`Error parsing price feeds from message ${data.toString()}.`);
+                    this.logger.error(error);
+                    this.onWsError(error);
+                    return;
+                }
+                if (this.priceFeedCallbacks.has(priceFeed.id)) {
+                    for (const cb of this.priceFeedCallbacks.get(priceFeed.id)){
+                        cb(priceFeed);
+                    }
+                }
+            } else {
+                this.logger.warn(`Ignoring unsupported server response ${data.toString()}.`);
+            }
+        };
+        await this.wsClient.startWebSocket();
+    }
+    /**
+   * Closes connection websocket.
+   *
+   * At termination, the websocket should be closed to finish the
+   * process elegantly. It will automatically close when the connection
+   * is subscribed to no price feeds.
+   */ closeWebSocket() {
+        this.wsClient?.closeWebSocket();
+        this.wsClient = undefined;
+        this.priceFeedCallbacks.clear();
+    }
+}

package/{lib → dist/cjs}/PriceServiceConnection.d.ts

@@ -1,23 +1,31 @@
-import { HexString, PriceFeed } from "@pythnetwork/price-service-sdk";
-import { Logger } from "ts-log";
+import type { HexString } from "@pythnetwork/price-service-sdk";
+import { PriceFeed } from "@pythnetwork/price-service-sdk";
+import type { Logger } from "ts-log";
 export type DurationInMs = number;
 export type PriceFeedRequestConfig = {
-    verbose?: boolean;
-    binary?: boolean;
-    allowOutOfOrder?: boolean;
+    verbose?: boolean | undefined;
+    binary?: boolean | undefined;
+    allowOutOfOrder?: boolean | undefined;
 };
 export type PriceServiceConnectionConfig = {
-    timeout?: DurationInMs;
+    timeout?: DurationInMs | undefined;
     /**
      * Number of times a HTTP request will be retried before the API returns a failure. Default: 3.
      *
      * The connection uses exponential back-off for the delay between retries. However,
      * it will timeout regardless of the retries at the configured `timeout` time.
      */
-    httpRetries?: number;
-    logger?: Logger;
-    verbose?: boolean;
-    priceFeedRequestConfig?: PriceFeedRequestConfig;
+    httpRetries?: number | undefined;
+    logger?: Logger | undefined;
+    verbose?: boolean | undefined;
+    priceFeedRequestConfig?: PriceFeedRequestConfig | undefined;
+    /**
+     * Optional API access token for authentication.
+     * When provided, this token will be included in all requests either:
+     * - As a Bearer token in the Authorization header (for HTTP requests)
+     * - As an ACCESS_TOKEN query parameter (for WebSocket connections)
+     */
+    accessToken?: string | undefined;
 };
 export type PriceFeedUpdateCallback = (priceFeed: PriceFeed) => void;
 export declare class PriceServiceConnection {
@@ -27,6 +35,7 @@ export declare class PriceServiceConnection {
     private wsEndpoint;
     private logger;
     private priceFeedRequestConfig;
+    private accessToken;
     /**
      * Custom handler for web socket errors (connection and message parsing).
      *
@@ -36,15 +45,15 @@ export declare class PriceServiceConnection {
     /**
      * Constructs a new Connection.
      *
-     * @param endpoint endpoint URL to the price service. Example: https://website/example/
-     * @param config Optional PriceServiceConnectionConfig for custom configurations.
+     * @param endpoint - endpoint URL to the price service. Example: https://website/example/
+     * @param config - Optional PriceServiceConnectionConfig for custom configurations.
      */
     constructor(endpoint: string, config?: PriceServiceConnectionConfig);
     /**
      * Fetch Latest PriceFeeds of given price ids.
      * This will throw an axios error if there is a network problem or the price service returns a non-ok response (e.g: Invalid price ids)
      *
-     * @param priceIds Array of hex-encoded price ids.
+     * @param priceIds - Array of hex-encoded price ids.
      * @returns Array of PriceFeeds
      */
     getLatestPriceFeeds(priceIds: HexString[]): Promise<PriceFeed[] | undefined>;
@@ -54,7 +63,7 @@ export declare class PriceServiceConnection {
      *
      * This function is coupled to wormhole implemntation.
      *
-     * @param priceIds Array of hex-encoded price ids.
+     * @param priceIds - Array of hex-encoded price ids.
      * @returns Array of base64 encoded VAAs.
      */
     getLatestVaas(priceIds: HexString[]): Promise<string[]>;
@@ -66,8 +75,8 @@ export declare class PriceServiceConnection {
      *
      * This function is coupled to wormhole implemntation.
      *
-     * @param priceId Hex-encoded price id.
-     * @param publishTime Epoch timestamp in seconds.
+     * @param priceId - Hex-encoded price id.
+     * @param publishTime - Epoch timestamp in seconds.
      * @returns Tuple of VAA and publishTime.
      */
     getVaa(priceId: HexString, publishTime: EpochTimeStamp): Promise<[string, EpochTimeStamp]>;
@@ -77,8 +86,8 @@ export declare class PriceServiceConnection {
      * is old and the price service endpoint does not have a db backend for historical requests.
      * This will throw an axios error if there is a network problem or the price service returns a non-ok response (e.g: Invalid price id)
      *
-     * @param priceId Hex-encoded price id.
-     * @param publishTime Epoch timestamp in seconds.
+     * @param priceId - Hex-encoded price id.
+     * @param publishTime - Epoch timestamp in seconds.
      * @returns PriceFeed
      */
     getPriceFeed(priceId: HexString, publishTime: EpochTimeStamp): Promise<PriceFeed>;
@@ -97,8 +106,8 @@ export declare class PriceServiceConnection {
      * it calls `connection.onWsError`. If you want to handle the errors you should set the
      * `onWsError` function to your custom error handler.
      *
-     * @param priceIds Array of hex-encoded price ids.
-     * @param cb Callback function that is called with a PriceFeed upon updates to given price ids.
+     * @param priceIds - Array of hex-encoded price ids.
+     * @param cb - Callback function that is called with a PriceFeed upon updates to given price ids.
      */
     subscribePriceFeedUpdates(priceIds: HexString[], cb: PriceFeedUpdateCallback): Promise<void>;
     /**
@@ -109,8 +118,8 @@ export declare class PriceServiceConnection {
      * it calls `connection.onWsError`. If you want to handle the errors you should set the
      * `onWsError` function to your custom error handler.
      *
-     * @param priceIds Array of hex-encoded price ids.
-     * @param cb Optional callback, if set it will only unsubscribe this callback from updates for given price ids.
+     * @param priceIds - Array of hex-encoded price ids.
+     * @param cb - Optional callback, if set it will only unsubscribe this callback from updates for given price ids.
      */
     unsubscribePriceFeedUpdates(priceIds: HexString[], cb?: PriceFeedUpdateCallback): Promise<void>;
     /**
@@ -128,4 +137,3 @@ export declare class PriceServiceConnection {
      */
     closeWebSocket(): void;
 }
-//# sourceMappingURL=PriceServiceConnection.d.ts.map

package/dist/cjs/ResillientWebSocket.cjs

@@ -0,0 +1,144 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */ /* eslint-disable @typescript-eslint/no-misused-promises */ /* eslint-disable @typescript-eslint/no-unsafe-argument */ /* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable @typescript-eslint/no-unnecessary-condition */ /* eslint-disable unicorn/prefer-add-event-listener */ /* eslint-disable @typescript-eslint/require-await */ /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable @typescript-eslint/no-empty-function */ "use strict";
+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"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const PING_TIMEOUT_DURATION = 30_000 + 3000; // It is 30s on the server and 3s is added for delays
+class ResilientWebSocket {
+    endpoint;
+    wsClient;
+    wsUserClosed;
+    wsFailedAttempts;
+    pingTimeout;
+    logger;
+    onError;
+    onMessage;
+    onReconnect;
+    constructor(endpoint, logger){
+        this.endpoint = endpoint;
+        this.logger = logger;
+        this.wsFailedAttempts = 0;
+        this.onError = (error)=>{
+            this.logger?.error(error);
+        };
+        this.wsUserClosed = true;
+        this.onMessage = ()=>{};
+        this.onReconnect = ()=>{};
+    }
+    async send(data) {
+        this.logger?.info(`Sending ${data}`);
+        await this.waitForMaybeReadyWebSocket();
+        if (this.wsClient === undefined) {
+            this.logger?.error("Couldn't connect to the websocket server. Error callback is called.");
+        } else {
+            this.wsClient.send(data);
+        }
+    }
+    async startWebSocket() {
+        if (this.wsClient !== undefined) {
+            return;
+        }
+        this.logger?.info(`Creating Web Socket client`);
+        this.wsClient = new _isomorphicws.default(this.endpoint);
+        this.wsUserClosed = false;
+        this.wsClient.addEventListener("open", ()=>{
+            this.wsFailedAttempts = 0;
+            // Ping handler is undefined in browser side so heartbeat is disabled.
+            if (this.wsClient.on !== undefined) {
+                this.heartbeat();
+            }
+        });
+        this.wsClient.onerror = (event)=>{
+            this.onError(event.error);
+        };
+        this.wsClient.onmessage = (event)=>{
+            this.onMessage(event.data);
+        };
+        this.wsClient.addEventListener("close", async ()=>{
+            if (this.pingTimeout !== undefined) {
+                clearInterval(this.pingTimeout);
+            }
+            if (this.wsUserClosed) {
+                this.logger?.info("The connection has been closed successfully.");
+            } else {
+                this.wsFailedAttempts += 1;
+                this.wsClient = undefined;
+                const waitTime = expoBackoff(this.wsFailedAttempts);
+                this.logger?.error(`Connection closed unexpectedly or because of timeout. Reconnecting after ${waitTime}ms.`);
+                await sleep(waitTime);
+                this.restartUnexpectedClosedWebsocket();
+            }
+        });
+        if (this.wsClient.on !== undefined) {
+            // Ping handler is undefined in browser side
+            this.wsClient.on("ping", this.heartbeat.bind(this));
+        }
+    }
+    /**
+   * Heartbeat is only enabled in node clients because they support handling
+   * ping-pong events.
+   *
+   * This approach only works when server constantly pings the clients which.
+   * Otherwise you might consider sending ping and acting on pong responses
+   * yourself.
+   */ heartbeat() {
+        this.logger?.info("Heartbeat");
+        if (this.pingTimeout !== undefined) {
+            clearTimeout(this.pingTimeout);
+        }
+        this.pingTimeout = setTimeout(()=>{
+            this.logger?.warn(`Connection timed out. Reconnecting...`);
+            this.wsClient?.terminate();
+            this.restartUnexpectedClosedWebsocket();
+        }, PING_TIMEOUT_DURATION);
+    }
+    async waitForMaybeReadyWebSocket() {
+        let waitedTime = 0;
+        while(this.wsClient !== undefined && this.wsClient.readyState !== this.wsClient.OPEN){
+            if (waitedTime > 5000) {
+                this.wsClient.close();
+                return;
+            } else {
+                waitedTime += 10;
+                await sleep(10);
+            }
+        }
+    }
+    async restartUnexpectedClosedWebsocket() {
+        if (this.wsUserClosed) {
+            return;
+        }
+        await this.startWebSocket();
+        await this.waitForMaybeReadyWebSocket();
+        if (this.wsClient === undefined) {
+            this.logger?.error("Couldn't reconnect to websocket. Error callback is called.");
+            return;
+        }
+        this.onReconnect();
+    }
+    closeWebSocket() {
+        if (this.wsClient !== undefined) {
+            const client = this.wsClient;
+            this.wsClient = undefined;
+            client.close();
+        }
+        this.wsUserClosed = true;
+    }
+}
+async function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+function expoBackoff(attempts) {
+    return 2 ** attempts * 100;
+}

package/{lib → dist/cjs}/ResillientWebSocket.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="ws" />
 import WebSocket from "isomorphic-ws";
-import { Logger } from "ts-log";
+import type { Logger } from "ts-log";
 /**
  * This class wraps websocket to provide a resilient web socket client.
  *
@@ -22,7 +21,7 @@ export declare class ResilientWebSocket {
     onMessage: (data: WebSocket.Data) => void;
     onReconnect: () => void;
     constructor(endpoint: string, logger?: Logger);
-    send(data: any): Promise<void>;
+    send(data: unknown): Promise<void>;
     startWebSocket(): Promise<void>;
     /**
      * Heartbeat is only enabled in node clients because they support handling
@@ -37,4 +36,3 @@ export declare class ResilientWebSocket {
     private restartUnexpectedClosedWebsocket;
     closeWebSocket(): void;
 }
-//# sourceMappingURL=ResillientWebSocket.d.ts.map

package/dist/cjs/index.cjs

@@ -0,0 +1,32 @@
+"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 Price () {
+        return _priceservicesdk.Price;
+    },
+    get PriceFeed () {
+        return _priceservicesdk.PriceFeed;
+    },
+    get PriceFeedMetadata () {
+        return _priceservicesdk.PriceFeedMetadata;
+    },
+    get PriceServiceConnection () {
+        return _PriceServiceConnection.PriceServiceConnection;
+    },
+    get isAccumulatorUpdateData () {
+        return _priceservicesdk.isAccumulatorUpdateData;
+    },
+    get parseAccumulatorUpdateData () {
+        return _priceservicesdk.parseAccumulatorUpdateData;
+    }
+});
+const _PriceServiceConnection = require("./PriceServiceConnection.cjs");
+const _priceservicesdk = require("@pythnetwork/price-service-sdk");

package/dist/cjs/index.d.ts

@@ -0,0 +1,2 @@
+export { type DurationInMs, PriceServiceConnection, type PriceServiceConnectionConfig, } from "./PriceServiceConnection.js";
+export { type HexString, PriceFeedMetadata, PriceFeed, Price, type UnixTimestamp, isAccumulatorUpdateData, parseAccumulatorUpdateData, type AccumulatorUpdateData, } from "@pythnetwork/price-service-sdk";

package/dist/cjs/package.json

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

package/dist/cjs/utils.cjs

@@ -0,0 +1,27 @@
+"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 makeWebsocketUrl () {
+        return makeWebsocketUrl;
+    },
+    get removeLeading0xIfExists () {
+        return removeLeading0xIfExists;
+    }
+});
+function makeWebsocketUrl(endpoint) {
+    const url = new URL("ws", endpoint);
+    const useHttps = url.protocol === "https:";
+    url.protocol = useHttps ? "wss:" : "ws:";
+    return url.toString();
+}
+function removeLeading0xIfExists(id) {
+    return id.startsWith("0x") ? id.slice(2) : id;
+}