@pythnetwork/price-service-client 1.4.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2023 Pyth Contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/lib/PriceServiceConnection.d.ts

@@ -0,0 +1,119 @@
+import { HexString, PriceFeed } from "@pythnetwork/price-service-sdk";
+import { Logger } from "ts-log";
+export type DurationInMs = number;
+export type PriceFeedRequestConfig = {
+    verbose?: boolean;
+    binary?: boolean;
+};
+export type PriceServiceConnectionConfig = {
+    timeout?: DurationInMs;
+    /**
+     * 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;
+};
+export type PriceFeedUpdateCallback = (priceFeed: PriceFeed) => void;
+export declare class PriceServiceConnection {
+    private httpClient;
+    private priceFeedCallbacks;
+    private wsClient;
+    private wsEndpoint;
+    private logger;
+    private priceFeedRequestConfig;
+    /**
+     * 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 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;
+}
+//# sourceMappingURL=PriceServiceConnection.d.ts.map

package/lib/PriceServiceConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PriceServiceConnection.d.ts","sourceRoot":"","sources":["../src/PriceServiceConnection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAItE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC,MAAM,MAAM,sBAAsB,GAAG;IAEnC,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IAEzC,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACjD,CAAC;AAsBF,MAAM,MAAM,uBAAuB,GAAG,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC;AAErE,qBAAa,sBAAsB;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,kBAAkB,CAA+C;IACzE,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,UAAU,CAAqB;IAEvC,OAAO,CAAC,MAAM,CAAqB;IAEnC,OAAO,CAAC,sBAAsB,CAAyB;IAEvD;;;;OAIG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAElC;;;;;OAKG;gBACS,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,4BAA4B;IAyBnE;;;;;;OAMG;IACG,mBAAmB,CACvB,QAAQ,EAAE,SAAS,EAAE,GACpB,OAAO,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC;IAkBnC;;;;;;;;OAQG;IACG,aAAa,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAS7D;;;;;;;;;;;OAWG;IACG,MAAM,CACV,OAAO,EAAE,SAAS,EAClB,WAAW,EAAE,cAAc,GAC1B,OAAO,CAAC,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAUpC;;;;;OAKG;IACG,eAAe,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAK7C;;;;;;;;;;OAUG;IACG,yBAAyB,CAC7B,QAAQ,EAAE,SAAS,EAAE,EACrB,EAAE,EAAE,uBAAuB;IA6B7B;;;;;;;;;;OAUG;IACG,2BAA2B,CAC/B,QAAQ,EAAE,SAAS,EAAE,EACrB,EAAE,CAAC,EAAE,uBAAuB;IA4C9B;;;;OAIG;IACG,cAAc;IAwEpB;;;;;;OAMG;IACH,cAAc;CAKf"}

package/lib/PriceServiceConnection.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceServiceConnection = void 0;
+const price_service_sdk_1 = require("@pythnetwork/price-service-sdk");
+const axios_1 = require("axios");
+const axios_retry_1 = require("axios-retry");
+const ResillientWebSocket_1 = require("./ResillientWebSocket");
+const utils_1 = require("./utils");
+class PriceServiceConnection {
+    httpClient;
+    priceFeedCallbacks;
+    wsClient;
+    wsEndpoint;
+    logger;
+    priceFeedRequestConfig;
+    /**
+     * 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.httpClient = axios_1.default.create({
+            baseURL: endpoint,
+            timeout: config?.timeout || 5000,
+        });
+        (0, axios_retry_1.default)(this.httpClient, {
+            retries: config?.httpRetries || 3,
+            retryDelay: axios_retry_1.default.exponentialDelay,
+        });
+        this.priceFeedRequestConfig = {
+            binary: config?.priceFeedRequestConfig?.binary,
+            verbose: config?.priceFeedRequestConfig?.verbose ?? config?.verbose,
+        };
+        this.priceFeedCallbacks = new Map();
+        this.logger = config?.logger;
+        this.onWsError = (error) => {
+            this.logger?.error(error);
+        };
+        this.wsEndpoint = (0, utils_1.makeWebsocketUrl)(endpoint);
+    }
+    /**
+     * 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) => price_service_sdk_1.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 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_1.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,
+        };
+        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_1.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_1.ResilientWebSocket(this.wsEndpoint, this.logger);
+        this.wsClient.onError = this.onWsError;
+        this.wsClient.onReconnect = () => {
+            if (this.priceFeedCallbacks.size > 0) {
+                const message = {
+                    ids: Array.from(this.priceFeedCallbacks.keys()),
+                    type: "subscribe",
+                    verbose: this.priceFeedRequestConfig.verbose,
+                    binary: this.priceFeedRequestConfig.binary,
+                };
+                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 (e) {
+                this.logger?.error(`Error parsing message ${data.toString()} as JSON.`);
+                this.logger?.error(e);
+                this.onWsError(e);
+                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 = price_service_sdk_1.PriceFeed.fromJson(message.price_feed);
+                }
+                catch (e) {
+                    this.logger?.error(`Error parsing price feeds from message ${data.toString()}.`);
+                    this.logger?.error(e);
+                    this.onWsError(e);
+                    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();
+    }
+}
+exports.PriceServiceConnection = PriceServiceConnection;

package/lib/ResillientWebSocket.d.ts

@@ -0,0 +1,39 @@
+import * as WebSocket from "isomorphic-ws";
+import { 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: any): 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;
+}
+//# sourceMappingURL=ResillientWebSocket.d.ts.map

package/lib/ResillientWebSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResillientWebSocket.d.ts","sourceRoot":"","sources":["../src/ResillientWebSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC;;;;;;;;;GASG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,MAAM,CAAqB;IAEnC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAChC,SAAS,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC;IAC1C,WAAW,EAAE,MAAM,IAAI,CAAC;gBAEZ,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAavC,IAAI,CAAC,IAAI,EAAE,GAAG;IAcd,cAAc;IAqDpB;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;YAcH,0BAA0B;YAgB1B,gCAAgC;IAkB9C,cAAc;CAQf"}

package/lib/ResillientWebSocket.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResilientWebSocket = void 0;
+const WebSocket = require("isomorphic-ws");
+const PING_TIMEOUT_DURATION = 30000 + 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).
+ */
+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.onopen = () => {
+            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.onclose = async () => {
+            if (this.pingTimeout !== undefined) {
+                clearInterval(this.pingTimeout);
+            }
+            if (this.wsUserClosed === false) {
+                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();
+            }
+            else {
+                this.logger?.info("The connection has been closed successfully.");
+            }
+        };
+        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 > 1000) {
+                this.wsClient.close();
+                return;
+            }
+            else {
+                waitedTime += 10;
+                await sleep(10);
+            }
+        }
+    }
+    async restartUnexpectedClosedWebsocket() {
+        if (this.wsUserClosed === true) {
+            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;
+    }
+}
+exports.ResilientWebSocket = ResilientWebSocket;
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function expoBackoff(attempts) {
+    return 2 ** attempts * 100;
+}

package/lib/examples/PriceServiceClient.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=PriceServiceClient.d.ts.map

package/lib/examples/PriceServiceClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PriceServiceClient.d.ts","sourceRoot":"","sources":["../../src/examples/PriceServiceClient.ts"],"names":[],"mappings":""}

package/lib/examples/PriceServiceClient.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargs_1 = require("yargs");
+const helpers_1 = require("yargs/helpers");
+const index_1 = require("../index");
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const argv = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    .option("endpoint", {
+    description: "Endpoint URL for the price service. e.g: https://endpoint/example",
+    type: "string",
+    required: true,
+})
+    .option("price-ids", {
+    description: "Space separated price feed ids (in hex without leading 0x) to fetch." +
+        " e.g: f9c0172ba10dfa4d19088d...",
+    type: "array",
+    required: true,
+})
+    .help()
+    .alias("help", "h")
+    .parserConfiguration({
+    "parse-numbers": false,
+})
+    .parseSync();
+async function run() {
+    const connection = new index_1.PriceServiceConnection(argv.endpoint, {
+        logger: console,
+        priceFeedRequestConfig: {
+            binary: true,
+        },
+    });
+    const priceIds = argv.priceIds;
+    const priceFeeds = await connection.getLatestPriceFeeds(priceIds);
+    console.log(priceFeeds);
+    console.log(priceFeeds?.at(0)?.getPriceNoOlderThan(60));
+    console.log("Subscribing to price feed updates.");
+    await connection.subscribePriceFeedUpdates(priceIds, (priceFeed) => {
+        console.log(`Current price for ${priceFeed.id}: ${JSON.stringify(priceFeed.getPriceNoOlderThan(60))}.`);
+        console.log(priceFeed.getVAA());
+    });
+    await sleep(600000);
+    // To close the websocket you should either unsubscribe from all
+    // price feeds or call `connection.stopWebSocket()` directly.
+    console.log("Unsubscribing from price feed updates.");
+    await connection.unsubscribePriceFeedUpdates(priceIds);
+    // connection.closeWebSocket();
+}
+run();

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { DurationInMs, PriceServiceConnection, PriceServiceConnectionConfig, } from "./PriceServiceConnection";
+export { HexString, PriceFeedMetadata, PriceFeed, Price, UnixTimestamp, } from "@pythnetwork/price-service-sdk";
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,KAAK,EACL,aAAa,GACd,MAAM,gCAAgC,CAAC"}

package/lib/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Price = exports.PriceFeed = exports.PriceFeedMetadata = exports.PriceServiceConnection = void 0;
+var PriceServiceConnection_1 = require("./PriceServiceConnection");
+Object.defineProperty(exports, "PriceServiceConnection", { enumerable: true, get: function () { return PriceServiceConnection_1.PriceServiceConnection; } });
+var price_service_sdk_1 = require("@pythnetwork/price-service-sdk");
+Object.defineProperty(exports, "PriceFeedMetadata", { enumerable: true, get: function () { return price_service_sdk_1.PriceFeedMetadata; } });
+Object.defineProperty(exports, "PriceFeed", { enumerable: true, get: function () { return price_service_sdk_1.PriceFeed; } });
+Object.defineProperty(exports, "Price", { enumerable: true, get: function () { return price_service_sdk_1.Price; } });

package/lib/utils.d.ts

@@ -0,0 +1,10 @@
+import { 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;
+//# sourceMappingURL=utils.d.ts.map

package/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,UAOhD;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,SAAS,GAAG,SAAS,CAMhE"}

package/lib/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLeading0xIfExists = exports.makeWebsocketUrl = void 0;
+/**
+ * Convert http(s) endpoint to ws(s) endpoint.
+ *
+ * @param endpoint Http(s) protocol endpoint
+ * @returns Ws(s) protocol endpoint of the same address
+ */
+function makeWebsocketUrl(endpoint) {
+    const url = new URL("ws", endpoint);
+    const useHttps = url.protocol === "https:";
+    url.protocol = useHttps ? "wss:" : "ws:";
+    return url.toString();
+}
+exports.makeWebsocketUrl = makeWebsocketUrl;
+function removeLeading0xIfExists(id) {
+    if (id.startsWith("0x")) {
+        return id.substring(2);
+    }
+    else {
+        return id;
+    }
+}
+exports.removeLeading0xIfExists = removeLeading0xIfExists;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@pythnetwork/price-service-client",
+  "version": "1.4.0",
+  "description": "Pyth price service client",
+  "author": {
+    "name": "Pyth Data Association"
+  },
+  "homepage": "https://pyth.network",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyth-network/pyth-crosschain",
+    "directory": "price_service/client/js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest --testPathIgnorePatterns=.*.e2e.test.ts --passWithNoTests",
+    "test:e2e": "jest --testPathPattern=.*.e2e.test.ts",
+    "build": "tsc",
+    "example": "npm run build && node lib/examples/PriceServiceClient.js",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "eslint src/",
+    "prepublishOnly": "npm run build && npm test && npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src"
+  },
+  "keywords": [
+    "pyth",
+    "oracle"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/jest": "^29.4.0",
+    "@types/yargs": "^17.0.10",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
+    "eslint": "^8.14.0",
+    "jest": "^29.4.0",
+    "prettier": "^2.6.2",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.6.3",
+    "yargs": "^17.4.1"
+  },
+  "dependencies": {
+    "@pythnetwork/price-service-sdk": "*",
+    "@types/ws": "^8.5.3",
+    "axios": "^1.2.5",
+    "axios-retry": "^3.4.0",
+    "isomorphic-ws": "^4.0.1",
+    "ts-log": "^2.2.4",
+    "ws": "^8.6.0"
+  },
+  "gitHead": "94f38fdd745ba4211e4aee0b361b2f6d82522f8c"
+}