@pythnetwork/pyth-lazer-sdk 6.0.0 → 6.2.1

package/dist/cjs/client.cjs

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

package/dist/cjs/client.d.ts

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

package/dist/cjs/index.cjs

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./client.cjs"), exports);
-_export_star(require("./protocol.cjs"), exports);
 _export_star(require("./constants.cjs"), exports);
+_export_star(require("./protocol.cjs"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/cjs/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/cjs/protocol.cjs

@@ -21,11 +21,11 @@ _export(exports, {
 });
 const BINARY_UPDATE_FORMAT_MAGIC_LE = 461_928_307;
 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
 };
 var CustomSocketClosureCodes = /*#__PURE__*/ function(CustomSocketClosureCodes) {
     CustomSocketClosureCodes[CustomSocketClosureCodes["CLIENT_TIMEOUT_BUT_RECONNECTING"] = 4000] = "CLIENT_TIMEOUT_BUT_RECONNECTING";

package/dist/cjs/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/cjs/socket/resilient-websocket.cjs

@@ -45,6 +45,7 @@ class ResilientWebSocket {
     onError;
     onMessage;
     onReconnect;
+    onTimeout;
     constructor(config){
         this.endpoint = config.endpoint;
         this.wsOptions = config.wsOptions;
@@ -62,6 +63,9 @@ 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`);
@@ -129,6 +133,7 @@ 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/cjs/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;