@pythnetwork/pyth-lazer-sdk 5.0.0 → 5.2.1

package/dist/esm/{client.js → client.mjs}

@@ -1,9 +1,8 @@
-import WebSocket from "isomorphic-ws";
 import { dummyLogger } from "ts-log";
-import { DEFAULT_METADATA_SERVICE_URL, DEFAULT_PRICE_SERVICE_URL, } from "./constants.js";
-import { BINARY_UPDATE_FORMAT_MAGIC_LE, FORMAT_MAGICS_LE } from "./protocol.js";
-import { WebSocketPool } from "./socket/websocket-pool.js";
-import { bufferFromWebsocketData } from "./util/buffer-util.js";
+import { DEFAULT_METADATA_SERVICE_URL, DEFAULT_PRICE_SERVICE_URL } from "./constants.mjs";
+import { BINARY_UPDATE_FORMAT_MAGIC_LE, FORMAT_MAGICS_LE } from "./protocol.mjs";
+import { WebSocketPool } from "./socket/websocket-pool.mjs";
+import { bufferFromWebsocketData } from "./util/buffer-util.mjs";
 const UINT16_NUM_BYTES = 2;
 const UINT32_NUM_BYTES = 4;
 const UINT64_NUM_BYTES = 8;
@@ -13,7 +12,7 @@ export class PythLazerClient {
     priceServiceUrl;
     logger;
     wsp;
-    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp) {
+    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp){
         this.token = token;
         this.metadataServiceUrl = metadataServiceUrl;
         this.priceServiceUrl = priceServiceUrl;
@@ -21,21 +20,19 @@ export class PythLazerClient {
         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() {
+   * 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) {
+   * 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) {
         const token = config.token;
         // Collect and remove trailing slash from URLs
         const metadataServiceUrl = (config.metadataServiceUrl ?? DEFAULT_METADATA_SERVICE_URL).replace(/\/+$/, "");
@@ -49,26 +46,23 @@ export class PythLazerClient {
         return new PythLazerClient(token, metadataServiceUrl, priceServiceUrl, logger, 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) {
+   * 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) {
         const wsp = this.getWebSocketPool();
-        wsp.addMessageListener(async (data) => {
+        wsp.addMessageListener(async (data)=>{
             if (typeof data == "string") {
                 handler({
                     type: "json",
-                    value: JSON.parse(data),
+                    value: JSON.parse(data)
                 });
                 return;
             }
             const buffData = await bufferFromWebsocketData(data);
             let pos = 0;
-            const magic = buffData
-                .subarray(pos, pos + UINT32_NUM_BYTES)
-                .readUint32LE();
+            const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
             pos += UINT32_NUM_BYTES;
             if (magic != BINARY_UPDATE_FORMAT_MAGIC_LE) {
                 throw new Error("binary update format magic mismatch");
@@ -76,36 +70,32 @@ export class PythLazerClient {
             // TODO: some uint64 values may not be representable as Number.
             const subscriptionId = Number(buffData.subarray(pos, pos + UINT64_NUM_BYTES).readBigInt64BE());
             pos += UINT64_NUM_BYTES;
-            const value = { subscriptionId };
-            while (pos < buffData.length) {
-                const len = buffData
-                    .subarray(pos, pos + UINT16_NUM_BYTES)
-                    .readUint16BE();
+            const value = {
+                subscriptionId
+            };
+            while(pos < buffData.length){
+                const len = buffData.subarray(pos, pos + UINT16_NUM_BYTES).readUint16BE();
                 pos += UINT16_NUM_BYTES;
-                const magic = buffData
-                    .subarray(pos, pos + UINT32_NUM_BYTES)
-                    .readUint32LE();
+                const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
                 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 {
+                } else {
                     throw new Error(`unknown magic:  ${magic.toString()}`);
                 }
                 pos += len;
             }
-            handler({ type: "binary", value });
+            handler({
+                type: "binary",
+                value
+            });
         });
     }
     subscribe(request) {
@@ -124,11 +114,10 @@ export class PythLazerClient {
         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) {
+   * 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);
     }
@@ -137,27 +126,25 @@ export class PythLazerClient {
         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 = {}) {
+   * 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,
+            ...options.headers
         };
         return fetch(url, {
             ...options,
-            headers,
+            headers
         });
     }
     /**
-     * Queries the symbols endpoint to get available price feed symbols.
-     * @param params - Optional query parameters to filter symbols
-     * @returns Promise resolving to array of symbol information
-     */
-    async getSymbols(params) {
+   * Queries the symbols endpoint to get available price feed symbols.
+   * @param params - Optional query parameters to filter symbols
+   * @returns Promise resolving to array of symbol information
+   */ async getSymbols(params) {
         const url = new URL(`${this.metadataServiceUrl}/v1/symbols`);
         if (params?.query) {
             url.searchParams.set("query", params.query);
@@ -170,61 +157,62 @@ export class PythLazerClient {
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch symbols: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * Queries the latest price endpoint to get current price data.
-     * @param params - Parameters for the latest price request
-     * @returns Promise resolving to JsonUpdate with current price data
-     */
-    async getLatestPrice(params) {
+   * Queries the latest price endpoint to get current price data.
+   * @param params - Parameters for the latest price request
+   * @returns Promise resolving to JsonUpdate with current price data
+   */ async getLatestPrice(params) {
         const url = `${this.priceServiceUrl}/v1/latest_price`;
         try {
             const body = JSON.stringify(params);
-            this.logger.debug("getLatestPrice", { url, body });
+            this.logger.debug("getLatestPrice", {
+                url,
+                body
+            });
             const response = await this.authenticatedFetch(url, {
                 method: "POST",
                 headers: {
-                    "Content-Type": "application/json",
+                    "Content-Type": "application/json"
                 },
-                body: body,
+                body: body
             });
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch latest price: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * Queries the price endpoint to get historical price data at a specific timestamp.
-     * @param params - Parameters for the price request including timestamp
-     * @returns Promise resolving to JsonUpdate with price data at the specified time
-     */
-    async getPrice(params) {
+   * Queries the price endpoint to get historical price data at a specific timestamp.
+   * @param params - Parameters for the price request including timestamp
+   * @returns Promise resolving to JsonUpdate with price data at the specified time
+   */ async getPrice(params) {
         const url = `${this.priceServiceUrl}/v1/price`;
         try {
             const body = JSON.stringify(params);
-            this.logger.debug("getPrice", { url, body });
+            this.logger.debug("getPrice", {
+                url,
+                body
+            });
             const response = await this.authenticatedFetch(url, {
                 method: "POST",
                 headers: {
-                    "Content-Type": "application/json",
+                    "Content-Type": "application/json"
                 },
-                body: body,
+                body: body
             });
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch price: ${error instanceof Error ? error.message : String(error)}`);
         }
     }

package/dist/esm/emitter/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * T defines the "Event Map".
+ * Example: `{ 'data': (payload: string) => void; 'error': (err: Error) => void; }`
+ */
+export declare abstract class IsomorphicEventEmitter<T extends Record<string, (...args: any[]) => void>> {
+    private listeners;
+    /**
+     * Register a callback for a specific event.
+     */
+    on<K extends keyof T>(eventName: K, callback: T[K]): void;
+    /**
+     * Registers a callback for a specific event that
+     * will only be executed a single time i.e. the first occurence.
+     * After this, the handler will be automatically removed and cleaned up.
+     */
+    once<K extends keyof T>(eventName: K, callback: T[K]): void;
+    /**
+     * Remove a callback from a specific event.
+     * If no specific callback is specified when off() is called,
+     * ALL event handler callbacks for the given eventName will be removed
+     * at once.
+     */
+    off<K extends keyof T>(eventName: K, callback?: T[K]): void;
+    /**
+     * Protected method to retrieve listeners for internal triggering.
+     * This allows the child class to decide how/when to execute them.
+     */
+    protected getListeners<K extends keyof T>(eventName: K): T[K][];
+}

package/dist/esm/emitter/index.mjs

@@ -0,0 +1,43 @@
+/**
+ * T defines the "Event Map".
+ * Example: `{ 'data': (payload: string) => void; 'error': (err: Error) => void; }`
+ */ export class IsomorphicEventEmitter {
+    listeners = new Map();
+    /**
+   * Register a callback for a specific event.
+   */ on(eventName, callback) {
+        const currentListeners = this.listeners.get(eventName) ?? [];
+        this.listeners.set(eventName, [
+            ...currentListeners,
+            callback
+        ]);
+    }
+    /**
+   * Registers a callback for a specific event that
+   * will only be executed a single time i.e. the first occurence.
+   * After this, the handler will be automatically removed and cleaned up.
+   */ once(eventName, callback) {
+        const wrappedCallback = (...args)=>{
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            callback(...args);
+            this.off(eventName, wrappedCallback);
+        };
+        this.on(eventName, wrappedCallback);
+    }
+    /**
+   * Remove a callback from a specific event.
+   * If no specific callback is specified when off() is called,
+   * ALL event handler callbacks for the given eventName will be removed
+   * at once.
+   */ off(eventName, callback) {
+        const cbIsFunc = typeof callback === "function";
+        const currentListeners = this.listeners.get(eventName) ?? [];
+        this.listeners.set(eventName, currentListeners.filter((cb)=>cbIsFunc && cb !== callback));
+    }
+    /**
+   * Protected method to retrieve listeners for internal triggering.
+   * This allows the child class to decide how/when to execute them.
+   */ getListeners(eventName) {
+        return this.listeners.get(eventName) ?? [];
+    }
+}

package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+export * from "./client.mjs";
+export * from "./protocol.mjs";
+export * from "./constants.mjs";

package/dist/esm/package.json

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

package/dist/esm/protocol.d.ts

@@ -1,7 +1,7 @@
 export type Format = "evm" | "solana" | "leEcdsa" | "leUnsigned";
 export type DeliveryFormat = "json" | "binary";
 export type JsonBinaryEncoding = "base64" | "hex";
-export type PriceFeedProperty = "price" | "bestBidPrice" | "bestAskPrice" | "exponent" | "publisherCount" | "confidence";
+export type PriceFeedProperty = "price" | "bestBidPrice" | "bestAskPrice" | "exponent" | "publisherCount" | "confidence" | "fundingRate" | "fundingTimestamp" | "fundingRateInterval";
 export type Channel = "real_time" | "fixed_rate@50ms" | "fixed_rate@200ms";
 export type Request = {
     type: "subscribe";

package/dist/esm/{protocol.js → protocol.mjs}

@@ -4,9 +4,9 @@ export const FORMAT_MAGICS_LE = {
     EVM: 2_593_727_018,
     SOLANA: 2_182_742_457,
     LE_ECDSA: 1_296_547_300,
-    LE_UNSIGNED: 1_499_680_012,
+    LE_UNSIGNED: 1_499_680_012
 };
-export var CustomSocketClosureCodes;
-(function (CustomSocketClosureCodes) {
+export var CustomSocketClosureCodes = /*#__PURE__*/ function(CustomSocketClosureCodes) {
     CustomSocketClosureCodes[CustomSocketClosureCodes["CLIENT_TIMEOUT_BUT_RECONNECTING"] = 4000] = "CLIENT_TIMEOUT_BUT_RECONNECTING";
-})(CustomSocketClosureCodes || (CustomSocketClosureCodes = {}));
+    return CustomSocketClosureCodes;
+}({});

package/dist/esm/socket/{resilient-websocket.js → resilient-websocket.mjs}

@@ -1,7 +1,7 @@
 import WebSocket from "isomorphic-ws";
 import { dummyLogger } from "ts-log";
-import { CustomSocketClosureCodes } from "../protocol.js";
-import { envIsBrowserOrWorker } from "../util/env-util.js";
+import { CustomSocketClosureCodes } from "../protocol.mjs";
+import { envIsBrowserOrWorker } from "../util/env-util.mjs";
 const DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS = 5000; // 5 seconds
 const DEFAULT_MAX_RETRY_DELAY_MS = 1000; // 1 second'
 const DEFAULT_LOG_AFTER_RETRY_COUNT = 10;
@@ -30,33 +30,29 @@ export class ResilientWebSocket {
     onError;
     onMessage;
     onReconnect;
-    constructor(config) {
+    constructor(config){
         this.endpoint = config.endpoint;
         this.wsOptions = config.wsOptions;
         this.logger = config.logger ?? dummyLogger;
-        this.heartbeatTimeoutDurationMs =
-            config.heartbeatTimeoutDurationMs ??
-                DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS;
+        this.heartbeatTimeoutDurationMs = config.heartbeatTimeoutDurationMs ?? DEFAULT_HEARTBEAT_TIMEOUT_DURATION_MS;
         this.maxRetryDelayMs = config.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
-        this.logAfterRetryCount =
-            config.logAfterRetryCount ?? DEFAULT_LOG_AFTER_RETRY_COUNT;
+        this.logAfterRetryCount = config.logAfterRetryCount ?? DEFAULT_LOG_AFTER_RETRY_COUNT;
         this.wsFailedAttempts = 0;
-        this.onError = (error) => {
+        this.onError = (error)=>{
             void error;
         };
-        this.onMessage = (data) => {
+        this.onMessage = (data)=>{
             void data;
         };
-        this.onReconnect = () => {
-            // Empty function, can be set by the user.
+        this.onReconnect = ()=>{
+        // Empty function, can be set by the user.
         };
     }
     send(data) {
         this.logger.debug(`Sending message`);
         if (this.isConnected()) {
             this.wsClient.send(data);
-        }
-        else {
+        } else {
             this.logger.warn(`WebSocket to ${this.endpoint} is not connected. Cannot send message.`);
         }
     }
@@ -80,33 +76,32 @@ export class ResilientWebSocket {
         // so we need to ensure it's not included if we're running in that environment:
         // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/WebSocket#protocols
         this.wsClient = new WebSocket(this.endpoint, envIsBrowserOrWorker() ? undefined : this.wsOptions);
-        this.wsClient.addEventListener("open", () => {
+        this.wsClient.addEventListener("open", ()=>{
             this.logger.info("WebSocket connection established");
             this.wsFailedAttempts = 0;
             this._isReconnecting = false;
             this.resetHeartbeat();
             this.onReconnect();
         });
-        this.wsClient.addEventListener("close", (e) => {
+        this.wsClient.addEventListener("close", (e)=>{
             if (this.wsUserClosed) {
                 this.logger.info(`WebSocket connection to ${this.endpoint} closed by user`);
-            }
-            else {
+            } else {
                 if (this.shouldLogRetry()) {
                     this.logger.warn(`WebSocket connection to ${this.endpoint} closed unexpectedly: Code: ${e.code.toString()}`);
                 }
                 this.handleReconnect();
             }
         });
-        this.wsClient.addEventListener("error", (event) => {
+        this.wsClient.addEventListener("error", (event)=>{
             this.onError(event);
         });
-        this.wsClient.addEventListener("message", (event) => {
+        this.wsClient.addEventListener("message", (event)=>{
             this.resetHeartbeat();
             this.onMessage(event.data);
         });
         if ("on" in this.wsClient) {
-            this.wsClient.on("ping", () => {
+            this.wsClient.on("ping", ()=>{
                 this.logger.info("Ping received");
                 this.resetHeartbeat();
             });
@@ -116,14 +111,13 @@ export class ResilientWebSocket {
         if (this.heartbeatTimeout !== undefined) {
             clearTimeout(this.heartbeatTimeout);
         }
-        this.heartbeatTimeout = setTimeout(() => {
+        this.heartbeatTimeout = setTimeout(()=>{
             const warnMsg = "Connection timed out. Reconnecting...";
             this.logger.warn(warnMsg);
             if (this.wsClient) {
                 if (typeof this.wsClient.terminate === "function") {
                     this.wsClient.terminate();
-                }
-                else {
+                } else {
                     // terminate is an implementation detail of the node-friendly
                     // https://www.npmjs.com/package/ws package, but is not a native WebSocket API,
                     // so we have to use the close method
@@ -148,11 +142,9 @@ export class ResilientWebSocket {
         this.wsClient = undefined;
         this._isReconnecting = true;
         if (this.shouldLogRetry()) {
-            this.logger.error("Connection closed unexpectedly or because of timeout. Reconnecting after " +
-                String(this.retryDelayMs()) +
-                "ms.");
+            this.logger.error("Connection closed unexpectedly or because of timeout. Reconnecting after " + String(this.retryDelayMs()) + "ms.");
         }
-        this.retryTimeout = setTimeout(() => {
+        this.retryTimeout = setTimeout(()=>{
             this.startWebSocket();
         }, this.retryDelayMs());
     }
@@ -164,14 +156,13 @@ export class ResilientWebSocket {
         this.wsUserClosed = true;
     }
     /**
-     * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.
-     *
-     * The delay increases exponentially with each attempt, starting at 20ms for the first attempt,
-     * and is capped at maxRetryDelayMs for attempts greater than or equal to 10.
-     *
-     * @returns The calculated delay in milliseconds before the next retry.
-     */
-    retryDelayMs() {
+   * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.
+   *
+   * The delay increases exponentially with each attempt, starting at 20ms for the first attempt,
+   * and is capped at maxRetryDelayMs for attempts greater than or equal to 10.
+   *
+   * @returns The calculated delay in milliseconds before the next retry.
+   */ retryDelayMs() {
         if (this.wsFailedAttempts >= 10) {
             return this.maxRetryDelayMs;
         }

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

@@ -4,14 +4,47 @@ import type { Logger } from "ts-log";
 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) => void | Promise<void>;
 export type WebSocketPoolConfig = {
-    urls?: string[];
+    /**
+     * Maximum number of open, parallel websocket connections
+     * @defaultValue 3
+     */
     numConnections?: number;
-    rwsConfig?: Omit<ResilientWebSocketConfig, "logger" | "endpoint">;
+    /**
+     * Callback that will be executed whenever an error
+     * message or an error event occurs on an individual WebSocket connection
+     *
+     * @deprecated use onWebSocketError() instead
+     */
     onError?: (error: ErrorEvent) => void;
+    /**
+     * Callback that will be executed whenever an error
+     * message or an error event occurs on an individual WebSocket connection
+     */
+    onWebSocketError?: (error: ErrorEvent) => void;
+    /**
+     * Callback that will be executed whenever an error occurs
+     * directly within the WebSocket pool. These can typically
+     * be errors that would normally manifest as "unhandledRejection" or "uncaughtException"
+     * errors.
+     */
+    onWebSocketPoolError?: (error: Error) => void;
+    /**
+     * Additional websocket configuration
+     */
+    rwsConfig?: Omit<ResilientWebSocketConfig, "logger" | "endpoint">;
+    /**
+     * Pyth URLs to use when creating a connection
+     */
+    urls?: string[];
+};
+export type WebSocketPoolEvents = {
+    error: (error: Error) => void;
+    shutdown: () => void;
 };
-export declare class WebSocketPool {
+export declare class WebSocketPool extends IsomorphicEventEmitter<WebSocketPoolEvents> {
     private readonly logger;
     rwsPool: ResilientWebSocket[];
     private cache;
@@ -30,6 +63,7 @@ export declare class WebSocketPool {
      * @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>;
+    private emitPoolError;
     /**
      * Checks for error responses in JSON messages and throws appropriate errors
      */