@pythnetwork/price-service-client 1.10.0 → 1.11.0

package/dist/{PriceServiceConnection.cjs → cjs/PriceServiceConnection.cjs}

@@ -25,6 +25,7 @@ class PriceServiceConnection {
     wsEndpoint;
     logger;
     priceFeedRequestConfig;
+    accessToken;
     /**
    * Custom handler for web socket errors (connection and message parsing).
    *
@@ -36,9 +37,13 @@ class PriceServiceConnection {
    * @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
+            timeout: config?.timeout || 5000,
+            headers: this.accessToken === undefined ? {} : {
+                Authorization: `Bearer ${this.accessToken}`
+            }
         });
         (0, _axiosretry.default)(this.httpClient, {
             retries: config?.httpRetries || 3,
@@ -70,6 +75,13 @@ class PriceServiceConnection {
             }
         };
         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.

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

@@ -19,6 +19,13 @@ export type PriceServiceConnectionConfig = {
     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 {
@@ -28,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).
      *

package/dist/esm/PriceServiceConnection.d.ts

@@ -0,0 +1,139 @@
+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 | undefined;
+    binary?: boolean | undefined;
+    allowOutOfOrder?: boolean | undefined;
+};
+export type PriceServiceConnectionConfig = {
+    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 | 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 {
+    private httpClient;
+    private priceFeedCallbacks;
+    private wsClient;
+    private wsEndpoint;
+    private logger;
+    private priceFeedRequestConfig;
+    private accessToken;
+    /**
+     * Custom handler for web socket errors (connection and message parsing).
+     *
+     * Default handler only logs the errors.
+     */
+    onWsError: (error: Error) => void;
+    /**
+     * 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: 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.
+     * @returns Array of PriceFeeds
+     */
+    getLatestPriceFeeds(priceIds: HexString[]): Promise<PriceFeed[] | undefined>;
+    /**
+     * 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.
+     */
+    getLatestVaas(priceIds: HexString[]): Promise<string[]>;
+    /**
+     * 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.
+     */
+    getVaa(priceId: HexString, publishTime: EpochTimeStamp): Promise<[string, EpochTimeStamp]>;
+    /**
+     * 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
+     */
+    getPriceFeed(priceId: HexString, publishTime: EpochTimeStamp): Promise<PriceFeed>;
+    /**
+     * 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.
+     */
+    getPriceFeedIds(): Promise<HexString[]>;
+    /**
+     * 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.
+     */
+    subscribePriceFeedUpdates(priceIds: HexString[], cb: PriceFeedUpdateCallback): Promise<void>;
+    /**
+     * 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.
+     */
+    unsubscribePriceFeedUpdates(priceIds: HexString[], cb?: PriceFeedUpdateCallback): Promise<void>;
+    /**
+     * Starts connection websocket.
+     *
+     * This function is called automatically upon subscribing to price feed updates.
+     */
+    startWebSocket(): Promise<void>;
+    /**
+     * 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(): void;
+}

package/dist/esm/PriceServiceConnection.mjs

@@ -0,0 +1,307 @@
+/* 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 */ import { PriceFeed } from "@pythnetwork/price-service-sdk";
+import axios from "axios";
+import axiosRetry from "axios-retry";
+import { ResilientWebSocket } from "./ResillientWebSocket.mjs";
+import { makeWebsocketUrl, removeLeading0xIfExists } from "./utils.mjs";
+export 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.create({
+            baseURL: endpoint,
+            timeout: config?.timeout || 5000,
+            headers: this.accessToken === undefined ? {} : {
+                Authorization: `Bearer ${this.accessToken}`
+            }
+        });
+        axiosRetry(this.httpClient, {
+            retries: config?.httpRetries || 3,
+            // eslint-disable-next-line import/no-named-as-default-member
+            retryDelay: axiosRetry.exponentialDelay.bind(axiosRetry)
+        });
+        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 = 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)=>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 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)=>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)=>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 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 = 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/dist/esm/ResillientWebSocket.d.ts

@@ -0,0 +1,38 @@
+import WebSocket from "isomorphic-ws";
+import type { Logger } from "ts-log";
+/**
+ * This class wraps websocket to provide a resilient web socket client.
+ *
+ * It will reconnect if connection fails with exponential backoff. Also, in node, it will reconnect
+ * if it receives no ping request from server within a while as indication of timeout (assuming
+ * the server sends it regularly).
+ *
+ * This class also logs events if logger is given and by replacing onError method you can handle
+ * connection errors yourself (e.g: do not retry and close the connection).
+ */
+export declare class ResilientWebSocket {
+    private endpoint;
+    private wsClient;
+    private wsUserClosed;
+    private wsFailedAttempts;
+    private pingTimeout;
+    private logger;
+    onError: (error: Error) => void;
+    onMessage: (data: WebSocket.Data) => void;
+    onReconnect: () => void;
+    constructor(endpoint: string, logger?: Logger);
+    send(data: unknown): Promise<void>;
+    startWebSocket(): Promise<void>;
+    /**
+     * 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.
+     */
+    private heartbeat;
+    private waitForMaybeReadyWebSocket;
+    private restartUnexpectedClosedWebsocket;
+    closeWebSocket(): void;
+}

package/dist/esm/ResillientWebSocket.mjs

@@ -0,0 +1,138 @@
+/* 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 */ import WebSocket from "isomorphic-ws";
+const PING_TIMEOUT_DURATION = 30_000 + 3000; // It is 30s on the server and 3s is added for delays
+/**
+ * This class wraps websocket to provide a resilient web socket client.
+ *
+ * It will reconnect if connection fails with exponential backoff. Also, in node, it will reconnect
+ * if it receives no ping request from server within a while as indication of timeout (assuming
+ * the server sends it regularly).
+ *
+ * This class also logs events if logger is given and by replacing onError method you can handle
+ * connection errors yourself (e.g: do not retry and close the connection).
+ */ export 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 WebSocket(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/dist/esm/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/esm/index.mjs

@@ -0,0 +1,2 @@
+export { PriceServiceConnection } from "./PriceServiceConnection.mjs";
+export { PriceFeedMetadata, PriceFeed, Price, isAccumulatorUpdateData, parseAccumulatorUpdateData } from "@pythnetwork/price-service-sdk";

package/dist/esm/package.json

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

package/dist/esm/utils.d.ts

@@ -0,0 +1,9 @@
+import type { HexString } from "@pythnetwork/price-service-sdk";
+/**
+ * Convert http(s) endpoint to ws(s) endpoint.
+ *
+ * @param endpoint -  Http(s) protocol endpoint
+ * @returns Ws(s) protocol endpoint of the same address
+ */
+export declare function makeWebsocketUrl(endpoint: string): string;
+export declare function removeLeading0xIfExists(id: HexString): HexString;

package/dist/esm/utils.mjs

@@ -0,0 +1,14 @@
+/**
+ * Convert http(s) endpoint to ws(s) endpoint.
+ *
+ * @param endpoint -  Http(s) protocol endpoint
+ * @returns Ws(s) protocol endpoint of the same address
+ */ export function makeWebsocketUrl(endpoint) {
+    const url = new URL("ws", endpoint);
+    const useHttps = url.protocol === "https:";
+    url.protocol = useHttps ? "wss:" : "ws:";
+    return url.toString();
+}
+export function removeLeading0xIfExists(id) {
+    return id.startsWith("0x") ? id.slice(2) : id;
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@pythnetwork/price-service-client",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Pyth price service client",
   "deprecated": "This package is deprecated and is no longer maintained. Please use @pythnetwork/hermes-client instead.",
   "author": {
     "name": "Pyth Data Association"
   },
   "homepage": "https://pyth.network",
-  "main": "./dist/index.cjs",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/cjs/index.d.ts",
   "files": [
     "dist/**/*"
   ],
@@ -45,32 +45,56 @@
     "@pythnetwork/price-service-sdk": "1.9.0"
   },
   "engines": {
-    "node": ">=22.14.0"
+    "node": "^24.0.0"
   },
   "type": "module",
   "exports": {
     "./PriceServiceConnection": {
-      "types": "./dist/PriceServiceConnection.d.ts",
-      "default": "./dist/PriceServiceConnection.cjs"
+      "require": {
+        "types": "./dist/cjs/PriceServiceConnection.d.ts",
+        "default": "./dist/cjs/PriceServiceConnection.cjs"
+      },
+      "import": {
+        "types": "./dist/esm/PriceServiceConnection.d.ts",
+        "default": "./dist/esm/PriceServiceConnection.mjs"
+      }
     },
     "./ResillientWebSocket": {
-      "types": "./dist/ResillientWebSocket.d.ts",
-      "default": "./dist/ResillientWebSocket.cjs"
+      "require": {
+        "types": "./dist/cjs/ResillientWebSocket.d.ts",
+        "default": "./dist/cjs/ResillientWebSocket.cjs"
+      },
+      "import": {
+        "types": "./dist/esm/ResillientWebSocket.d.ts",
+        "default": "./dist/esm/ResillientWebSocket.mjs"
+      }
     },
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.cjs"
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.cjs"
+      },
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.mjs"
+      }
     },
     "./utils": {
-      "types": "./dist/utils.d.ts",
-      "default": "./dist/utils.cjs"
+      "require": {
+        "types": "./dist/cjs/utils.d.ts",
+        "default": "./dist/cjs/utils.cjs"
+      },
+      "import": {
+        "types": "./dist/esm/utils.d.ts",
+        "default": "./dist/esm/utils.mjs"
+      }
     },
     "./package.json": "./package.json"
   },
-  "module": "./dist/esm/index.js",
+  "module": "./dist/esm/index.mjs",
   "scripts": {
     "test:e2e": "jest --testPathPattern=.*.e2e.test.ts",
-    "build": "ts-duality --noEsm",
+    "build": "ts-duality",
     "example": "pnpm run build && node lib/examples/PriceServiceClient.js",
     "fix:format": "prettier --write \"src/**/*.ts\"",
     "fix:lint": "eslint src/ --fix --max-warnings 0",