@pythnetwork/pyth-lazer-sdk 0.5.1 → 2.0.0

package/dist/cjs/client.d.ts

@@ -1,5 +1,5 @@
-import type { Logger } from "ts-log";
 import type { ParsedPayload, Request, Response } from "./protocol.js";
+import type { WebSocketPoolConfig } from "./socket/websocket-pool.js";
 export type BinaryResponse = {
     subscriptionId: number;
     evm?: Buffer | undefined;
@@ -25,7 +25,7 @@ export declare class PythLazerClient {
      * @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>;
+    static create(config: WebSocketPoolConfig): 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.
@@ -33,9 +33,9 @@ export declare class PythLazerClient {
      * or a binary response containing EVM, Solana, or parsed payload data.
      */
     addMessageListener(handler: (event: JsonOrBinaryResponse) => void): void;
-    subscribe(request: Request): Promise<void>;
-    unsubscribe(subscriptionId: number): Promise<void>;
-    send(request: Request): Promise<void>;
+    subscribe(request: Request): void;
+    unsubscribe(subscriptionId: number): void;
+    send(request: Request): 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()`.

package/dist/cjs/client.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythLazerClient = void 0;
-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;
@@ -19,8 +18,8 @@ class PythLazerClient {
      * @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);
+    static async create(config) {
+        const wsp = await websocket_pool_js_1.WebSocketPool.create(config);
         return new PythLazerClient(wsp);
     }
     /**
@@ -81,17 +80,17 @@ class PythLazerClient {
             }
         });
     }
-    async subscribe(request) {
+    subscribe(request) {
         if (request.type !== "subscribe") {
             throw new Error("Request must be a subscribe request");
         }
-        await this.wsp.addSubscription(request);
+        this.wsp.addSubscription(request);
     }
-    async unsubscribe(subscriptionId) {
-        await this.wsp.removeSubscription(subscriptionId);
+    unsubscribe(subscriptionId) {
+        this.wsp.removeSubscription(subscriptionId);
     }
-    async send(request) {
-        await this.wsp.sendRequest(request);
+    send(request) {
+        this.wsp.sendRequest(request);
     }
     /**
      * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.

package/dist/cjs/constants.d.ts

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

package/dist/cjs/constants.js

@@ -1,6 +1,5 @@
 "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");
+exports.SOLANA_LAZER_STORAGE_ID = exports.SOLANA_LAZER_PROGRAM_ID = void 0;
+exports.SOLANA_LAZER_PROGRAM_ID = "pytd2yyk641x7ak7mkaasSJVXh6YYZnC7wTmtgAyxPt";
+exports.SOLANA_LAZER_STORAGE_ID = "3rdJbqfnagQ4yx9HXJViD4zc4xpiSqmFsKpPuSCQVyQL";

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -16,5 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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

@@ -2,29 +2,48 @@ import type { ClientRequestArgs } from "node:http";
 import type { ClientOptions, ErrorEvent } from "isomorphic-ws";
 import WebSocket from "isomorphic-ws";
 import type { Logger } from "ts-log";
-export declare class ResilientWebSocket {
+export type ResilientWebSocketConfig = {
     endpoint: string;
+    wsOptions?: ClientOptions | ClientRequestArgs | undefined;
+    logger?: Logger;
+    heartbeatTimeoutDurationMs?: number;
+    maxRetryDelayMs?: number;
+    logAfterRetryCount?: number;
+};
+export declare class ResilientWebSocket {
+    private endpoint;
+    private wsOptions?;
+    private logger;
+    private heartbeatTimeoutDurationMs;
+    private maxRetryDelayMs;
+    private logAfterRetryCount;
     wsClient: undefined | WebSocket;
     wsUserClosed: boolean;
-    private wsOptions;
     private wsFailedAttempts;
-    private heartbeatTimeout;
-    private logger;
-    private connectionPromise;
-    private resolveConnection;
-    private rejectConnection;
+    private heartbeatTimeout?;
+    private retryTimeout?;
     private _isReconnecting;
-    get isReconnecting(): boolean;
-    get isConnected(): boolean;
+    isReconnecting(): boolean;
+    isConnected(): this is this & {
+        wsClient: WebSocket;
+    };
+    private shouldLogRetry;
     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>;
+    constructor(config: ResilientWebSocketConfig);
+    send(data: string | Buffer): void;
+    startWebSocket(): void;
     private resetHeartbeat;
-    private waitForMaybeReadyWebSocket;
-    private handleClose;
-    private restartUnexpectedClosedWebsocket;
+    private handleReconnect;
     closeWebSocket(): void;
+    /**
+     * 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.
+     */
+    private retryDelayMs;
 }

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

@@ -5,38 +5,49 @@ var __importDefault = (this && this.__importDefault) || function (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;
+const ts_log_1 = require("ts-log");
+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;
 class ResilientWebSocket {
     endpoint;
-    wsClient;
-    wsUserClosed;
     wsOptions;
+    logger;
+    heartbeatTimeoutDurationMs;
+    maxRetryDelayMs;
+    logAfterRetryCount;
+    wsClient;
+    wsUserClosed = false;
     wsFailedAttempts;
     heartbeatTimeout;
-    logger;
-    connectionPromise;
-    resolveConnection;
-    rejectConnection;
+    retryTimeout;
     _isReconnecting = false;
-    get isReconnecting() {
+    isReconnecting() {
         return this._isReconnecting;
     }
-    get isConnected() {
+    isConnected() {
         return this.wsClient?.readyState === isomorphic_ws_1.default.OPEN;
     }
+    shouldLogRetry() {
+        return this.wsFailedAttempts % this.logAfterRetryCount === 0;
+    }
     onError;
     onMessage;
     onReconnect;
-    constructor(endpoint, wsOptions, logger) {
-        this.endpoint = endpoint;
-        this.wsOptions = wsOptions;
-        this.logger = logger;
+    constructor(config) {
+        this.endpoint = config.endpoint;
+        this.wsOptions = config.wsOptions;
+        this.logger = config.logger ?? ts_log_1.dummyLogger;
+        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.wsFailedAttempts = 0;
         this.onError = (error) => {
-            this.logger?.error(error.error);
+            void error;
         };
-        this.wsUserClosed = true;
         this.onMessage = (data) => {
             void data;
         };
@@ -44,144 +55,117 @@ class ResilientWebSocket {
             // 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.");
+    send(data) {
+        this.logger.debug(`Sending message`);
+        if (this.isConnected()) {
+            this.wsClient.send(data);
         }
         else {
-            this.wsClient.send(data);
+            this.logger.warn(`WebSocket to ${this.endpoint} is not connected. Cannot send message.`);
         }
     }
-    async startWebSocket() {
+    startWebSocket() {
+        if (this.wsUserClosed) {
+            this.logger.error("Connection was explicitly closed by user. Will not reconnect.");
+            return;
+        }
         if (this.wsClient !== undefined) {
-            // If there's an existing connection attempt, wait for it
-            if (this.connectionPromise) {
-                return this.connectionPromise;
-            }
+            this.logger.info("WebSocket client already started.");
             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);
+        if (this.wsFailedAttempts == 0) {
+            this.logger.info(`Creating Web Socket client`);
+        }
+        if (this.retryTimeout !== undefined) {
+            clearTimeout(this.retryTimeout);
+            this.retryTimeout = undefined;
+        }
         this.wsClient = new isomorphic_ws_1.default(this.endpoint, this.wsOptions);
-        this.wsUserClosed = false;
         this.wsClient.addEventListener("open", () => {
+            this.logger.info("WebSocket connection established");
             this.wsFailedAttempts = 0;
-            this.resetHeartbeat();
-            clearTimeout(timeoutId);
             this._isReconnecting = false;
-            this.resolveConnection?.();
+            this.resetHeartbeat();
+            this.onReconnect();
+        });
+        this.wsClient.addEventListener("close", (e) => {
+            if (this.wsUserClosed) {
+                this.logger.info(`WebSocket connection to ${this.endpoint} closed by user`);
+            }
+            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.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.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.logger.warn("Connection timed out. Reconnecting...");
             this.wsClient?.terminate();
-            void this.restartUnexpectedClosedWebsocket();
-        }, HEARTBEAT_TIMEOUT_DURATION);
+            this.handleReconnect();
+        }, this.heartbeatTimeoutDurationMs);
     }
-    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);
-            }
+    handleReconnect() {
+        if (this.wsUserClosed) {
+            this.logger.info("WebSocket connection closed by user, not reconnecting.");
+            return;
         }
-    }
-    async handleClose() {
         if (this.heartbeatTimeout !== undefined) {
             clearTimeout(this.heartbeatTimeout);
         }
-        if (this.wsUserClosed) {
-            this.logger?.info("The connection has been closed successfully.");
+        if (this.retryTimeout !== undefined) {
+            clearTimeout(this.retryTimeout);
         }
-        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) +
+        this.wsFailedAttempts += 1;
+        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.");
-            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();
+        this.retryTimeout = setTimeout(() => {
+            this.startWebSocket();
+        }, this.retryDelayMs());
     }
     closeWebSocket() {
         if (this.wsClient !== undefined) {
-            const client = this.wsClient;
+            this.wsClient.close();
             this.wsClient = undefined;
-            this.connectionPromise = undefined;
-            this.resolveConnection = undefined;
-            this.rejectConnection = undefined;
-            client.close();
         }
         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() {
+        if (this.wsFailedAttempts >= 10) {
+            return this.maxRetryDelayMs;
+        }
+        return Math.min(2 ** this.wsFailedAttempts * 10, this.maxRetryDelayMs);
+    }
 }
 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

@@ -1,7 +1,17 @@
+import type { ErrorEvent } from "isomorphic-ws";
 import WebSocket from "isomorphic-ws";
 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";
+export type WebSocketPoolConfig = {
+    urls: string[];
+    token: string;
+    numConnections?: number;
+    logger?: Logger;
+    rwsConfig?: Omit<ResilientWebSocketConfig, "logger" | "endpoint">;
+    onError?: (error: ErrorEvent) => void;
+};
 export declare class WebSocketPool {
     private readonly logger;
     rwsPool: ResilientWebSocket[];
@@ -20,7 +30,7 @@ export declare class WebSocketPool {
      * @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>;
+    static create(config: WebSocketPoolConfig): Promise<WebSocketPool>;
     /**
      * Checks for error responses in JSON messages and throws appropriate errors
      */
@@ -30,9 +40,9 @@ export declare class WebSocketPool {
      * 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>;
+    sendRequest(request: Request): void;
+    addSubscription(request: Request): void;
+    removeSubscription(subscriptionId: number): void;
     addMessageListener(handler: (data: WebSocket.Data) => void): void;
     /**
      * Calls the handler if all websocket connections are currently down or in reconnecting state.
@@ -40,6 +50,7 @@ export declare class WebSocketPool {
      */
     addAllConnectionsDownListener(handler: () => void): void;
     private areAllConnectionsDown;
+    private isAnyConnectionEstablished;
     private checkConnectionStates;
     shutdown(): void;
 }

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

@@ -7,7 +7,7 @@ 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;
+const DEFAULT_NUM_CONNECTIONS = 4;
 class WebSocketPool {
     logger;
     rwsPool;
@@ -17,7 +17,7 @@ class WebSocketPool {
     allConnectionsDownListeners;
     wasAllDown = true;
     checkConnectionStatesInterval;
-    constructor(logger = ts_log_1.dummyLogger) {
+    constructor(logger) {
         this.logger = logger;
         this.rwsPool = [];
         this.cache = new ttlcache_1.default({ ttl: 1000 * 10 }); // TTL of 10 seconds
@@ -37,24 +37,30 @@ class WebSocketPool {
      * @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) {
+    static async create(config) {
+        if (config.urls.length === 0) {
             throw new Error("No URLs provided");
         }
+        const logger = config.logger ?? ts_log_1.dummyLogger;
         const pool = new WebSocketPool(logger);
-        // Create all websocket instances
-        const connectionPromises = [];
+        const numConnections = config.numConnections ?? DEFAULT_NUM_CONNECTIONS;
         for (let i = 0; i < numConnections; i++) {
-            const url = urls[i % urls.length];
+            const url = config.urls[i % config.urls.length];
             if (!url) {
                 throw new Error(`URLs must not be null or empty`);
             }
             const wsOptions = {
+                ...config.rwsConfig?.wsOptions,
                 headers: {
-                    Authorization: `Bearer ${token}`,
+                    Authorization: `Bearer ${config.token}`,
                 },
             };
-            const rws = new resilient_websocket_js_1.ResilientWebSocket(url, wsOptions, logger);
+            const rws = new resilient_websocket_js_1.ResilientWebSocket({
+                ...config.rwsConfig,
+                endpoint: url,
+                wsOptions,
+                logger,
+            });
             // If a websocket client unexpectedly disconnects, ResilientWebSocket will reestablish
             // the connection and call the onReconnect callback.
             rws.onReconnect = () => {
@@ -63,29 +69,26 @@ class WebSocketPool {
                 }
                 for (const [, request] of pool.subscriptions) {
                     try {
-                        void rws.send(JSON.stringify(request));
+                        rws.send(JSON.stringify(request));
                     }
                     catch (error) {
                         pool.logger.error("Failed to resend subscription on reconnect:", error);
                     }
                 }
             };
+            if (config.onError) {
+                rws.onError = config.onError;
+            }
             // 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);
+            rws.startWebSocket();
         }
-        catch (error) {
-            // If any connection fails, clean up and throw
-            pool.shutdown();
-            throw error;
+        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(`Successfully established ${numConnections.toString()} redundant WebSocket connections`);
+        pool.logger.info(`At least one WebSocket connection is established. WebSocketPool is ready.`);
         return pool;
     }
     /**
@@ -120,32 +123,25 @@ class WebSocketPool {
             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);
+    sendRequest(request) {
+        for (const rws of this.rwsPool) {
+            rws.send(JSON.stringify(request));
+        }
     }
-    async addSubscription(request) {
+    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);
+        this.sendRequest(request);
     }
-    async removeSubscription(subscriptionId) {
+    removeSubscription(subscriptionId) {
         this.subscriptions.delete(subscriptionId);
         const request = {
             type: "unsubscribe",
             subscriptionId,
         };
-        await this.sendRequest(request);
+        this.sendRequest(request);
     }
     addMessageListener(handler) {
         this.messageListeners.push(handler);
@@ -158,7 +154,10 @@ class WebSocketPool {
         this.allConnectionsDownListeners.push(handler);
     }
     areAllConnectionsDown() {
-        return this.rwsPool.every((ws) => !ws.isConnected || ws.isReconnecting);
+        return this.rwsPool.every((ws) => !ws.isConnected() || ws.isReconnecting());
+    }
+    isAnyConnectionEstablished() {
+        return this.rwsPool.some((ws) => ws.isConnected());
     }
     checkConnectionStates() {
         const allDown = this.areAllConnectionsDown();