@pythnetwork/pyth-lazer-sdk 6.0.0 → 6.2.1

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

@@ -10,10 +10,10 @@ Object.defineProperty(exports, "WebSocketPool", {
 });
 const _ttlcache = /*#__PURE__*/ _interop_require_default(require("@isaacs/ttlcache"));
 const _tslog = require("ts-log");
-const _resilientwebsocket = require("./resilient-websocket.cjs");
 const _constants = require("../constants.cjs");
 const _index = require("../emitter/index.cjs");
 const _index1 = require("../util/index.cjs");
+const _resilientwebsocket = require("./resilient-websocket.cjs");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -27,8 +27,12 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
     subscriptions;
     messageListeners;
     allConnectionsDownListeners;
+    connectionRestoredListeners;
+    connectionTimeoutListeners;
+    connectionReconnectListeners;
     wasAllDown = true;
     checkConnectionStatesInterval;
+    isShutdown = false;
     constructor(logger){
         super(), this.logger = logger;
         this.rwsPool = [];
@@ -38,6 +42,9 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         this.subscriptions = new Map();
         this.messageListeners = [];
         this.allConnectionsDownListeners = [];
+        this.connectionRestoredListeners = [];
+        this.connectionTimeoutListeners = [];
+        this.connectionReconnectListeners = [];
         // Start monitoring connection states
         this.checkConnectionStatesInterval = setInterval(()=>{
             this.checkConnectionStates();
@@ -50,76 +57,103 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
    * @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(config, token, logger) {
+   */ static async create(config, token, abortSignal, logger) {
+        // Helper to check if aborted and throw
+        const throwIfAborted = ()=>{
+            if (abortSignal?.aborted) {
+                throw new DOMException("WebSocketPool.create() was aborted", "AbortError");
+            }
+        };
+        // Check before starting
+        throwIfAborted();
         const urls = config.urls ?? [
             _constants.DEFAULT_STREAM_SERVICE_0_URL,
             _constants.DEFAULT_STREAM_SERVICE_1_URL
         ];
         const log = logger ?? _tslog.dummyLogger;
         const pool = new WebSocketPool(log);
-        const numConnections = config.numConnections ?? DEFAULT_NUM_CONNECTIONS;
-        // bind a handler to capture any emitted errors and send them to the user-provided
-        // onWebSocketPoolError callback (if it is present)
-        if (typeof config.onWebSocketPoolError === "function") {
-            pool.on("error", config.onWebSocketPoolError);
-            pool.once("shutdown", ()=>{
-                // unbind all error handlers so we don't leak memory
-                pool.off("error");
-            });
-        }
-        for(let i = 0; i < numConnections; i++){
-            const baseUrl = urls[i % urls.length];
-            const isBrowser = (0, _index1.envIsBrowserOrWorker)();
-            const url = isBrowser ? (0, _index1.addAuthTokenToWebSocketUrl)(baseUrl, token) : baseUrl;
-            if (!url) {
-                throw new Error(`URLs must not be null or empty`);
+        try {
+            const numConnections = config.numConnections ?? DEFAULT_NUM_CONNECTIONS;
+            // bind a handler to capture any emitted errors and send them to the user-provided
+            // onWebSocketPoolError callback (if it is present)
+            if (typeof config.onWebSocketPoolError === "function") {
+                pool.on("error", config.onWebSocketPoolError);
+                pool.once("shutdown", ()=>{
+                    // unbind all error handlers so we don't leak memory
+                    pool.off("error");
+                });
             }
-            const wsOptions = {
-                ...config.rwsConfig?.wsOptions,
-                headers: isBrowser ? undefined : {
-                    Authorization: `Bearer ${token}`
-                }
-            };
-            const rws = new _resilientwebsocket.ResilientWebSocket({
-                ...config.rwsConfig,
-                endpoint: url,
-                wsOptions,
-                logger: log
-            });
-            // If a websocket client unexpectedly disconnects, ResilientWebSocket will reestablish
-            // the connection and call the onReconnect callback.
-            rws.onReconnect = ()=>{
-                if (rws.wsUserClosed) {
-                    return;
+            for(let i = 0; i < numConnections; i++){
+                const baseUrl = urls[i % urls.length];
+                const isBrowser = (0, _index1.envIsBrowserOrWorker)();
+                const url = isBrowser ? (0, _index1.addAuthTokenToWebSocketUrl)(baseUrl, token) : baseUrl;
+                if (!url) {
+                    throw new Error(`URLs must not be null or empty`);
                 }
-                for (const [, request] of pool.subscriptions){
-                    try {
-                        rws.send(JSON.stringify(request));
-                    } catch (error) {
-                        pool.logger.error("Failed to resend subscription on reconnect:", error);
+                const wsOptions = {
+                    ...config.rwsConfig?.wsOptions,
+                    headers: isBrowser ? undefined : {
+                        Authorization: `Bearer ${token}`
+                    }
+                };
+                const rws = new _resilientwebsocket.ResilientWebSocket({
+                    ...config.rwsConfig,
+                    endpoint: url,
+                    logger: log,
+                    wsOptions
+                });
+                const connectionIndex = i;
+                const connectionEndpoint = url;
+                // If a websocket client unexpectedly disconnects, ResilientWebSocket will reestablish
+                // the connection and call the onReconnect callback.
+                rws.onReconnect = ()=>{
+                    if (rws.wsUserClosed || pool.isShutdown) {
+                        return;
+                    }
+                    for (const listener of pool.connectionReconnectListeners){
+                        listener(connectionIndex, connectionEndpoint);
                     }
+                    for (const [, request] of pool.subscriptions){
+                        try {
+                            rws.send(JSON.stringify(request));
+                        } catch (error) {
+                            pool.logger.error("Failed to resend subscription on reconnect:", error);
+                        }
+                    }
+                };
+                rws.onTimeout = ()=>{
+                    for (const listener of pool.connectionTimeoutListeners){
+                        listener(connectionIndex, connectionEndpoint);
+                    }
+                };
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
+                const onErrorHandler = config.onWebSocketError ?? config.onError;
+                if (typeof onErrorHandler === "function") {
+                    rws.onError = onErrorHandler;
                 }
-            };
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            const onErrorHandler = config.onWebSocketError ?? config.onError;
-            if (typeof onErrorHandler === "function") {
-                rws.onError = onErrorHandler;
+                // Handle all client messages ourselves. Dedupe before sending to registered message handlers.
+                rws.onMessage = (data)=>{
+                    pool.dedupeHandler(data).catch((error)=>{
+                        pool.emitPoolError(error, "Error in WebSocketPool dedupeHandler");
+                    });
+                };
+                pool.rwsPool.push(rws);
+                rws.startWebSocket();
             }
-            // Handle all client messages ourselves. Dedupe before sending to registered message handlers.
-            rws.onMessage = (data)=>{
-                pool.dedupeHandler(data).catch((error)=>{
-                    pool.emitPoolError(error, "Error in WebSocketPool dedupeHandler");
-                });
-            };
-            pool.rwsPool.push(rws);
-            rws.startWebSocket();
-        }
-        pool.logger.info(`Started WebSocketPool with ${numConnections.toString()} connections. Waiting for at least one to connect...`);
-        while(!pool.isAnyConnectionEstablished()){
-            await new Promise((resolve)=>setTimeout(resolve, 100));
+            pool.logger.info(`Started WebSocketPool with ${numConnections.toString()} connections. Waiting for at least one to connect...`);
+            while(!pool.isAnyConnectionEstablished() && !pool.isShutdown){
+                throwIfAborted();
+                await new Promise((resolve)=>setTimeout(resolve, 100));
+            }
+            // Final check after loop exits
+            throwIfAborted();
+            pool.logger.info(`At least one WebSocket connection is established. WebSocketPool is ready.`);
+            return pool;
+        } catch (error) {
+            // Clean up the pool if aborted during connection wait
+            pool.shutdown();
+            throw error;
         }
-        pool.logger.info(`At least one WebSocket connection is established. WebSocketPool is ready.`);
-        return pool;
     }
     emitPoolError(error, context) {
         const err = error instanceof Error ? error : new Error(String(error));
@@ -171,6 +205,10 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         }
     };
     sendRequest(request) {
+        if (this.isShutdown) {
+            this.logger.warn("Cannot send request: WebSocketPool is shutdown");
+            return;
+        }
         for (const rws of this.rwsPool){
             try {
                 rws.send(JSON.stringify(request));
@@ -180,6 +218,10 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         }
     }
     addSubscription(request) {
+        if (this.isShutdown) {
+            this.logger.warn("Cannot add subscription: WebSocketPool is shutdown");
+            return;
+        }
         if (request.type !== "subscribe") {
             this.emitPoolError(new Error("Request must be a subscribe request"));
             return;
@@ -188,10 +230,14 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         this.sendRequest(request);
     }
     removeSubscription(subscriptionId) {
+        if (this.isShutdown) {
+            this.logger.warn("Cannot remove subscription: WebSocketPool is shutdown");
+            return;
+        }
         this.subscriptions.delete(subscriptionId);
         const request = {
-            type: "unsubscribe",
-            subscriptionId
+            subscriptionId,
+            type: "unsubscribe"
         };
         this.sendRequest(request);
     }
@@ -204,6 +250,23 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
    */ addAllConnectionsDownListener(handler) {
         this.allConnectionsDownListeners.push(handler);
     }
+    /**
+   * Calls the handler when at least one connection is restored after all connections were down.
+   */ addConnectionRestoredListener(handler) {
+        this.connectionRestoredListeners.push(handler);
+    }
+    /**
+   * Calls the handler when an individual connection times out (heartbeat timeout).
+   * @param handler - Callback with connection index and endpoint URL
+   */ addConnectionTimeoutListener(handler) {
+        this.connectionTimeoutListeners.push(handler);
+    }
+    /**
+   * Calls the handler when an individual connection reconnects after being down.
+   * @param handler - Callback with connection index and endpoint URL
+   */ addConnectionReconnectListener(handler) {
+        this.connectionReconnectListeners.push(handler);
+    }
     areAllConnectionsDown() {
         return this.rwsPool.every((ws)=>!ws.isConnected() || ws.isReconnecting());
     }
@@ -211,6 +274,10 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         return this.rwsPool.some((ws)=>ws.isConnected());
     }
     checkConnectionStates() {
+        // Stop monitoring if shutdown
+        if (this.isShutdown) {
+            return;
+        }
         const allDown = this.areAllConnectionsDown();
         // If all connections just went down
         if (allDown && !this.wasAllDown) {
@@ -225,12 +292,25 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
                 }
             }
         }
-        // If at least one connection was restored
+        // If at least one connection was restored after all were down
         if (!allDown && this.wasAllDown) {
             this.wasAllDown = false;
+            this.logger.info("At least one WebSocket connection restored");
+            for (const listener of this.connectionRestoredListeners){
+                try {
+                    listener();
+                } catch (error) {
+                    this.emitPoolError(error, "Connection-restored listener threw");
+                }
+            }
         }
     }
     shutdown() {
+        // Prevent multiple shutdown calls
+        if (this.isShutdown) {
+            return;
+        }
+        this.isShutdown = true;
         for (const rws of this.rwsPool){
             rws.closeWebSocket();
         }
@@ -238,6 +318,9 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         this.subscriptions.clear();
         this.messageListeners = [];
         this.allConnectionsDownListeners = [];
+        this.connectionRestoredListeners = [];
+        this.connectionTimeoutListeners = [];
+        this.connectionReconnectListeners = [];
         clearInterval(this.checkConnectionStatesInterval);
         // execute all bound shutdown handlers
         for (const shutdownHandler of this.getListeners("shutdown")){

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

@@ -1,10 +1,10 @@
+import type WebSocket from "isomorphic-ws";
 import type { ErrorEvent } from "isomorphic-ws";
-import WebSocket from "isomorphic-ws";
 import type { Logger } from "ts-log";
+import { IsomorphicEventEmitter } from "../emitter/index.js";
 import type { Request } from "../protocol.js";
 import type { ResilientWebSocketConfig } from "./resilient-websocket.js";
 import { ResilientWebSocket } from "./resilient-websocket.js";
-import { IsomorphicEventEmitter } from "../emitter/index.js";
 type WebSocketOnMessageCallback = (data: WebSocket.Data) => Promise<void>;
 export type WebSocketPoolConfig = {
     /**
@@ -51,8 +51,12 @@ export declare class WebSocketPool extends IsomorphicEventEmitter<WebSocketPoolE
     private subscriptions;
     private messageListeners;
     private allConnectionsDownListeners;
+    private connectionRestoredListeners;
+    private connectionTimeoutListeners;
+    private connectionReconnectListeners;
     private wasAllDown;
     private checkConnectionStatesInterval;
+    private isShutdown;
     private constructor();
     /**
      * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
@@ -62,7 +66,7 @@ export declare class WebSocketPool extends IsomorphicEventEmitter<WebSocketPoolE
      * @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(config: WebSocketPoolConfig, token: string, logger?: Logger): Promise<WebSocketPool>;
+    static create(config: WebSocketPoolConfig, token: string, abortSignal?: AbortSignal | null | undefined, logger?: Logger): Promise<WebSocketPool>;
     private emitPoolError;
     /**
      * Checks for error responses in JSON messages and throws appropriate errors
@@ -83,6 +87,20 @@ export declare class WebSocketPool extends IsomorphicEventEmitter<WebSocketPoolE
      * The connections may still try to reconnect in the background.
      */
     addAllConnectionsDownListener(handler: () => void): void;
+    /**
+     * Calls the handler when at least one connection is restored after all connections were down.
+     */
+    addConnectionRestoredListener(handler: () => void): void;
+    /**
+     * Calls the handler when an individual connection times out (heartbeat timeout).
+     * @param handler - Callback with connection index and endpoint URL
+     */
+    addConnectionTimeoutListener(handler: (connectionIndex: number, endpoint: string) => void): void;
+    /**
+     * Calls the handler when an individual connection reconnects after being down.
+     * @param handler - Callback with connection index and endpoint URL
+     */
+    addConnectionReconnectListener(handler: (connectionIndex: number, endpoint: string) => void): void;
     private areAllConnectionsDown;
     private isAnyConnectionEstablished;
     private checkConnectionStates;

package/dist/esm/client.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "ts-log";
-import type { ParsedPayload, Request, Response, SymbolResponse, SymbolsQueryParams, LatestPriceRequest, PriceRequest, JsonUpdate } from "./protocol.js";
+import type { JsonUpdate, LatestPriceRequest, ParsedPayload, PriceRequest, Request, Response, SymbolResponse, SymbolsQueryParams } from "./protocol.js";
 import type { WebSocketPoolConfig } from "./socket/websocket-pool.js";
 export type BinaryResponse = {
     subscriptionId: number;
@@ -17,25 +17,25 @@ export type JsonOrBinaryResponse = {
     value: BinaryResponse;
 };
 export type LazerClientConfig = {
+    /**
+     * If provided, allows aborting the client creation process.
+     * Once the client is successfully created, this signal has no effect on the client's lifecycle.
+     * When aborted, the promise will reject with a DOMException with name 'AbortError'.
+     */
+    abortSignal?: AbortSignal;
     token: string;
     metadataServiceUrl?: string;
     priceServiceUrl?: string;
     logger?: Logger;
-    webSocketPoolConfig?: WebSocketPoolConfig;
+    webSocketPoolConfig: WebSocketPoolConfig;
 };
 export declare class PythLazerClient {
-    private readonly token;
-    private readonly metadataServiceUrl;
-    private readonly priceServiceUrl;
-    private readonly logger;
-    private readonly wsp?;
+    private logger;
+    private metadataServiceUrl;
+    private priceServiceUrl;
+    private token;
+    private wsp;
     private constructor();
-    /**
-     * Gets the WebSocket pool. If the WebSocket pool is not configured, an error is thrown.
-     * @throws Error if WebSocket pool is not configured
-     * @returns The WebSocket pool
-     */
-    private getWebSocketPool;
     /**
      * Creates a new PythLazerClient instance.
      * @param config - Configuration including token, metadata service URL, and price service URL, and WebSocket pool configuration
@@ -57,6 +57,21 @@ export declare class PythLazerClient {
      * @param handler - Function to be called when all connections are down
      */
     addAllConnectionsDownListener(handler: () => void): void;
+    /**
+     * Registers a handler function that will be called when at least one connection is restored after all were down.
+     * @param handler - Function to be called when connection is restored
+     */
+    addConnectionRestoredListener(handler: () => void): void;
+    /**
+     * Registers a handler function that will be called when an individual connection times out (heartbeat timeout).
+     * @param handler - Function to be called with connection index and endpoint URL
+     */
+    addConnectionTimeoutListener(handler: (connectionIndex: number, endpoint: string) => void): void;
+    /**
+     * Registers a handler function that will be called when an individual connection reconnects.
+     * @param handler - Function to be called with connection index and endpoint URL
+     */
+    addConnectionReconnectListener(handler: (connectionIndex: number, endpoint: string) => void): void;
     shutdown(): void;
     /**
      * Private helper method to make authenticated HTTP requests with Bearer token

package/dist/esm/client.mjs

@@ -7,43 +7,69 @@ const UINT16_NUM_BYTES = 2;
 const UINT32_NUM_BYTES = 4;
 const UINT64_NUM_BYTES = 8;
 export class PythLazerClient {
-    token;
+    logger;
     metadataServiceUrl;
     priceServiceUrl;
-    logger;
+    token;
     wsp;
-    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp){
-        this.token = token;
+    constructor({ logger, metadataServiceUrl, priceServiceUrl, token, wsp }){
+        this.logger = logger;
         this.metadataServiceUrl = metadataServiceUrl;
         this.priceServiceUrl = priceServiceUrl;
-        this.logger = logger;
+        this.token = token;
         this.wsp = wsp;
     }
     /**
-   * Gets the WebSocket pool. If the WebSocket pool is not configured, an error is thrown.
-   * @throws Error if WebSocket pool is not configured
-   * @returns The WebSocket pool
-   */ getWebSocketPool() {
-        if (!this.wsp) {
-            throw new Error("WebSocket pool is not available. Make sure to provide webSocketPoolConfig when creating the client.");
-        }
-        return this.wsp;
-    }
-    /**
    * Creates a new PythLazerClient instance.
    * @param config - Configuration including token, metadata service URL, and price service URL, and WebSocket pool configuration
    */ static async create(config) {
+        let wsp = undefined;
+        let client = undefined;
+        const { abortSignal } = config;
+        const handleAbort = ()=>{
+            // we need to EXPLICITLY shutdown both items,
+            // because there is a possibility the client was undefined
+            // when the abort signal was called
+            client?.shutdown();
+            wsp?.shutdown();
+            abortSignal?.removeEventListener("abort", handleAbort);
+        };
+        const throwIfAborted = ()=>{
+            if (abortSignal?.aborted) {
+                throw new DOMException("PythLazerClient.create() was aborted", "AbortError");
+            }
+        };
+        abortSignal?.addEventListener("abort", handleAbort);
         const token = config.token;
         // Collect and remove trailing slash from URLs
         const metadataServiceUrl = (config.metadataServiceUrl ?? DEFAULT_METADATA_SERVICE_URL).replace(/\/+$/, "");
         const priceServiceUrl = (config.priceServiceUrl ?? DEFAULT_PRICE_SERVICE_URL).replace(/\/+$/, "");
         const logger = config.logger ?? dummyLogger;
-        // If webSocketPoolConfig is provided, create a WebSocket pool and block until at least one connection is established.
-        let wsp;
-        if (config.webSocketPoolConfig) {
-            wsp = await WebSocketPool.create(config.webSocketPoolConfig, token, logger);
+        try {
+            throwIfAborted();
+            // the prior API was mismatched, in that it marked a websocket pool as optional,
+            // yet all internal code on the Pyth Pro client used it and threw if it didn't exist.
+            // now, the typings indicate it's no longer optional and we don't sanity check
+            // if it's set
+            wsp = await WebSocketPool.create(config.webSocketPoolConfig, token, abortSignal, logger);
+            throwIfAborted();
+            client = new PythLazerClient({
+                logger,
+                metadataServiceUrl,
+                priceServiceUrl,
+                token,
+                wsp
+            });
+            throwIfAborted();
+            // detach the abortSignal handler here, because we've made it!
+            abortSignal?.removeEventListener("abort", handleAbort);
+            return client;
+        } catch (error) {
+            client?.shutdown();
+            wsp?.shutdown();
+            abortSignal?.removeEventListener("abort", handleAbort);
+            throw error;
         }
-        return new PythLazerClient(token, metadataServiceUrl, priceServiceUrl, logger, wsp);
     }
     /**
    * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
@@ -51,9 +77,8 @@ export class PythLazerClient {
    * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
    * or a binary response containing EVM, Solana, or parsed payload data.
    */ addMessageListener(handler) {
-        const wsp = this.getWebSocketPool();
-        wsp.addMessageListener(async (data)=>{
-            if (typeof data == "string") {
+        this.wsp.addMessageListener(async (data)=>{
+            if (typeof data === "string") {
                 handler({
                     type: "json",
                     value: JSON.parse(data)
@@ -64,7 +89,7 @@ export class PythLazerClient {
             let pos = 0;
             const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
             pos += UINT32_NUM_BYTES;
-            if (magic != BINARY_UPDATE_FORMAT_MAGIC_LE) {
+            if (magic !== BINARY_UPDATE_FORMAT_MAGIC_LE) {
                 throw new Error("binary update format magic mismatch");
             }
             // TODO: some uint64 values may not be representable as Number.
@@ -77,15 +102,15 @@ export class PythLazerClient {
                 const len = buffData.subarray(pos, pos + UINT16_NUM_BYTES).readUint16BE();
                 pos += UINT16_NUM_BYTES;
                 const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
-                if (magic == FORMAT_MAGICS_LE.EVM) {
+                if (magic === FORMAT_MAGICS_LE.EVM) {
                     value.evm = buffData.subarray(pos, pos + len);
-                } else if (magic == FORMAT_MAGICS_LE.SOLANA) {
+                } else if (magic === FORMAT_MAGICS_LE.SOLANA) {
                     value.solana = buffData.subarray(pos, pos + len);
-                } else if (magic == FORMAT_MAGICS_LE.LE_ECDSA) {
+                } else if (magic === FORMAT_MAGICS_LE.LE_ECDSA) {
                     value.leEcdsa = buffData.subarray(pos, pos + len);
-                } else if (magic == FORMAT_MAGICS_LE.LE_UNSIGNED) {
+                } else if (magic === FORMAT_MAGICS_LE.LE_UNSIGNED) {
                     value.leUnsigned = buffData.subarray(pos, pos + len);
-                } else if (magic == FORMAT_MAGICS_LE.JSON) {
+                } else if (magic === FORMAT_MAGICS_LE.JSON) {
                     value.parsed = JSON.parse(buffData.subarray(pos + UINT32_NUM_BYTES, pos + len).toString());
                 } else {
                     throw new Error(`unknown magic:  ${magic.toString()}`);
@@ -99,42 +124,54 @@ export class PythLazerClient {
         });
     }
     subscribe(request) {
-        const wsp = this.getWebSocketPool();
         if (request.type !== "subscribe") {
             throw new Error("Request must be a subscribe request");
         }
-        wsp.addSubscription(request);
+        this.wsp.addSubscription(request);
     }
     unsubscribe(subscriptionId) {
-        const wsp = this.getWebSocketPool();
-        wsp.removeSubscription(subscriptionId);
+        this.wsp.removeSubscription(subscriptionId);
     }
     send(request) {
-        const wsp = this.getWebSocketPool();
-        wsp.sendRequest(request);
+        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) {
-        const wsp = this.getWebSocketPool();
-        wsp.addAllConnectionsDownListener(handler);
+        this.wsp.addAllConnectionsDownListener(handler);
+    }
+    /**
+   * Registers a handler function that will be called when at least one connection is restored after all were down.
+   * @param handler - Function to be called when connection is restored
+   */ addConnectionRestoredListener(handler) {
+        this.wsp.addConnectionRestoredListener(handler);
+    }
+    /**
+   * Registers a handler function that will be called when an individual connection times out (heartbeat timeout).
+   * @param handler - Function to be called with connection index and endpoint URL
+   */ addConnectionTimeoutListener(handler) {
+        this.wsp.addConnectionTimeoutListener(handler);
+    }
+    /**
+   * Registers a handler function that will be called when an individual connection reconnects.
+   * @param handler - Function to be called with connection index and endpoint URL
+   */ addConnectionReconnectListener(handler) {
+        this.wsp.addConnectionReconnectListener(handler);
     }
     shutdown() {
-        const wsp = this.getWebSocketPool();
-        wsp.shutdown();
+        this.wsp.shutdown();
     }
     /**
    * Private helper method to make authenticated HTTP requests with Bearer token
    * @param url - The URL to fetch
    * @param options - Additional fetch options
    * @returns Promise resolving to the fetch Response
-   */ async authenticatedFetch(url, options = {}) {
-        const headers = {
-            Authorization: `Bearer ${this.token}`,
-            ...options.headers
-        };
+   */ authenticatedFetch(url, options = {}) {
+        // Handle all possible types of headers (Headers object, array, or plain object)
+        const headers = new Headers(options.headers);
+        headers.set("Authorization", headers.get("authorization") ?? `Bearer ${this.token}`);
         return fetch(url, {
             ...options,
             headers
@@ -171,15 +208,15 @@ export class PythLazerClient {
         try {
             const body = JSON.stringify(params);
             this.logger.debug("getLatestPrice", {
-                url,
-                body
+                body,
+                url
             });
             const response = await this.authenticatedFetch(url, {
-                method: "POST",
+                body: body,
                 headers: {
                     "Content-Type": "application/json"
                 },
-                body: body
+                method: "POST"
             });
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
@@ -198,15 +235,15 @@ export class PythLazerClient {
         try {
             const body = JSON.stringify(params);
             this.logger.debug("getPrice", {
-                url,
-                body
+                body,
+                url
             });
             const response = await this.authenticatedFetch(url, {
-                method: "POST",
+                body: body,
                 headers: {
                     "Content-Type": "application/json"
                 },
-                body: body
+                method: "POST"
             });
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);