@pythnetwork/pyth-lazer-sdk 6.0.0 → 6.2.1

package/dist/esm/index.d.ts

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

package/dist/esm/index.mjs

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

package/dist/esm/protocol.d.ts

@@ -2,7 +2,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" | "fundingRate" | "fundingTimestamp" | "fundingRateInterval" | "marketSession" | "emaPrice" | "emaConfidence" | "feedUpdateTimestamp";
-export type Channel = "real_time" | "fixed_rate@50ms" | "fixed_rate@200ms";
+export type Channel = "real_time" | "fixed_rate@50ms" | "fixed_rate@200ms" | "fixed_rate@1000ms";
 export type Request = {
     type: "subscribe";
     subscriptionId: number;
@@ -78,11 +78,11 @@ export type Response = {
 };
 export declare const BINARY_UPDATE_FORMAT_MAGIC_LE = 461928307;
 export declare const FORMAT_MAGICS_LE: {
-    JSON: number;
     EVM: number;
-    SOLANA: number;
+    JSON: number;
     LE_ECDSA: number;
     LE_UNSIGNED: number;
+    SOLANA: number;
 };
 export type AssetType = "crypto" | "fx" | "equity" | "metal" | "rates" | "nav" | "commodity" | "funding-rate" | "eco" | "kalshi";
 export type SymbolsQueryParams = {

package/dist/esm/protocol.mjs

@@ -1,10 +1,10 @@
 export const BINARY_UPDATE_FORMAT_MAGIC_LE = 461_928_307;
 export const FORMAT_MAGICS_LE = {
-    JSON: 3_302_625_434,
     EVM: 2_593_727_018,
-    SOLANA: 2_182_742_457,
+    JSON: 3_302_625_434,
     LE_ECDSA: 1_296_547_300,
-    LE_UNSIGNED: 1_499_680_012
+    LE_UNSIGNED: 1_499_680_012,
+    SOLANA: 2_182_742_457
 };
 export var CustomSocketClosureCodes = /*#__PURE__*/ function(CustomSocketClosureCodes) {
     CustomSocketClosureCodes[CustomSocketClosureCodes["CLIENT_TIMEOUT_BUT_RECONNECTING"] = 4000] = "CLIENT_TIMEOUT_BUT_RECONNECTING";

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

@@ -44,6 +44,7 @@ export declare class ResilientWebSocket {
     onError: (error: ErrorEvent) => void;
     onMessage: (data: WebSocket.Data) => void;
     onReconnect: () => void;
+    onTimeout: () => void;
     constructor(config: ResilientWebSocketConfig);
     send(data: string | Buffer): void;
     startWebSocket(): void;

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

@@ -30,6 +30,7 @@ export class ResilientWebSocket {
     onError;
     onMessage;
     onReconnect;
+    onTimeout;
     constructor(config){
         this.endpoint = config.endpoint;
         this.wsOptions = config.wsOptions;
@@ -47,6 +48,9 @@ export class ResilientWebSocket {
         this.onReconnect = ()=>{
         // Empty function, can be set by the user.
         };
+        this.onTimeout = ()=>{
+        // Empty function, can be set by the user.
+        };
     }
     send(data) {
         this.logger.debug(`Sending message`);
@@ -114,6 +118,7 @@ export class ResilientWebSocket {
         this.heartbeatTimeout = setTimeout(()=>{
             const warnMsg = "Connection timed out. Reconnecting...";
             this.logger.warn(warnMsg);
+            this.onTimeout();
             if (this.wsClient) {
                 if (typeof this.wsClient.terminate === "function") {
                     this.wsClient.terminate();

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

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

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

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