@pythnetwork/pyth-lazer-sdk 0.1.2 → 0.3.0

package/dist/cjs/client.d.ts

@@ -1,4 +1,4 @@
-import WebSocket from "isomorphic-ws";
+import { type Logger } from "ts-log";
 import { type ParsedPayload, type Request, type Response } from "./protocol.js";
 export type BinaryResponse = {
     subscriptionId: number;
@@ -14,8 +14,31 @@ export type JsonOrBinaryResponse = {
     value: BinaryResponse;
 };
 export declare class PythLazerClient {
-    ws: WebSocket;
-    constructor(url: string, token: string);
+    private readonly wsp;
+    private constructor();
+    /**
+     * Creates a new PythLazerClient instance.
+     * @param urls - List of WebSocket URLs of the Pyth Lazer service
+     * @param token - The access token for authentication
+     * @param numConnections - The number of parallel WebSocket connections to establish (default: 3). A higher number gives a more reliable stream. The connections will round-robin across the provided URLs.
+     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+     */
+    static create(urls: string[], token: string, numConnections?: number, logger?: Logger): Promise<PythLazerClient>;
+    /**
+     * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
+     * The listener will be called for each message received, with deduplication across redundant connections.
+     * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
+     * or a binary response containing EVM, Solana, or parsed payload data.
+     */
     addMessageListener(handler: (event: JsonOrBinaryResponse) => void): void;
-    send(request: Request): void;
+    subscribe(request: Request): Promise<void>;
+    unsubscribe(subscriptionId: number): Promise<void>;
+    send(request: Request): Promise<void>;
+    /**
+     * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.
+     * The connections may still try to reconnect in the background. To shut down the pool, call `shutdown()`.
+     * @param handler - Function to be called when all connections are down
+     */
+    addAllConnectionsDownListener(handler: () => void): void;
+    shutdown(): void;
 }

package/dist/cjs/client.js

@@ -1,58 +1,67 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythLazerClient = void 0;
-const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const ts_log_1 = require("ts-log");
 const protocol_js_1 = require("./protocol.js");
+const websocket_pool_js_1 = require("./socket/websocket-pool.js");
 const UINT16_NUM_BYTES = 2;
 const UINT32_NUM_BYTES = 4;
 const UINT64_NUM_BYTES = 8;
 class PythLazerClient {
-    ws;
-    constructor(url, token) {
-        const finalUrl = new URL(url);
-        finalUrl.searchParams.append("ACCESS_TOKEN", token);
-        this.ws = new isomorphic_ws_1.default(finalUrl);
+    wsp;
+    constructor(wsp) {
+        this.wsp = wsp;
     }
+    /**
+     * Creates a new PythLazerClient instance.
+     * @param urls - List of WebSocket URLs of the Pyth Lazer service
+     * @param token - The access token for authentication
+     * @param numConnections - The number of parallel WebSocket connections to establish (default: 3). A higher number gives a more reliable stream. The connections will round-robin across the provided URLs.
+     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+     */
+    static async create(urls, token, numConnections = 3, logger = ts_log_1.dummyLogger) {
+        const wsp = await websocket_pool_js_1.WebSocketPool.create(urls, token, numConnections, logger);
+        return new PythLazerClient(wsp);
+    }
+    /**
+     * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
+     * The listener will be called for each message received, with deduplication across redundant connections.
+     * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
+     * or a binary response containing EVM, Solana, or parsed payload data.
+     */
     addMessageListener(handler) {
-        this.ws.addEventListener("message", (event) => {
-            if (typeof event.data == "string") {
+        this.wsp.addMessageListener((data) => {
+            if (typeof data == "string") {
                 handler({
                     type: "json",
-                    value: JSON.parse(event.data),
+                    value: JSON.parse(data),
                 });
             }
-            else if (Buffer.isBuffer(event.data)) {
+            else if (Buffer.isBuffer(data)) {
                 let pos = 0;
-                const magic = event.data
-                    .subarray(pos, pos + UINT32_NUM_BYTES)
-                    .readUint32BE();
+                const magic = data.subarray(pos, pos + UINT32_NUM_BYTES).readUint32BE();
                 pos += UINT32_NUM_BYTES;
                 if (magic != protocol_js_1.BINARY_UPDATE_FORMAT_MAGIC) {
                     throw new Error("binary update format magic mismatch");
                 }
                 // TODO: some uint64 values may not be representable as Number.
-                const subscriptionId = Number(event.data.subarray(pos, pos + UINT64_NUM_BYTES).readBigInt64BE());
+                const subscriptionId = Number(data.subarray(pos, pos + UINT64_NUM_BYTES).readBigInt64BE());
                 pos += UINT64_NUM_BYTES;
                 const value = { subscriptionId };
-                while (pos < event.data.length) {
-                    const len = event.data
-                        .subarray(pos, pos + UINT16_NUM_BYTES)
-                        .readUint16BE();
+                while (pos < data.length) {
+                    const len = data.subarray(pos, pos + UINT16_NUM_BYTES).readUint16BE();
                     pos += UINT16_NUM_BYTES;
-                    const magic = event.data
+                    const magic = data
                         .subarray(pos, pos + UINT32_NUM_BYTES)
                         .readUint32BE();
                     if (magic == protocol_js_1.EVM_FORMAT_MAGIC) {
-                        value.evm = event.data.subarray(pos, pos + len);
+                        value.evm = data.subarray(pos, pos + len);
                     }
                     else if (magic == protocol_js_1.SOLANA_FORMAT_MAGIC_BE) {
-                        value.solana = event.data.subarray(pos, pos + len);
+                        value.solana = data.subarray(pos, pos + len);
                     }
                     else if (magic == protocol_js_1.PARSED_FORMAT_MAGIC) {
-                        value.parsed = JSON.parse(event.data.subarray(pos + UINT32_NUM_BYTES, pos + len).toString());
+                        value.parsed = JSON.parse(data.subarray(pos + UINT32_NUM_BYTES, pos + len).toString());
                     }
                     else {
                         throw new Error("unknown magic: " + magic.toString());
@@ -66,8 +75,28 @@ class PythLazerClient {
             }
         });
     }
-    send(request) {
-        this.ws.send(JSON.stringify(request));
+    async subscribe(request) {
+        if (request.type !== "subscribe") {
+            throw new Error("Request must be a subscribe request");
+        }
+        await this.wsp.addSubscription(request);
+    }
+    async unsubscribe(subscriptionId) {
+        await this.wsp.removeSubscription(subscriptionId);
+    }
+    async send(request) {
+        await this.wsp.sendRequest(request);
+    }
+    /**
+     * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.
+     * The connections may still try to reconnect in the background. To shut down the pool, call `shutdown()`.
+     * @param handler - Function to be called when all connections are down
+     */
+    addAllConnectionsDownListener(handler) {
+        this.wsp.addAllConnectionsDownListener(handler);
+    }
+    shutdown() {
+        this.wsp.shutdown();
     }
 }
 exports.PythLazerClient = PythLazerClient;

package/dist/cjs/constants.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const SOLANA_LAZER_PROGRAM_ID: PublicKey;
+export declare const SOLANA_STORAGE_ID: PublicKey;

package/dist/cjs/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLANA_STORAGE_ID = exports.SOLANA_LAZER_PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.SOLANA_LAZER_PROGRAM_ID = new web3_js_1.PublicKey("pytd2yyk641x7ak7mkaasSJVXh6YYZnC7wTmtgAyxPt");
+exports.SOLANA_STORAGE_ID = new web3_js_1.PublicKey("3rdJbqfnagQ4yx9HXJViD4zc4xpiSqmFsKpPuSCQVyQL");

package/dist/cjs/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./client.js";
 export * from "./protocol.js";
 export * from "./ed25519.js";
+export * from "./constants.js";

package/dist/cjs/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client.js"), exports);
 __exportStar(require("./protocol.js"), exports);
 __exportStar(require("./ed25519.js"), exports);
+__exportStar(require("./constants.js"), exports);

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

@@ -0,0 +1,29 @@
+import type { ClientRequestArgs } from "node:http";
+import WebSocket, { type ClientOptions, type ErrorEvent } from "isomorphic-ws";
+import type { Logger } from "ts-log";
+export declare class ResilientWebSocket {
+    endpoint: string;
+    wsClient: undefined | WebSocket;
+    wsUserClosed: boolean;
+    private wsOptions;
+    private wsFailedAttempts;
+    private heartbeatTimeout;
+    private logger;
+    private connectionPromise;
+    private resolveConnection;
+    private rejectConnection;
+    private _isReconnecting;
+    get isReconnecting(): boolean;
+    get isConnected(): boolean;
+    onError: (error: ErrorEvent) => void;
+    onMessage: (data: WebSocket.Data) => void;
+    onReconnect: () => void;
+    constructor(endpoint: string, wsOptions?: ClientOptions | ClientRequestArgs, logger?: Logger);
+    send(data: string | Buffer): Promise<void>;
+    startWebSocket(): Promise<void>;
+    private resetHeartbeat;
+    private waitForMaybeReadyWebSocket;
+    private handleClose;
+    private restartUnexpectedClosedWebsocket;
+    closeWebSocket(): void;
+}

package/dist/cjs/socket/resilient-websocket.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResilientWebSocket = void 0;
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const HEARTBEAT_TIMEOUT_DURATION = 10_000;
+const CONNECTION_TIMEOUT = 5000;
+class ResilientWebSocket {
+    endpoint;
+    wsClient;
+    wsUserClosed;
+    wsOptions;
+    wsFailedAttempts;
+    heartbeatTimeout;
+    logger;
+    connectionPromise;
+    resolveConnection;
+    rejectConnection;
+    _isReconnecting = false;
+    get isReconnecting() {
+        return this._isReconnecting;
+    }
+    get isConnected() {
+        return this.wsClient?.readyState === isomorphic_ws_1.default.OPEN;
+    }
+    onError;
+    onMessage;
+    onReconnect;
+    constructor(endpoint, wsOptions, logger) {
+        this.endpoint = endpoint;
+        this.wsOptions = wsOptions;
+        this.logger = logger;
+        this.wsFailedAttempts = 0;
+        this.onError = (error) => {
+            this.logger?.error(error.error);
+        };
+        this.wsUserClosed = true;
+        this.onMessage = (data) => {
+            void data;
+        };
+        this.onReconnect = () => {
+            // Empty function, can be set by the user.
+        };
+    }
+    async send(data) {
+        this.logger?.info(`Sending message`);
+        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) {
+            // If there's an existing connection attempt, wait for it
+            if (this.connectionPromise) {
+                return this.connectionPromise;
+            }
+            return;
+        }
+        this.logger?.info(`Creating Web Socket client`);
+        // Create a new promise for this connection attempt
+        this.connectionPromise = new Promise((resolve, reject) => {
+            this.resolveConnection = resolve;
+            this.rejectConnection = reject;
+        });
+        // Set a connection timeout
+        const timeoutId = setTimeout(() => {
+            if (this.rejectConnection) {
+                this.rejectConnection(new Error(`Connection timeout after ${String(CONNECTION_TIMEOUT)}ms`));
+            }
+        }, CONNECTION_TIMEOUT);
+        this.wsClient = new isomorphic_ws_1.default(this.endpoint, this.wsOptions);
+        this.wsUserClosed = false;
+        this.wsClient.addEventListener("open", () => {
+            this.wsFailedAttempts = 0;
+            this.resetHeartbeat();
+            clearTimeout(timeoutId);
+            this._isReconnecting = false;
+            this.resolveConnection?.();
+        });
+        this.wsClient.addEventListener("error", (event) => {
+            this.onError(event);
+            if (this.rejectConnection) {
+                this.rejectConnection(new Error("WebSocket connection failed"));
+            }
+        });
+        this.wsClient.addEventListener("message", (event) => {
+            this.resetHeartbeat();
+            this.onMessage(event.data);
+        });
+        this.wsClient.addEventListener("close", () => {
+            clearTimeout(timeoutId);
+            if (this.rejectConnection) {
+                this.rejectConnection(new Error("WebSocket closed before connecting"));
+            }
+            void this.handleClose();
+        });
+        if ("on" in this.wsClient) {
+            this.wsClient.on("ping", () => {
+                this.logger?.info("Ping received");
+                this.resetHeartbeat();
+            });
+        }
+        return this.connectionPromise;
+    }
+    resetHeartbeat() {
+        if (this.heartbeatTimeout !== undefined) {
+            clearTimeout(this.heartbeatTimeout);
+        }
+        this.heartbeatTimeout = setTimeout(() => {
+            this.logger?.warn("Connection timed out. Reconnecting...");
+            this.wsClient?.terminate();
+            void this.restartUnexpectedClosedWebsocket();
+        }, HEARTBEAT_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 handleClose() {
+        if (this.heartbeatTimeout !== undefined) {
+            clearTimeout(this.heartbeatTimeout);
+        }
+        if (this.wsUserClosed) {
+            this.logger?.info("The connection has been closed successfully.");
+        }
+        else {
+            this.wsFailedAttempts += 1;
+            this.wsClient = undefined;
+            this.connectionPromise = undefined;
+            this.resolveConnection = undefined;
+            this.rejectConnection = undefined;
+            const waitTime = expoBackoff(this.wsFailedAttempts);
+            this._isReconnecting = true;
+            this.logger?.error("Connection closed unexpectedly or because of timeout. Reconnecting after " +
+                String(waitTime) +
+                "ms.");
+            await sleep(waitTime);
+            await this.restartUnexpectedClosedWebsocket();
+        }
+    }
+    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;
+            this.connectionPromise = undefined;
+            this.resolveConnection = undefined;
+            this.rejectConnection = 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/dist/cjs/socket/websocket-pool.d.ts

@@ -0,0 +1,44 @@
+import WebSocket from "isomorphic-ws";
+import { type Logger } from "ts-log";
+import { ResilientWebSocket } from "./resilient-websocket.js";
+import type { Request } from "../protocol.js";
+export declare class WebSocketPool {
+    private readonly logger;
+    rwsPool: ResilientWebSocket[];
+    private cache;
+    private subscriptions;
+    private messageListeners;
+    private allConnectionsDownListeners;
+    private wasAllDown;
+    private constructor();
+    /**
+     * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
+     * Usage semantics are similar to using a regular WebSocket client.
+     * @param urls - List of WebSocket URLs to connect to
+     * @param token - Authentication token to use for the connections
+     * @param numConnections - Number of parallel WebSocket connections to maintain (default: 3)
+     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+     */
+    static create(urls: string[], token: string, numConnections?: number, logger?: Logger): Promise<WebSocketPool>;
+    /**
+     * Checks for error responses in JSON messages and throws appropriate errors
+     */
+    private handleErrorMessages;
+    /**
+     * Handles incoming websocket messages by deduplicating identical messages received across
+     * multiple connections before forwarding to registered handlers
+     */
+    dedupeHandler: (data: WebSocket.Data) => void;
+    sendRequest(request: Request): Promise<void>;
+    addSubscription(request: Request): Promise<void>;
+    removeSubscription(subscriptionId: number): Promise<void>;
+    addMessageListener(handler: (data: WebSocket.Data) => void): void;
+    /**
+     * Calls the handler if all websocket connections are currently down or in reconnecting state.
+     * The connections may still try to reconnect in the background.
+     */
+    addAllConnectionsDownListener(handler: () => void): void;
+    private areAllConnectionsDown;
+    private checkConnectionStates;
+    shutdown(): void;
+}

package/dist/cjs/socket/websocket-pool.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketPool = void 0;
+const ttlcache_1 = __importDefault(require("@isaacs/ttlcache"));
+const ts_log_1 = require("ts-log");
+const resilient_websocket_js_1 = require("./resilient-websocket.js");
+const DEFAULT_NUM_CONNECTIONS = 3;
+class WebSocketPool {
+    logger;
+    rwsPool;
+    cache;
+    subscriptions; // id -> subscription Request
+    messageListeners;
+    allConnectionsDownListeners;
+    wasAllDown = true;
+    constructor(logger = ts_log_1.dummyLogger) {
+        this.logger = logger;
+        this.rwsPool = [];
+        this.cache = new ttlcache_1.default({ ttl: 1000 * 10 }); // TTL of 10 seconds
+        this.subscriptions = new Map();
+        this.messageListeners = [];
+        this.allConnectionsDownListeners = [];
+        // Start monitoring connection states
+        setInterval(() => {
+            this.checkConnectionStates();
+        }, 100);
+    }
+    /**
+     * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
+     * Usage semantics are similar to using a regular WebSocket client.
+     * @param urls - List of WebSocket URLs to connect to
+     * @param token - Authentication token to use for the connections
+     * @param numConnections - Number of parallel WebSocket connections to maintain (default: 3)
+     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+     */
+    static async create(urls, token, numConnections = DEFAULT_NUM_CONNECTIONS, logger = ts_log_1.dummyLogger) {
+        if (urls.length === 0) {
+            throw new Error("No URLs provided");
+        }
+        const pool = new WebSocketPool(logger);
+        // Create all websocket instances
+        const connectionPromises = [];
+        for (let i = 0; i < numConnections; i++) {
+            const url = urls[i % urls.length];
+            if (!url) {
+                throw new Error(`URLs must not be null or empty`);
+            }
+            const wsOptions = {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            };
+            const rws = new resilient_websocket_js_1.ResilientWebSocket(url, wsOptions, logger);
+            // If a websocket client unexpectedly disconnects, ResilientWebSocket will reestablish
+            // the connection and call the onReconnect callback.
+            rws.onReconnect = () => {
+                if (rws.wsUserClosed) {
+                    return;
+                }
+                for (const [, request] of pool.subscriptions) {
+                    try {
+                        void rws.send(JSON.stringify(request));
+                    }
+                    catch (error) {
+                        pool.logger.error("Failed to resend subscription on reconnect:", error);
+                    }
+                }
+            };
+            // Handle all client messages ourselves. Dedupe before sending to registered message handlers.
+            rws.onMessage = pool.dedupeHandler;
+            pool.rwsPool.push(rws);
+            // Start the websocket and collect the promise
+            connectionPromises.push(rws.startWebSocket());
+        }
+        // Wait for all connections to be established
+        try {
+            await Promise.all(connectionPromises);
+        }
+        catch (error) {
+            // If any connection fails, clean up and throw
+            pool.shutdown();
+            throw error;
+        }
+        pool.logger.info(`Successfully established ${numConnections.toString()} redundant WebSocket connections`);
+        return pool;
+    }
+    /**
+     * Checks for error responses in JSON messages and throws appropriate errors
+     */
+    handleErrorMessages(data) {
+        const message = JSON.parse(data);
+        if (message.type === "subscriptionError") {
+            throw new Error(`Error occurred for subscription ID ${String(message.subscriptionId)}: ${message.error}`);
+        }
+        else if (message.type === "error") {
+            throw new Error(`Error: ${message.error}`);
+        }
+    }
+    /**
+     * Handles incoming websocket messages by deduplicating identical messages received across
+     * multiple connections before forwarding to registered handlers
+     */
+    dedupeHandler = (data) => {
+        const cacheKey = typeof data === "string"
+            ? data
+            : Buffer.from(data).toString("hex");
+        if (this.cache.has(cacheKey)) {
+            this.logger.debug("Dropping duplicate message");
+            return;
+        }
+        this.cache.set(cacheKey, true);
+        if (typeof data === "string") {
+            this.handleErrorMessages(data);
+        }
+        for (const handler of this.messageListeners) {
+            handler(data);
+        }
+    };
+    async sendRequest(request) {
+        const sendPromises = this.rwsPool.map(async (rws) => {
+            try {
+                await rws.send(JSON.stringify(request));
+            }
+            catch (error) {
+                this.logger.error("Failed to send request:", error);
+                throw error;
+            }
+        });
+        await Promise.all(sendPromises);
+    }
+    async addSubscription(request) {
+        if (request.type !== "subscribe") {
+            throw new Error("Request must be a subscribe request");
+        }
+        this.subscriptions.set(request.subscriptionId, request);
+        await this.sendRequest(request);
+    }
+    async removeSubscription(subscriptionId) {
+        this.subscriptions.delete(subscriptionId);
+        const request = {
+            type: "unsubscribe",
+            subscriptionId,
+        };
+        await this.sendRequest(request);
+    }
+    addMessageListener(handler) {
+        this.messageListeners.push(handler);
+    }
+    /**
+     * Calls the handler if all websocket connections are currently down or in reconnecting state.
+     * The connections may still try to reconnect in the background.
+     */
+    addAllConnectionsDownListener(handler) {
+        this.allConnectionsDownListeners.push(handler);
+    }
+    areAllConnectionsDown() {
+        return this.rwsPool.every((ws) => !ws.isConnected || ws.isReconnecting);
+    }
+    checkConnectionStates() {
+        const allDown = this.areAllConnectionsDown();
+        // If all connections just went down
+        if (allDown && !this.wasAllDown) {
+            this.wasAllDown = true;
+            this.logger.error("All WebSocket connections are down or reconnecting");
+            // Notify all listeners
+            for (const listener of this.allConnectionsDownListeners) {
+                listener();
+            }
+        }
+        // If at least one connection was restored
+        if (!allDown && this.wasAllDown) {
+            this.wasAllDown = false;
+        }
+    }
+    shutdown() {
+        for (const rws of this.rwsPool) {
+            rws.closeWebSocket();
+        }
+        this.rwsPool = [];
+        this.subscriptions.clear();
+        this.messageListeners = [];
+        this.allConnectionsDownListeners = [];
+    }
+}
+exports.WebSocketPool = WebSocketPool;

package/dist/esm/client.d.ts

@@ -1,4 +1,4 @@
-import WebSocket from "isomorphic-ws";
+import { type Logger } from "ts-log";
 import { type ParsedPayload, type Request, type Response } from "./protocol.js";
 export type BinaryResponse = {
     subscriptionId: number;
@@ -14,8 +14,31 @@ export type JsonOrBinaryResponse = {
     value: BinaryResponse;
 };
 export declare class PythLazerClient {
-    ws: WebSocket;
-    constructor(url: string, token: string);
+    private readonly wsp;
+    private constructor();
+    /**
+     * Creates a new PythLazerClient instance.
+     * @param urls - List of WebSocket URLs of the Pyth Lazer service
+     * @param token - The access token for authentication
+     * @param numConnections - The number of parallel WebSocket connections to establish (default: 3). A higher number gives a more reliable stream. The connections will round-robin across the provided URLs.
+     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+     */
+    static create(urls: string[], token: string, numConnections?: number, logger?: Logger): Promise<PythLazerClient>;
+    /**
+     * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
+     * The listener will be called for each message received, with deduplication across redundant connections.
+     * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
+     * or a binary response containing EVM, Solana, or parsed payload data.
+     */
     addMessageListener(handler: (event: JsonOrBinaryResponse) => void): void;
-    send(request: Request): void;
+    subscribe(request: Request): Promise<void>;
+    unsubscribe(subscriptionId: number): Promise<void>;
+    send(request: Request): Promise<void>;
+    /**
+     * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.
+     * The connections may still try to reconnect in the background. To shut down the pool, call `shutdown()`.
+     * @param handler - Function to be called when all connections are down
+     */
+    addAllConnectionsDownListener(handler: () => void): void;
+    shutdown(): void;
 }

package/dist/esm/client.js

@@ -1,52 +1,65 @@
 import WebSocket from "isomorphic-ws";
+import { dummyLogger } from "ts-log";
 import { BINARY_UPDATE_FORMAT_MAGIC, EVM_FORMAT_MAGIC, PARSED_FORMAT_MAGIC, SOLANA_FORMAT_MAGIC_BE, } from "./protocol.js";
+import { WebSocketPool } from "./socket/websocket-pool.js";
 const UINT16_NUM_BYTES = 2;
 const UINT32_NUM_BYTES = 4;
 const UINT64_NUM_BYTES = 8;
 export class PythLazerClient {
-    ws;
-    constructor(url, token) {
-        const finalUrl = new URL(url);
-        finalUrl.searchParams.append("ACCESS_TOKEN", token);
-        this.ws = new WebSocket(finalUrl);
+    wsp;
+    constructor(wsp) {
+        this.wsp = wsp;
     }
+    /**
+     * Creates a new PythLazerClient instance.
+     * @param urls - List of WebSocket URLs of the Pyth Lazer service
+     * @param token - The access token for authentication
+     * @param numConnections - The number of parallel WebSocket connections to establish (default: 3). A higher number gives a more reliable stream. The connections will round-robin across the provided URLs.
+     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+     */
+    static async create(urls, token, numConnections = 3, logger = dummyLogger) {
+        const wsp = await WebSocketPool.create(urls, token, numConnections, logger);
+        return new PythLazerClient(wsp);
+    }
+    /**
+     * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
+     * The listener will be called for each message received, with deduplication across redundant connections.
+     * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
+     * or a binary response containing EVM, Solana, or parsed payload data.
+     */
     addMessageListener(handler) {
-        this.ws.addEventListener("message", (event) => {
-            if (typeof event.data == "string") {
+        this.wsp.addMessageListener((data) => {
+            if (typeof data == "string") {
                 handler({
                     type: "json",
-                    value: JSON.parse(event.data),
+                    value: JSON.parse(data),
                 });
             }
-            else if (Buffer.isBuffer(event.data)) {
+            else if (Buffer.isBuffer(data)) {
                 let pos = 0;
-                const magic = event.data
-                    .subarray(pos, pos + UINT32_NUM_BYTES)
-                    .readUint32BE();
+                const magic = data.subarray(pos, pos + UINT32_NUM_BYTES).readUint32BE();
                 pos += UINT32_NUM_BYTES;
                 if (magic != BINARY_UPDATE_FORMAT_MAGIC) {
                     throw new Error("binary update format magic mismatch");
                 }
                 // TODO: some uint64 values may not be representable as Number.
-                const subscriptionId = Number(event.data.subarray(pos, pos + UINT64_NUM_BYTES).readBigInt64BE());
+                const subscriptionId = Number(data.subarray(pos, pos + UINT64_NUM_BYTES).readBigInt64BE());
                 pos += UINT64_NUM_BYTES;
                 const value = { subscriptionId };
-                while (pos < event.data.length) {
-                    const len = event.data
-                        .subarray(pos, pos + UINT16_NUM_BYTES)
-                        .readUint16BE();
+                while (pos < data.length) {
+                    const len = data.subarray(pos, pos + UINT16_NUM_BYTES).readUint16BE();
                     pos += UINT16_NUM_BYTES;
-                    const magic = event.data
+                    const magic = data
                         .subarray(pos, pos + UINT32_NUM_BYTES)
                         .readUint32BE();
                     if (magic == EVM_FORMAT_MAGIC) {
-                        value.evm = event.data.subarray(pos, pos + len);
+                        value.evm = data.subarray(pos, pos + len);
                     }
                     else if (magic == SOLANA_FORMAT_MAGIC_BE) {
-                        value.solana = event.data.subarray(pos, pos + len);
+                        value.solana = data.subarray(pos, pos + len);
                     }
                     else if (magic == PARSED_FORMAT_MAGIC) {
-                        value.parsed = JSON.parse(event.data.subarray(pos + UINT32_NUM_BYTES, pos + len).toString());
+                        value.parsed = JSON.parse(data.subarray(pos + UINT32_NUM_BYTES, pos + len).toString());
                     }
                     else {
                         throw new Error("unknown magic: " + magic.toString());
@@ -60,7 +73,27 @@ export class PythLazerClient {
             }
         });
     }
-    send(request) {
-        this.ws.send(JSON.stringify(request));
+    async subscribe(request) {
+        if (request.type !== "subscribe") {
+            throw new Error("Request must be a subscribe request");
+        }
+        await this.wsp.addSubscription(request);
+    }
+    async unsubscribe(subscriptionId) {
+        await this.wsp.removeSubscription(subscriptionId);
+    }
+    async send(request) {
+        await this.wsp.sendRequest(request);
+    }
+    /**
+     * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.
+     * The connections may still try to reconnect in the background. To shut down the pool, call `shutdown()`.
+     * @param handler - Function to be called when all connections are down
+     */
+    addAllConnectionsDownListener(handler) {
+        this.wsp.addAllConnectionsDownListener(handler);
+    }
+    shutdown() {
+        this.wsp.shutdown();
     }
 }

package/dist/esm/constants.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const SOLANA_LAZER_PROGRAM_ID: PublicKey;
+export declare const SOLANA_STORAGE_ID: PublicKey;

package/dist/esm/constants.js

@@ -0,0 +1,3 @@
+import { PublicKey } from "@solana/web3.js";
+export const SOLANA_LAZER_PROGRAM_ID = new PublicKey("pytd2yyk641x7ak7mkaasSJVXh6YYZnC7wTmtgAyxPt");
+export const SOLANA_STORAGE_ID = new PublicKey("3rdJbqfnagQ4yx9HXJViD4zc4xpiSqmFsKpPuSCQVyQL");

package/dist/esm/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./client.js";
 export * from "./protocol.js";
 export * from "./ed25519.js";
+export * from "./constants.js";

package/dist/esm/index.js

@@ -1,3 +1,4 @@
 export * from "./client.js";
 export * from "./protocol.js";
 export * from "./ed25519.js";
+export * from "./constants.js";

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

@@ -0,0 +1,29 @@
+import type { ClientRequestArgs } from "node:http";
+import WebSocket, { type ClientOptions, type ErrorEvent } from "isomorphic-ws";
+import type { Logger } from "ts-log";
+export declare class ResilientWebSocket {
+    endpoint: string;
+    wsClient: undefined | WebSocket;
+    wsUserClosed: boolean;
+    private wsOptions;
+    private wsFailedAttempts;
+    private heartbeatTimeout;
+    private logger;
+    private connectionPromise;
+    private resolveConnection;
+    private rejectConnection;
+    private _isReconnecting;
+    get isReconnecting(): boolean;
+    get isConnected(): boolean;
+    onError: (error: ErrorEvent) => void;
+    onMessage: (data: WebSocket.Data) => void;
+    onReconnect: () => void;
+    constructor(endpoint: string, wsOptions?: ClientOptions | ClientRequestArgs, logger?: Logger);
+    send(data: string | Buffer): Promise<void>;
+    startWebSocket(): Promise<void>;
+    private resetHeartbeat;
+    private waitForMaybeReadyWebSocket;
+    private handleClose;
+    private restartUnexpectedClosedWebsocket;
+    closeWebSocket(): void;
+}

package/dist/esm/socket/resilient-websocket.js

@@ -0,0 +1,180 @@
+import WebSocket, {} from "isomorphic-ws";
+const HEARTBEAT_TIMEOUT_DURATION = 10_000;
+const CONNECTION_TIMEOUT = 5000;
+export class ResilientWebSocket {
+    endpoint;
+    wsClient;
+    wsUserClosed;
+    wsOptions;
+    wsFailedAttempts;
+    heartbeatTimeout;
+    logger;
+    connectionPromise;
+    resolveConnection;
+    rejectConnection;
+    _isReconnecting = false;
+    get isReconnecting() {
+        return this._isReconnecting;
+    }
+    get isConnected() {
+        return this.wsClient?.readyState === WebSocket.OPEN;
+    }
+    onError;
+    onMessage;
+    onReconnect;
+    constructor(endpoint, wsOptions, logger) {
+        this.endpoint = endpoint;
+        this.wsOptions = wsOptions;
+        this.logger = logger;
+        this.wsFailedAttempts = 0;
+        this.onError = (error) => {
+            this.logger?.error(error.error);
+        };
+        this.wsUserClosed = true;
+        this.onMessage = (data) => {
+            void data;
+        };
+        this.onReconnect = () => {
+            // Empty function, can be set by the user.
+        };
+    }
+    async send(data) {
+        this.logger?.info(`Sending message`);
+        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) {
+            // If there's an existing connection attempt, wait for it
+            if (this.connectionPromise) {
+                return this.connectionPromise;
+            }
+            return;
+        }
+        this.logger?.info(`Creating Web Socket client`);
+        // Create a new promise for this connection attempt
+        this.connectionPromise = new Promise((resolve, reject) => {
+            this.resolveConnection = resolve;
+            this.rejectConnection = reject;
+        });
+        // Set a connection timeout
+        const timeoutId = setTimeout(() => {
+            if (this.rejectConnection) {
+                this.rejectConnection(new Error(`Connection timeout after ${String(CONNECTION_TIMEOUT)}ms`));
+            }
+        }, CONNECTION_TIMEOUT);
+        this.wsClient = new WebSocket(this.endpoint, this.wsOptions);
+        this.wsUserClosed = false;
+        this.wsClient.addEventListener("open", () => {
+            this.wsFailedAttempts = 0;
+            this.resetHeartbeat();
+            clearTimeout(timeoutId);
+            this._isReconnecting = false;
+            this.resolveConnection?.();
+        });
+        this.wsClient.addEventListener("error", (event) => {
+            this.onError(event);
+            if (this.rejectConnection) {
+                this.rejectConnection(new Error("WebSocket connection failed"));
+            }
+        });
+        this.wsClient.addEventListener("message", (event) => {
+            this.resetHeartbeat();
+            this.onMessage(event.data);
+        });
+        this.wsClient.addEventListener("close", () => {
+            clearTimeout(timeoutId);
+            if (this.rejectConnection) {
+                this.rejectConnection(new Error("WebSocket closed before connecting"));
+            }
+            void this.handleClose();
+        });
+        if ("on" in this.wsClient) {
+            this.wsClient.on("ping", () => {
+                this.logger?.info("Ping received");
+                this.resetHeartbeat();
+            });
+        }
+        return this.connectionPromise;
+    }
+    resetHeartbeat() {
+        if (this.heartbeatTimeout !== undefined) {
+            clearTimeout(this.heartbeatTimeout);
+        }
+        this.heartbeatTimeout = setTimeout(() => {
+            this.logger?.warn("Connection timed out. Reconnecting...");
+            this.wsClient?.terminate();
+            void this.restartUnexpectedClosedWebsocket();
+        }, HEARTBEAT_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 handleClose() {
+        if (this.heartbeatTimeout !== undefined) {
+            clearTimeout(this.heartbeatTimeout);
+        }
+        if (this.wsUserClosed) {
+            this.logger?.info("The connection has been closed successfully.");
+        }
+        else {
+            this.wsFailedAttempts += 1;
+            this.wsClient = undefined;
+            this.connectionPromise = undefined;
+            this.resolveConnection = undefined;
+            this.rejectConnection = undefined;
+            const waitTime = expoBackoff(this.wsFailedAttempts);
+            this._isReconnecting = true;
+            this.logger?.error("Connection closed unexpectedly or because of timeout. Reconnecting after " +
+                String(waitTime) +
+                "ms.");
+            await sleep(waitTime);
+            await this.restartUnexpectedClosedWebsocket();
+        }
+    }
+    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;
+            this.connectionPromise = undefined;
+            this.resolveConnection = undefined;
+            this.rejectConnection = 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/socket/websocket-pool.d.ts

@@ -0,0 +1,44 @@
+import WebSocket from "isomorphic-ws";
+import { type Logger } from "ts-log";
+import { ResilientWebSocket } from "./resilient-websocket.js";
+import type { Request } from "../protocol.js";
+export declare class WebSocketPool {
+    private readonly logger;
+    rwsPool: ResilientWebSocket[];
+    private cache;
+    private subscriptions;
+    private messageListeners;
+    private allConnectionsDownListeners;
+    private wasAllDown;
+    private constructor();
+    /**
+     * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
+     * Usage semantics are similar to using a regular WebSocket client.
+     * @param urls - List of WebSocket URLs to connect to
+     * @param token - Authentication token to use for the connections
+     * @param numConnections - Number of parallel WebSocket connections to maintain (default: 3)
+     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+     */
+    static create(urls: string[], token: string, numConnections?: number, logger?: Logger): Promise<WebSocketPool>;
+    /**
+     * Checks for error responses in JSON messages and throws appropriate errors
+     */
+    private handleErrorMessages;
+    /**
+     * Handles incoming websocket messages by deduplicating identical messages received across
+     * multiple connections before forwarding to registered handlers
+     */
+    dedupeHandler: (data: WebSocket.Data) => void;
+    sendRequest(request: Request): Promise<void>;
+    addSubscription(request: Request): Promise<void>;
+    removeSubscription(subscriptionId: number): Promise<void>;
+    addMessageListener(handler: (data: WebSocket.Data) => void): void;
+    /**
+     * Calls the handler if all websocket connections are currently down or in reconnecting state.
+     * The connections may still try to reconnect in the background.
+     */
+    addAllConnectionsDownListener(handler: () => void): void;
+    private areAllConnectionsDown;
+    private checkConnectionStates;
+    shutdown(): void;
+}

package/dist/esm/socket/websocket-pool.js

@@ -0,0 +1,182 @@
+import TTLCache from "@isaacs/ttlcache";
+import WebSocket from "isomorphic-ws";
+import { dummyLogger } from "ts-log";
+import { ResilientWebSocket } from "./resilient-websocket.js";
+const DEFAULT_NUM_CONNECTIONS = 3;
+export class WebSocketPool {
+    logger;
+    rwsPool;
+    cache;
+    subscriptions; // id -> subscription Request
+    messageListeners;
+    allConnectionsDownListeners;
+    wasAllDown = true;
+    constructor(logger = dummyLogger) {
+        this.logger = logger;
+        this.rwsPool = [];
+        this.cache = new TTLCache({ ttl: 1000 * 10 }); // TTL of 10 seconds
+        this.subscriptions = new Map();
+        this.messageListeners = [];
+        this.allConnectionsDownListeners = [];
+        // Start monitoring connection states
+        setInterval(() => {
+            this.checkConnectionStates();
+        }, 100);
+    }
+    /**
+     * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
+     * Usage semantics are similar to using a regular WebSocket client.
+     * @param urls - List of WebSocket URLs to connect to
+     * @param token - Authentication token to use for the connections
+     * @param numConnections - Number of parallel WebSocket connections to maintain (default: 3)
+     * @param logger - Optional logger to get socket level logs. Compatible with most loggers such as the built-in console and `bunyan`.
+     */
+    static async create(urls, token, numConnections = DEFAULT_NUM_CONNECTIONS, logger = dummyLogger) {
+        if (urls.length === 0) {
+            throw new Error("No URLs provided");
+        }
+        const pool = new WebSocketPool(logger);
+        // Create all websocket instances
+        const connectionPromises = [];
+        for (let i = 0; i < numConnections; i++) {
+            const url = urls[i % urls.length];
+            if (!url) {
+                throw new Error(`URLs must not be null or empty`);
+            }
+            const wsOptions = {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            };
+            const rws = new ResilientWebSocket(url, wsOptions, logger);
+            // If a websocket client unexpectedly disconnects, ResilientWebSocket will reestablish
+            // the connection and call the onReconnect callback.
+            rws.onReconnect = () => {
+                if (rws.wsUserClosed) {
+                    return;
+                }
+                for (const [, request] of pool.subscriptions) {
+                    try {
+                        void rws.send(JSON.stringify(request));
+                    }
+                    catch (error) {
+                        pool.logger.error("Failed to resend subscription on reconnect:", error);
+                    }
+                }
+            };
+            // Handle all client messages ourselves. Dedupe before sending to registered message handlers.
+            rws.onMessage = pool.dedupeHandler;
+            pool.rwsPool.push(rws);
+            // Start the websocket and collect the promise
+            connectionPromises.push(rws.startWebSocket());
+        }
+        // Wait for all connections to be established
+        try {
+            await Promise.all(connectionPromises);
+        }
+        catch (error) {
+            // If any connection fails, clean up and throw
+            pool.shutdown();
+            throw error;
+        }
+        pool.logger.info(`Successfully established ${numConnections.toString()} redundant WebSocket connections`);
+        return pool;
+    }
+    /**
+     * Checks for error responses in JSON messages and throws appropriate errors
+     */
+    handleErrorMessages(data) {
+        const message = JSON.parse(data);
+        if (message.type === "subscriptionError") {
+            throw new Error(`Error occurred for subscription ID ${String(message.subscriptionId)}: ${message.error}`);
+        }
+        else if (message.type === "error") {
+            throw new Error(`Error: ${message.error}`);
+        }
+    }
+    /**
+     * Handles incoming websocket messages by deduplicating identical messages received across
+     * multiple connections before forwarding to registered handlers
+     */
+    dedupeHandler = (data) => {
+        const cacheKey = typeof data === "string"
+            ? data
+            : Buffer.from(data).toString("hex");
+        if (this.cache.has(cacheKey)) {
+            this.logger.debug("Dropping duplicate message");
+            return;
+        }
+        this.cache.set(cacheKey, true);
+        if (typeof data === "string") {
+            this.handleErrorMessages(data);
+        }
+        for (const handler of this.messageListeners) {
+            handler(data);
+        }
+    };
+    async sendRequest(request) {
+        const sendPromises = this.rwsPool.map(async (rws) => {
+            try {
+                await rws.send(JSON.stringify(request));
+            }
+            catch (error) {
+                this.logger.error("Failed to send request:", error);
+                throw error;
+            }
+        });
+        await Promise.all(sendPromises);
+    }
+    async addSubscription(request) {
+        if (request.type !== "subscribe") {
+            throw new Error("Request must be a subscribe request");
+        }
+        this.subscriptions.set(request.subscriptionId, request);
+        await this.sendRequest(request);
+    }
+    async removeSubscription(subscriptionId) {
+        this.subscriptions.delete(subscriptionId);
+        const request = {
+            type: "unsubscribe",
+            subscriptionId,
+        };
+        await this.sendRequest(request);
+    }
+    addMessageListener(handler) {
+        this.messageListeners.push(handler);
+    }
+    /**
+     * Calls the handler if all websocket connections are currently down or in reconnecting state.
+     * The connections may still try to reconnect in the background.
+     */
+    addAllConnectionsDownListener(handler) {
+        this.allConnectionsDownListeners.push(handler);
+    }
+    areAllConnectionsDown() {
+        return this.rwsPool.every((ws) => !ws.isConnected || ws.isReconnecting);
+    }
+    checkConnectionStates() {
+        const allDown = this.areAllConnectionsDown();
+        // If all connections just went down
+        if (allDown && !this.wasAllDown) {
+            this.wasAllDown = true;
+            this.logger.error("All WebSocket connections are down or reconnecting");
+            // Notify all listeners
+            for (const listener of this.allConnectionsDownListeners) {
+                listener();
+            }
+        }
+        // If at least one connection was restored
+        if (!allDown && this.wasAllDown) {
+            this.wasAllDown = false;
+        }
+    }
+    shutdown() {
+        for (const rws of this.rwsPool) {
+            rws.closeWebSocket();
+        }
+        this.rwsPool = [];
+        this.subscriptions.clear();
+        this.messageListeners = [];
+        this.allConnectionsDownListeners = [];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pythnetwork/pyth-lazer-sdk",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Pyth Lazer SDK",
   "publishConfig": {
     "access": "public"
@@ -60,10 +60,12 @@
   ],
   "license": "Apache-2.0",
   "dependencies": {
+    "@isaacs/ttlcache": "^1.4.1",
     "@solana/buffer-layout": "^4.0.1",
     "@solana/web3.js": "^1.98.0",
     "isomorphic-ws": "^5.0.0",
+    "ts-log": "^2.2.7",
     "ws": "^8.18.0"
   },
-  "gitHead": "57670ca732de0be3ed7926f38f4853f01cd816fa"
+  "gitHead": "1c6530498edb3112be05a4f7e44a3973310df8ed"
 }