@pythnetwork/pyth-lazer-sdk 6.2.0 → 6.2.2

package/dist/cjs/client.cjs

@@ -22,39 +22,64 @@ class PythLazerClient {
     priceServiceUrl;
     token;
     wsp;
-    abortSignal;
-    constructor({ abortSignal, logger, metadataServiceUrl, priceServiceUrl, token, wsp }){
-        this.abortSignal = abortSignal;
+    constructor({ logger, metadataServiceUrl, priceServiceUrl, token, wsp }){
         this.logger = logger;
         this.metadataServiceUrl = metadataServiceUrl;
         this.priceServiceUrl = priceServiceUrl;
         this.token = token;
         this.wsp = wsp;
-        this.bindHandlers();
     }
     /**
    * 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 ?? _constants.DEFAULT_METADATA_SERVICE_URL).replace(/\/+$/, "");
         const priceServiceUrl = (config.priceServiceUrl ?? _constants.DEFAULT_PRICE_SERVICE_URL).replace(/\/+$/, "");
         const logger = config.logger ?? _tslog.dummyLogger;
-        // 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
-        const wsp = await _websocketpool.WebSocketPool.create(config.webSocketPoolConfig, token, config.abortSignal, logger);
-        const client = new PythLazerClient({
-            abortSignal: config.abortSignal,
-            logger,
-            metadataServiceUrl,
-            priceServiceUrl,
-            token,
-            wsp
-        });
-        return client;
+        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.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;
+        }
     }
     /**
    * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
@@ -108,11 +133,6 @@ class PythLazerClient {
             });
         });
     }
-    /**
-   * binds any internal event handlers
-   */ bindHandlers() {
-        this.abortSignal?.addEventListener("abort", this.abortHandler);
-    }
     subscribe(request) {
         if (request.type !== "subscribe") {
             throw new Error("Request must be a subscribe request");
@@ -150,14 +170,7 @@ class PythLazerClient {
    */ addConnectionReconnectListener(handler) {
         this.wsp.addConnectionReconnectListener(handler);
     }
-    /**
-   * called if and only if a user provided an abort signal and it was aborted
-   */ abortHandler = ()=>{
-        this.shutdown();
-    };
     shutdown() {
-        // Clean up abort signal listener to prevent memory leak
-        this.abortSignal?.removeEventListener("abort", this.abortHandler);
         this.wsp.shutdown();
     }
     /**

package/dist/cjs/client.d.ts

@@ -18,8 +18,9 @@ export type JsonOrBinaryResponse = {
 };
 export type LazerClientConfig = {
     /**
-     * if provided and the signal is detected as canceled,
-     * all active listeners and connections will be unbound and killed.
+     * 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;
@@ -34,7 +35,6 @@ export declare class PythLazerClient {
     private priceServiceUrl;
     private token;
     private wsp;
-    private abortSignal;
     private constructor();
     /**
      * Creates a new PythLazerClient instance.
@@ -48,10 +48,6 @@ export declare class PythLazerClient {
      * or a binary response containing EVM, Solana, or parsed payload data.
      */
     addMessageListener(handler: (event: JsonOrBinaryResponse) => void): void;
-    /**
-     * binds any internal event handlers
-     */
-    bindHandlers(): void;
     subscribe(request: Request): void;
     unsubscribe(subscriptionId: number): void;
     send(request: Request): void;
@@ -76,10 +72,6 @@ export declare class PythLazerClient {
      * @param handler - Function to be called with connection index and endpoint URL
      */
     addConnectionReconnectListener(handler: (connectionIndex: number, endpoint: string) => void): void;
-    /**
-     * called if and only if a user provided an abort signal and it was aborted
-     */
-    protected abortHandler: () => void;
     shutdown(): void;
     /**
      * Private helper method to make authenticated HTTP requests with Bearer token

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

@@ -84,46 +84,68 @@ class ResilientWebSocket {
             this.logger.info("WebSocket client already started.");
             return;
         }
-        if (this.wsFailedAttempts == 0) {
+        if (this.wsFailedAttempts === 0) {
             this.logger.info(`Creating Web Socket client`);
         }
         if (this.retryTimeout !== undefined) {
             clearTimeout(this.retryTimeout);
             this.retryTimeout = undefined;
         }
-        // browser constructor supports a different 2nd argument for the constructor,
-        // 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 _isomorphicws.default(this.endpoint, (0, _envutil.envIsBrowserOrWorker)() ? undefined : this.wsOptions);
-        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)=>{
-            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()}`);
+        // we wrap the new WebSocket() construction in a try / catch because,
+        // if one of our instances legitimately goes down or there's some network
+        // error that impacts connectivity, the WebSocket constructor will throw
+        // an uncaught DOMException in the browser (or equivalent in Node, Bun or Deno)
+        // and potentially blow up the process (if running in Node, Bun or Deno)
+        try {
+            // browser constructor supports a different 2nd argument for the constructor,
+            // 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 _isomorphicws.default(this.endpoint, (0, _envutil.envIsBrowserOrWorker)() ? undefined : this.wsOptions);
+            this.wsClient.addEventListener("open", ()=>{
+                this.logger.info("WebSocket connection established");
+                this.wsFailedAttempts = 0;
+                this._isReconnecting = false;
+                this.resetHeartbeat();
+                try {
+                    this.onReconnect();
+                } catch (error) {
+                    this.logger.error("Error in onReconnect callback:", error);
                 }
-                this.handleReconnect();
-            }
-        });
-        this.wsClient.addEventListener("error", (event)=>{
-            this.onError(event);
-        });
-        this.wsClient.addEventListener("message", (event)=>{
-            this.resetHeartbeat();
-            this.onMessage(event.data);
-        });
-        if ("on" in this.wsClient) {
-            this.wsClient.on("ping", ()=>{
-                this.logger.info("Ping received");
+            });
+            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)=>{
+                try {
+                    this.onError(event);
+                } catch (error) {
+                    this.logger.error("Error in onError callback:", error);
+                }
+            });
+            this.wsClient.addEventListener("message", (event)=>{
                 this.resetHeartbeat();
+                try {
+                    this.onMessage(event.data);
+                } catch (error) {
+                    this.logger.error("Error in onMessage callback:", error);
+                }
             });
+            if (typeof this.wsClient?.on === "function") {
+                this.wsClient.on("ping", ()=>{
+                    this.logger.debug("Ping received");
+                    this.resetHeartbeat();
+                });
+            }
+        } catch (error) {
+            this.logger.error("Failed to create WebSocket client:", error);
+            this.handleReconnect();
         }
     }
     resetHeartbeat() {
@@ -133,7 +155,11 @@ class ResilientWebSocket {
         this.heartbeatTimeout = setTimeout(()=>{
             const warnMsg = "Connection timed out. Reconnecting...";
             this.logger.warn(warnMsg);
-            this.onTimeout();
+            try {
+                this.onTimeout();
+            } catch (error) {
+                this.logger.error("Error in onTimeout callback:", error);
+            }
             if (this.wsClient) {
                 if (typeof this.wsClient.terminate === "function") {
                     this.wsClient.terminate();
@@ -144,7 +170,8 @@ class ResilientWebSocket {
                     this.wsClient.close(_protocol.CustomSocketClosureCodes.CLIENT_TIMEOUT_BUT_RECONNECTING, warnMsg);
                 }
             }
-            this.handleReconnect();
+        // No direct call to handleReconnect() here
+        // terminate/close will trigger the 'close' event, which will call it.
         }, this.heartbeatTimeoutDurationMs);
     }
     handleReconnect() {
@@ -169,11 +196,12 @@ class ResilientWebSocket {
         }, this.retryDelayMs());
     }
     closeWebSocket() {
-        if (this.wsClient !== undefined) {
+        // immediately block duplicate calls to this function
+        this.wsUserClosed = true;
+        if (typeof this.wsClient?.close === "function") {
             this.wsClient.close();
             this.wsClient = undefined;
         }
-        this.wsUserClosed = true;
     }
     /**
    * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.

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

@@ -8,21 +8,15 @@ Object.defineProperty(exports, "WebSocketPool", {
         return WebSocketPool;
     }
 });
-const _ttlcache = /*#__PURE__*/ _interop_require_default(require("@isaacs/ttlcache"));
+const _ttlcache = require("@isaacs/ttlcache");
 const _tslog = require("ts-log");
 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
-    };
-}
 const DEFAULT_NUM_CONNECTIONS = 4;
 class WebSocketPool extends _index.IsomorphicEventEmitter {
     logger;
-    abortSignal;
     rwsPool;
     cache;
     subscriptions;
@@ -34,10 +28,10 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
     wasAllDown = true;
     checkConnectionStatesInterval;
     isShutdown = false;
-    constructor(logger, abortSignal){
-        super(), this.logger = logger, this.abortSignal = abortSignal;
+    constructor(logger){
+        super(), this.logger = logger;
         this.rwsPool = [];
-        this.cache = new _ttlcache.default({
+        this.cache = new _ttlcache.TTLCache({
             ttl: 1000 * 10
         }); // TTL of 10 seconds
         this.subscriptions = new Map();
@@ -59,90 +53,102 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
    * @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, 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, abortSignal);
-        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`);
+        const pool = new WebSocketPool(log);
+        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,
-                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 || pool.abortSignal?.aborted) {
-                    return;
-                }
-                for (const listener of pool.connectionReconnectListeners){
-                    listener(connectionIndex, connectionEndpoint);
+            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;
                 }
-            };
-            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;
+                // 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()){
-            if (pool.abortSignal?.aborted) {
-                pool.logger.warn("the WebSocket Pool's abort signal was aborted during connection. Shutting down.");
-                pool.shutdown();
-                return pool;
+            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));
             }
-            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));
@@ -194,8 +200,8 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         }
     };
     sendRequest(request) {
-        if (this.isShutdown || this.abortSignal?.aborted) {
-            this.logger.warn("Cannot send request: WebSocketPool is shutdown or aborted");
+        if (this.isShutdown) {
+            this.logger.warn("Cannot send request: WebSocketPool is shutdown");
             return;
         }
         for (const rws of this.rwsPool){
@@ -207,8 +213,8 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         }
     }
     addSubscription(request) {
-        if (this.isShutdown || this.abortSignal?.aborted) {
-            this.logger.warn("Cannot add subscription: WebSocketPool is shutdown or aborted");
+        if (this.isShutdown) {
+            this.logger.warn("Cannot add subscription: WebSocketPool is shutdown");
             return;
         }
         if (request.type !== "subscribe") {
@@ -219,8 +225,8 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         this.sendRequest(request);
     }
     removeSubscription(subscriptionId) {
-        if (this.isShutdown || this.abortSignal?.aborted) {
-            this.logger.warn("Cannot remove subscription: WebSocketPool is shutdown or aborted");
+        if (this.isShutdown) {
+            this.logger.warn("Cannot remove subscription: WebSocketPool is shutdown");
             return;
         }
         this.subscriptions.delete(subscriptionId);
@@ -263,8 +269,8 @@ class WebSocketPool extends _index.IsomorphicEventEmitter {
         return this.rwsPool.some((ws)=>ws.isConnected());
     }
     checkConnectionStates() {
-        // Stop monitoring if shutdown or aborted
-        if (this.isShutdown || this.abortSignal?.aborted) {
+        // Stop monitoring if shutdown
+        if (this.isShutdown) {
             return;
         }
         const allDown = this.areAllConnectionsDown();

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

@@ -46,7 +46,6 @@ export type WebSocketPoolEvents = {
 };
 export declare class WebSocketPool extends IsomorphicEventEmitter<WebSocketPoolEvents> {
     private readonly logger;
-    private readonly abortSignal?;
     rwsPool: ResilientWebSocket[];
     private cache;
     private subscriptions;
@@ -67,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, abortSignal: AbortSignal | null | undefined, 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

package/dist/esm/client.d.ts

@@ -18,8 +18,9 @@ export type JsonOrBinaryResponse = {
 };
 export type LazerClientConfig = {
     /**
-     * if provided and the signal is detected as canceled,
-     * all active listeners and connections will be unbound and killed.
+     * 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;
@@ -34,7 +35,6 @@ export declare class PythLazerClient {
     private priceServiceUrl;
     private token;
     private wsp;
-    private abortSignal;
     private constructor();
     /**
      * Creates a new PythLazerClient instance.
@@ -48,10 +48,6 @@ export declare class PythLazerClient {
      * or a binary response containing EVM, Solana, or parsed payload data.
      */
     addMessageListener(handler: (event: JsonOrBinaryResponse) => void): void;
-    /**
-     * binds any internal event handlers
-     */
-    bindHandlers(): void;
     subscribe(request: Request): void;
     unsubscribe(subscriptionId: number): void;
     send(request: Request): void;
@@ -76,10 +72,6 @@ export declare class PythLazerClient {
      * @param handler - Function to be called with connection index and endpoint URL
      */
     addConnectionReconnectListener(handler: (connectionIndex: number, endpoint: string) => void): void;
-    /**
-     * called if and only if a user provided an abort signal and it was aborted
-     */
-    protected abortHandler: () => void;
     shutdown(): void;
     /**
      * Private helper method to make authenticated HTTP requests with Bearer token

package/dist/esm/client.mjs

@@ -12,39 +12,64 @@ export class PythLazerClient {
     priceServiceUrl;
     token;
     wsp;
-    abortSignal;
-    constructor({ abortSignal, logger, metadataServiceUrl, priceServiceUrl, token, wsp }){
-        this.abortSignal = abortSignal;
+    constructor({ logger, metadataServiceUrl, priceServiceUrl, token, wsp }){
         this.logger = logger;
         this.metadataServiceUrl = metadataServiceUrl;
         this.priceServiceUrl = priceServiceUrl;
         this.token = token;
         this.wsp = wsp;
-        this.bindHandlers();
     }
     /**
    * 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;
-        // 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
-        const wsp = await WebSocketPool.create(config.webSocketPoolConfig, token, config.abortSignal, logger);
-        const client = new PythLazerClient({
-            abortSignal: config.abortSignal,
-            logger,
-            metadataServiceUrl,
-            priceServiceUrl,
-            token,
-            wsp
-        });
-        return client;
+        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;
+        }
     }
     /**
    * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
@@ -98,11 +123,6 @@ export class PythLazerClient {
             });
         });
     }
-    /**
-   * binds any internal event handlers
-   */ bindHandlers() {
-        this.abortSignal?.addEventListener("abort", this.abortHandler);
-    }
     subscribe(request) {
         if (request.type !== "subscribe") {
             throw new Error("Request must be a subscribe request");
@@ -140,14 +160,7 @@ export class PythLazerClient {
    */ addConnectionReconnectListener(handler) {
         this.wsp.addConnectionReconnectListener(handler);
     }
-    /**
-   * called if and only if a user provided an abort signal and it was aborted
-   */ abortHandler = ()=>{
-        this.shutdown();
-    };
     shutdown() {
-        // Clean up abort signal listener to prevent memory leak
-        this.abortSignal?.removeEventListener("abort", this.abortHandler);
         this.wsp.shutdown();
     }
     /**

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

@@ -69,46 +69,68 @@ export class ResilientWebSocket {
             this.logger.info("WebSocket client already started.");
             return;
         }
-        if (this.wsFailedAttempts == 0) {
+        if (this.wsFailedAttempts === 0) {
             this.logger.info(`Creating Web Socket client`);
         }
         if (this.retryTimeout !== undefined) {
             clearTimeout(this.retryTimeout);
             this.retryTimeout = undefined;
         }
-        // browser constructor supports a different 2nd argument for the constructor,
-        // 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.logger.info("WebSocket connection established");
-            this.wsFailedAttempts = 0;
-            this._isReconnecting = false;
-            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()}`);
+        // we wrap the new WebSocket() construction in a try / catch because,
+        // if one of our instances legitimately goes down or there's some network
+        // error that impacts connectivity, the WebSocket constructor will throw
+        // an uncaught DOMException in the browser (or equivalent in Node, Bun or Deno)
+        // and potentially blow up the process (if running in Node, Bun or Deno)
+        try {
+            // browser constructor supports a different 2nd argument for the constructor,
+            // 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.logger.info("WebSocket connection established");
+                this.wsFailedAttempts = 0;
+                this._isReconnecting = false;
+                this.resetHeartbeat();
+                try {
+                    this.onReconnect();
+                } catch (error) {
+                    this.logger.error("Error in onReconnect callback:", error);
                 }
-                this.handleReconnect();
-            }
-        });
-        this.wsClient.addEventListener("error", (event)=>{
-            this.onError(event);
-        });
-        this.wsClient.addEventListener("message", (event)=>{
-            this.resetHeartbeat();
-            this.onMessage(event.data);
-        });
-        if ("on" in this.wsClient) {
-            this.wsClient.on("ping", ()=>{
-                this.logger.info("Ping received");
+            });
+            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)=>{
+                try {
+                    this.onError(event);
+                } catch (error) {
+                    this.logger.error("Error in onError callback:", error);
+                }
+            });
+            this.wsClient.addEventListener("message", (event)=>{
                 this.resetHeartbeat();
+                try {
+                    this.onMessage(event.data);
+                } catch (error) {
+                    this.logger.error("Error in onMessage callback:", error);
+                }
             });
+            if (typeof this.wsClient?.on === "function") {
+                this.wsClient.on("ping", ()=>{
+                    this.logger.debug("Ping received");
+                    this.resetHeartbeat();
+                });
+            }
+        } catch (error) {
+            this.logger.error("Failed to create WebSocket client:", error);
+            this.handleReconnect();
         }
     }
     resetHeartbeat() {
@@ -118,7 +140,11 @@ export class ResilientWebSocket {
         this.heartbeatTimeout = setTimeout(()=>{
             const warnMsg = "Connection timed out. Reconnecting...";
             this.logger.warn(warnMsg);
-            this.onTimeout();
+            try {
+                this.onTimeout();
+            } catch (error) {
+                this.logger.error("Error in onTimeout callback:", error);
+            }
             if (this.wsClient) {
                 if (typeof this.wsClient.terminate === "function") {
                     this.wsClient.terminate();
@@ -129,7 +155,8 @@ export class ResilientWebSocket {
                     this.wsClient.close(CustomSocketClosureCodes.CLIENT_TIMEOUT_BUT_RECONNECTING, warnMsg);
                 }
             }
-            this.handleReconnect();
+        // No direct call to handleReconnect() here
+        // terminate/close will trigger the 'close' event, which will call it.
         }, this.heartbeatTimeoutDurationMs);
     }
     handleReconnect() {
@@ -154,11 +181,12 @@ export class ResilientWebSocket {
         }, this.retryDelayMs());
     }
     closeWebSocket() {
-        if (this.wsClient !== undefined) {
+        // immediately block duplicate calls to this function
+        this.wsUserClosed = true;
+        if (typeof this.wsClient?.close === "function") {
             this.wsClient.close();
             this.wsClient = undefined;
         }
-        this.wsUserClosed = true;
     }
     /**
    * Calculates the delay in milliseconds for exponential backoff based on the number of failed attempts.

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

@@ -46,7 +46,6 @@ export type WebSocketPoolEvents = {
 };
 export declare class WebSocketPool extends IsomorphicEventEmitter<WebSocketPoolEvents> {
     private readonly logger;
-    private readonly abortSignal?;
     rwsPool: ResilientWebSocket[];
     private cache;
     private subscriptions;
@@ -67,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, abortSignal: AbortSignal | null | undefined, 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

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

@@ -1,4 +1,4 @@
-import TTLCache from "@isaacs/ttlcache";
+import { TTLCache } from "@isaacs/ttlcache";
 import { dummyLogger } from "ts-log";
 import { DEFAULT_STREAM_SERVICE_0_URL, DEFAULT_STREAM_SERVICE_1_URL } from "../constants.mjs";
 import { IsomorphicEventEmitter } from "../emitter/index.mjs";
@@ -7,7 +7,6 @@ import { ResilientWebSocket } from "./resilient-websocket.mjs";
 const DEFAULT_NUM_CONNECTIONS = 4;
 export class WebSocketPool extends IsomorphicEventEmitter {
     logger;
-    abortSignal;
     rwsPool;
     cache;
     subscriptions;
@@ -19,8 +18,8 @@ export class WebSocketPool extends IsomorphicEventEmitter {
     wasAllDown = true;
     checkConnectionStatesInterval;
     isShutdown = false;
-    constructor(logger, abortSignal){
-        super(), this.logger = logger, this.abortSignal = abortSignal;
+    constructor(logger){
+        super(), this.logger = logger;
         this.rwsPool = [];
         this.cache = new TTLCache({
             ttl: 1000 * 10
@@ -44,90 +43,102 @@ export class WebSocketPool extends IsomorphicEventEmitter {
    * @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, 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 ?? [
             DEFAULT_STREAM_SERVICE_0_URL,
             DEFAULT_STREAM_SERVICE_1_URL
         ];
         const log = logger ?? dummyLogger;
-        const pool = new WebSocketPool(log, abortSignal);
-        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 = envIsBrowserOrWorker();
-            const url = isBrowser ? addAuthTokenToWebSocketUrl(baseUrl, token) : baseUrl;
-            if (!url) {
-                throw new Error(`URLs must not be null or empty`);
+        const pool = new WebSocketPool(log);
+        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}`
+            for(let i = 0; i < numConnections; i++){
+                const baseUrl = urls[i % urls.length];
+                const isBrowser = envIsBrowserOrWorker();
+                const url = isBrowser ? addAuthTokenToWebSocketUrl(baseUrl, token) : baseUrl;
+                if (!url) {
+                    throw new Error(`URLs must not be null or empty`);
                 }
-            };
-            const rws = new 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 || pool.abortSignal?.aborted) {
-                    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);
+                const wsOptions = {
+                    ...config.rwsConfig?.wsOptions,
+                    headers: isBrowser ? undefined : {
+                        Authorization: `Bearer ${token}`
                     }
+                };
+                const rws = new 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;
                 }
-            };
-            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;
+                // 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()){
-            if (pool.abortSignal?.aborted) {
-                pool.logger.warn("the WebSocket Pool's abort signal was aborted during connection. Shutting down.");
-                pool.shutdown();
-                return pool;
+            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));
             }
-            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));
@@ -179,8 +190,8 @@ export class WebSocketPool extends IsomorphicEventEmitter {
         }
     };
     sendRequest(request) {
-        if (this.isShutdown || this.abortSignal?.aborted) {
-            this.logger.warn("Cannot send request: WebSocketPool is shutdown or aborted");
+        if (this.isShutdown) {
+            this.logger.warn("Cannot send request: WebSocketPool is shutdown");
             return;
         }
         for (const rws of this.rwsPool){
@@ -192,8 +203,8 @@ export class WebSocketPool extends IsomorphicEventEmitter {
         }
     }
     addSubscription(request) {
-        if (this.isShutdown || this.abortSignal?.aborted) {
-            this.logger.warn("Cannot add subscription: WebSocketPool is shutdown or aborted");
+        if (this.isShutdown) {
+            this.logger.warn("Cannot add subscription: WebSocketPool is shutdown");
             return;
         }
         if (request.type !== "subscribe") {
@@ -204,8 +215,8 @@ export class WebSocketPool extends IsomorphicEventEmitter {
         this.sendRequest(request);
     }
     removeSubscription(subscriptionId) {
-        if (this.isShutdown || this.abortSignal?.aborted) {
-            this.logger.warn("Cannot remove subscription: WebSocketPool is shutdown or aborted");
+        if (this.isShutdown) {
+            this.logger.warn("Cannot remove subscription: WebSocketPool is shutdown");
             return;
         }
         this.subscriptions.delete(subscriptionId);
@@ -248,8 +259,8 @@ export class WebSocketPool extends IsomorphicEventEmitter {
         return this.rwsPool.some((ws)=>ws.isConnected());
     }
     checkConnectionStates() {
-        // Stop monitoring if shutdown or aborted
-        if (this.isShutdown || this.abortSignal?.aborted) {
+        // Stop monitoring if shutdown
+        if (this.isShutdown) {
             return;
         }
         const allDown = this.areAllConnectionsDown();

package/package.json

@@ -3,18 +3,18 @@
     "url": "https://github.com/pyth-network/pyth-crosschain/issues"
   },
   "dependencies": {
-    "@isaacs/ttlcache": "^1.4.1",
+    "@isaacs/ttlcache": "^2.1.4",
     "buffer": "^6.0.3",
     "isomorphic-ws": "^5.0.0",
     "ts-log": "^2.2.7",
-    "ws": "^8.19.0"
+    "ws": "^8.20.0"
   },
   "description": "Pyth Lazer SDK",
   "devDependencies": {
     "@cprussin/tsconfig": "^4.0.2",
     "@types/node": "^24.10.1",
     "@types/ws": "^8.18.1",
-    "typedoc": "^0.28.17"
+    "typedoc": "^0.28.18"
   },
   "engines": {
     "node": "^24.0.0"
@@ -164,5 +164,5 @@
   },
   "type": "module",
   "types": "./dist/cjs/index.d.ts",
-  "version": "6.2.0"
+  "version": "6.2.2"
 }