@pythnetwork/pyth-lazer-sdk 5.0.0 → 5.2.0

package/dist/cjs/socket/{websocket-pool.js → websocket-pool.cjs}

@@ -1,82 +1,91 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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 constants_js_1 = require("../constants.js");
-const index_js_1 = require("../util/index.js");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebSocketPool", {
+    enumerable: true,
+    get: function() {
+        return WebSocketPool;
+    }
+});
+const _ttlcache = /*#__PURE__*/ _interop_require_default(require("@isaacs/ttlcache"));
+const _tslog = require("ts-log");
+const _resilientwebsocket = require("./resilient-websocket.cjs");
+const _constants = require("../constants.cjs");
+const _index = require("../util/index.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 const DEFAULT_NUM_CONNECTIONS = 4;
 class WebSocketPool {
     logger;
     rwsPool;
     cache;
-    subscriptions; // id -> subscription Request
+    subscriptions;
     messageListeners;
     allConnectionsDownListeners;
     wasAllDown = true;
     checkConnectionStatesInterval;
-    constructor(logger) {
+    constructor(logger){
         this.logger = logger;
         this.rwsPool = [];
-        this.cache = new ttlcache_1.default({ ttl: 1000 * 10 }); // TTL of 10 seconds
+        this.cache = new _ttlcache.default({
+            ttl: 1000 * 10
+        }); // TTL of 10 seconds
         this.subscriptions = new Map();
         this.messageListeners = [];
         this.allConnectionsDownListeners = [];
         // Start monitoring connection states
-        this.checkConnectionStatesInterval = setInterval(() => {
+        this.checkConnectionStatesInterval = setInterval(()=>{
             this.checkConnectionStates();
         }, 100);
     }
     /**
-     * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
-     * Usage semantics are similar to using a regular WebSocket client.
-     * @param urls - List of WebSocket URLs to connect to
-     * @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) {
+   * Creates a new WebSocketPool instance that uses multiple redundant WebSocket connections for reliability.
+   * Usage semantics are similar to using a regular WebSocket client.
+   * @param urls - List of WebSocket URLs to connect to
+   * @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) {
         const urls = config.urls ?? [
-            constants_js_1.DEFAULT_STREAM_SERVICE_0_URL,
-            constants_js_1.DEFAULT_STREAM_SERVICE_1_URL,
+            _constants.DEFAULT_STREAM_SERVICE_0_URL,
+            _constants.DEFAULT_STREAM_SERVICE_1_URL
         ];
-        const log = logger ?? ts_log_1.dummyLogger;
+        const log = logger ?? _tslog.dummyLogger;
         const pool = new WebSocketPool(log);
         const numConnections = config.numConnections ?? DEFAULT_NUM_CONNECTIONS;
-        for (let i = 0; i < numConnections; i++) {
+        for(let i = 0; i < numConnections; i++){
             const baseUrl = urls[i % urls.length];
-            const isBrowser = (0, index_js_1.envIsBrowserOrWorker)();
-            const url = isBrowser
-                ? (0, index_js_1.addAuthTokenToWebSocketUrl)(baseUrl, token)
-                : baseUrl;
+            const isBrowser = (0, _index.envIsBrowserOrWorker)();
+            const url = isBrowser ? (0, _index.addAuthTokenToWebSocketUrl)(baseUrl, token) : baseUrl;
             if (!url) {
                 throw new Error(`URLs must not be null or empty`);
             }
             const wsOptions = {
                 ...config.rwsConfig?.wsOptions,
-                headers: isBrowser ? undefined : { Authorization: `Bearer ${token}` },
+                headers: isBrowser ? undefined : {
+                    Authorization: `Bearer ${token}`
+                }
             };
-            const rws = new resilient_websocket_js_1.ResilientWebSocket({
+            const rws = new _resilientwebsocket.ResilientWebSocket({
                 ...config.rwsConfig,
                 endpoint: url,
                 wsOptions,
-                logger: log,
+                logger: log
             });
             // If a websocket client unexpectedly disconnects, ResilientWebSocket will reestablish
             // the connection and call the onReconnect callback.
-            rws.onReconnect = () => {
+            rws.onReconnect = ()=>{
                 if (rws.wsUserClosed) {
                     return;
                 }
-                for (const [, request] of pool.subscriptions) {
+                for (const [, request] of pool.subscriptions){
                     try {
                         rws.send(JSON.stringify(request));
-                    }
-                    catch (error) {
+                    } catch (error) {
                         pool.logger.error("Failed to resend subscription on reconnect:", error);
                     }
                 }
@@ -85,8 +94,8 @@ class WebSocketPool {
                 rws.onError = config.onError;
             }
             // Handle all client messages ourselves. Dedupe before sending to registered message handlers.
-            rws.onMessage = (data) => {
-                pool.dedupeHandler(data).catch((error) => {
+            rws.onMessage = (data)=>{
+                pool.dedupeHandler(data).catch((error)=>{
                     const errMsg = `An error occurred in the WebSocket pool's dedupeHandler: ${error instanceof Error ? error.message : String(error)}`;
                     throw new Error(errMsg);
                 });
@@ -95,35 +104,31 @@ class WebSocketPool {
             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));
+        while(!pool.isAnyConnectionEstablished()){
+            await new Promise((resolve)=>setTimeout(resolve, 100));
         }
         pool.logger.info(`At least one WebSocket connection is established. WebSocketPool is ready.`);
         return pool;
     }
     /**
-     * Checks for error responses in JSON messages and throws appropriate errors
-     */
-    handleErrorMessages(data) {
+   * Checks for error responses in JSON messages and throws appropriate errors
+   */ handleErrorMessages(data) {
         const message = JSON.parse(data);
         if (message.type === "subscriptionError") {
             throw new Error(`Error occurred for subscription ID ${String(message.subscriptionId)}: ${message.error}`);
-        }
-        else if (message.type === "error") {
+        } else if (message.type === "error") {
             throw new Error(`Error: ${message.error}`);
         }
     }
     async constructCacheKeyFromWebsocketData(data) {
-        if (typeof data === "string")
-            return data;
-        const buff = await (0, index_js_1.bufferFromWebsocketData)(data);
+        if (typeof data === "string") return data;
+        const buff = await (0, _index.bufferFromWebsocketData)(data);
         return buff.toString("hex");
     }
     /**
-     * Handles incoming websocket messages by deduplicating identical messages received across
-     * multiple connections before forwarding to registered handlers
-     */
-    dedupeHandler = async (data) => {
+   * Handles incoming websocket messages by deduplicating identical messages received across
+   * multiple connections before forwarding to registered handlers
+   */ dedupeHandler = async (data)=>{
         const cacheKey = await this.constructCacheKeyFromWebsocketData(data);
         if (this.cache.has(cacheKey)) {
             this.logger.debug("Dropping duplicate message");
@@ -133,10 +138,10 @@ class WebSocketPool {
         if (typeof data === "string") {
             this.handleErrorMessages(data);
         }
-        await Promise.all(this.messageListeners.map((handler) => handler(data)));
+        await Promise.all(this.messageListeners.map((handler)=>handler(data)));
     };
     sendRequest(request) {
-        for (const rws of this.rwsPool) {
+        for (const rws of this.rwsPool){
             rws.send(JSON.stringify(request));
         }
     }
@@ -151,7 +156,7 @@ class WebSocketPool {
         this.subscriptions.delete(subscriptionId);
         const request = {
             type: "unsubscribe",
-            subscriptionId,
+            subscriptionId
         };
         this.sendRequest(request);
     }
@@ -159,17 +164,16 @@ class WebSocketPool {
         this.messageListeners.push(handler);
     }
     /**
-     * Calls the handler if all websocket connections are currently down or in reconnecting state.
-     * The connections may still try to reconnect in the background.
-     */
-    addAllConnectionsDownListener(handler) {
+   * Calls the handler if all websocket connections are currently down or in reconnecting state.
+   * The connections may still try to reconnect in the background.
+   */ addAllConnectionsDownListener(handler) {
         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());
+        return this.rwsPool.some((ws)=>ws.isConnected());
     }
     checkConnectionStates() {
         const allDown = this.areAllConnectionsDown();
@@ -178,7 +182,7 @@ class WebSocketPool {
             this.wasAllDown = true;
             this.logger.error("All WebSocket connections are down or reconnecting");
             // Notify all listeners
-            for (const listener of this.allConnectionsDownListeners) {
+            for (const listener of this.allConnectionsDownListeners){
                 listener();
             }
         }
@@ -188,7 +192,7 @@ class WebSocketPool {
         }
     }
     shutdown() {
-        for (const rws of this.rwsPool) {
+        for (const rws of this.rwsPool){
             rws.closeWebSocket();
         }
         this.rwsPool = [];
@@ -198,4 +202,3 @@ class WebSocketPool {
         clearInterval(this.checkConnectionStatesInterval);
     }
 }
-exports.WebSocketPool = WebSocketPool;

package/dist/cjs/util/{buffer-util.js → buffer-util.cjs}

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bufferFromWebsocketData = bufferFromWebsocketData;
 // the linting rules don't allow importing anything that might clash with
 // a global, top-level import. we disable this rule because we need this
 // imported from our installed dependency
 // eslint-disable-next-line unicorn/prefer-node-protocol
-const buffer_1 = require("buffer");
-const BufferClassToUse = "Buffer" in globalThis ? globalThis.Buffer : buffer_1.Buffer;
-/**
- * given a relatively unknown websocket frame data object,
- * returns a valid Buffer instance that is safe to use
- * isomorphically in any JS runtime environment
- */
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "bufferFromWebsocketData", {
+    enumerable: true,
+    get: function() {
+        return bufferFromWebsocketData;
+    }
+});
+const _buffer = require("buffer");
+const BufferClassToUse = "Buffer" in globalThis ? globalThis.Buffer : _buffer.Buffer;
 async function bufferFromWebsocketData(data) {
     if (typeof data === "string") {
         return BufferClassToUse.from(new TextEncoder().encode(data).buffer);
     }
-    if (data instanceof BufferClassToUse)
-        return data;
+    if (data instanceof BufferClassToUse) return data;
     if (data instanceof Blob) {
         // let the uncaught promise exception bubble up if there's an issue
         return BufferClassToUse.from(await data.arrayBuffer());
     }
-    if (data instanceof ArrayBuffer)
-        return BufferClassToUse.from(data);
+    if (data instanceof ArrayBuffer) return BufferClassToUse.from(data);
     if (Array.isArray(data)) {
         // an array of buffers is highly unlikely, but it is a possibility
         // indicated by the WebSocket Data interface

package/dist/cjs/util/env-util.cjs

@@ -0,0 +1,33 @@
+// we create this local-only type, which has assertions made to indicate
+// that we do not know and cannot guarantee which JS environment we are in
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get envIsBrowser () {
+        return envIsBrowser;
+    },
+    get envIsBrowserOrWorker () {
+        return envIsBrowserOrWorker;
+    },
+    get envIsServiceOrWebWorker () {
+        return envIsServiceOrWebWorker;
+    }
+});
+const g = globalThis;
+function envIsServiceOrWebWorker() {
+    return typeof WorkerGlobalScope !== "undefined" && g.self instanceof WorkerGlobalScope;
+}
+function envIsBrowser() {
+    return g.window !== undefined;
+}
+function envIsBrowserOrWorker() {
+    return envIsServiceOrWebWorker() || envIsBrowser();
+}

package/dist/cjs/util/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./buffer-util.cjs"), exports);
+_export_star(require("./env-util.cjs"), exports);
+_export_star(require("./url-util.cjs"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/util/url-util.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "addAuthTokenToWebSocketUrl", {
+    enumerable: true,
+    get: function() {
+        return addAuthTokenToWebSocketUrl;
+    }
+});
+const ACCESS_TOKEN_QUERY_PARAM_KEY = "ACCESS_TOKEN";
+function addAuthTokenToWebSocketUrl(baseUrl, authToken) {
+    if (!baseUrl || !authToken) return baseUrl;
+    const parsedUrl = new URL(baseUrl);
+    parsedUrl.searchParams.set(ACCESS_TOKEN_QUERY_PARAM_KEY, authToken);
+    return parsedUrl.toString();
+}

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

@@ -1,9 +1,8 @@
-import WebSocket from "isomorphic-ws";
 import { dummyLogger } from "ts-log";
-import { DEFAULT_METADATA_SERVICE_URL, DEFAULT_PRICE_SERVICE_URL, } from "./constants.js";
-import { BINARY_UPDATE_FORMAT_MAGIC_LE, FORMAT_MAGICS_LE } from "./protocol.js";
-import { WebSocketPool } from "./socket/websocket-pool.js";
-import { bufferFromWebsocketData } from "./util/buffer-util.js";
+import { DEFAULT_METADATA_SERVICE_URL, DEFAULT_PRICE_SERVICE_URL } from "./constants.mjs";
+import { BINARY_UPDATE_FORMAT_MAGIC_LE, FORMAT_MAGICS_LE } from "./protocol.mjs";
+import { WebSocketPool } from "./socket/websocket-pool.mjs";
+import { bufferFromWebsocketData } from "./util/buffer-util.mjs";
 const UINT16_NUM_BYTES = 2;
 const UINT32_NUM_BYTES = 4;
 const UINT64_NUM_BYTES = 8;
@@ -13,7 +12,7 @@ export class PythLazerClient {
     priceServiceUrl;
     logger;
     wsp;
-    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp) {
+    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp){
         this.token = token;
         this.metadataServiceUrl = metadataServiceUrl;
         this.priceServiceUrl = priceServiceUrl;
@@ -21,21 +20,19 @@ export class PythLazerClient {
         this.wsp = wsp;
     }
     /**
-     * Gets the WebSocket pool. If the WebSocket pool is not configured, an error is thrown.
-     * @throws Error if WebSocket pool is not configured
-     * @returns The WebSocket pool
-     */
-    getWebSocketPool() {
+   * Gets the WebSocket pool. If the WebSocket pool is not configured, an error is thrown.
+   * @throws Error if WebSocket pool is not configured
+   * @returns The WebSocket pool
+   */ getWebSocketPool() {
         if (!this.wsp) {
             throw new Error("WebSocket pool is not available. Make sure to provide webSocketPoolConfig when creating the client.");
         }
         return this.wsp;
     }
     /**
-     * Creates a new PythLazerClient instance.
-     * @param config - Configuration including token, metadata service URL, and price service URL, and WebSocket pool configuration
-     */
-    static async create(config) {
+   * Creates a new PythLazerClient instance.
+   * @param config - Configuration including token, metadata service URL, and price service URL, and WebSocket pool configuration
+   */ static async create(config) {
         const token = config.token;
         // Collect and remove trailing slash from URLs
         const metadataServiceUrl = (config.metadataServiceUrl ?? DEFAULT_METADATA_SERVICE_URL).replace(/\/+$/, "");
@@ -49,26 +46,23 @@ export class PythLazerClient {
         return new PythLazerClient(token, metadataServiceUrl, priceServiceUrl, logger, wsp);
     }
     /**
-     * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
-     * The listener will be called for each message received, with deduplication across redundant connections.
-     * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
-     * or a binary response containing EVM, Solana, or parsed payload data.
-     */
-    addMessageListener(handler) {
+   * Adds a message listener that receives either JSON or binary responses from the WebSocket connections.
+   * The listener will be called for each message received, with deduplication across redundant connections.
+   * @param handler - Callback function that receives the parsed message. The message can be either a JSON response
+   * or a binary response containing EVM, Solana, or parsed payload data.
+   */ addMessageListener(handler) {
         const wsp = this.getWebSocketPool();
-        wsp.addMessageListener(async (data) => {
+        wsp.addMessageListener(async (data)=>{
             if (typeof data == "string") {
                 handler({
                     type: "json",
-                    value: JSON.parse(data),
+                    value: JSON.parse(data)
                 });
                 return;
             }
             const buffData = await bufferFromWebsocketData(data);
             let pos = 0;
-            const magic = buffData
-                .subarray(pos, pos + UINT32_NUM_BYTES)
-                .readUint32LE();
+            const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
             pos += UINT32_NUM_BYTES;
             if (magic != BINARY_UPDATE_FORMAT_MAGIC_LE) {
                 throw new Error("binary update format magic mismatch");
@@ -76,36 +70,32 @@ export class PythLazerClient {
             // TODO: some uint64 values may not be representable as Number.
             const subscriptionId = Number(buffData.subarray(pos, pos + UINT64_NUM_BYTES).readBigInt64BE());
             pos += UINT64_NUM_BYTES;
-            const value = { subscriptionId };
-            while (pos < buffData.length) {
-                const len = buffData
-                    .subarray(pos, pos + UINT16_NUM_BYTES)
-                    .readUint16BE();
+            const value = {
+                subscriptionId
+            };
+            while(pos < buffData.length){
+                const len = buffData.subarray(pos, pos + UINT16_NUM_BYTES).readUint16BE();
                 pos += UINT16_NUM_BYTES;
-                const magic = buffData
-                    .subarray(pos, pos + UINT32_NUM_BYTES)
-                    .readUint32LE();
+                const magic = buffData.subarray(pos, pos + UINT32_NUM_BYTES).readUint32LE();
                 if (magic == FORMAT_MAGICS_LE.EVM) {
                     value.evm = buffData.subarray(pos, pos + len);
-                }
-                else if (magic == FORMAT_MAGICS_LE.SOLANA) {
+                } else if (magic == FORMAT_MAGICS_LE.SOLANA) {
                     value.solana = buffData.subarray(pos, pos + len);
-                }
-                else if (magic == FORMAT_MAGICS_LE.LE_ECDSA) {
+                } else if (magic == FORMAT_MAGICS_LE.LE_ECDSA) {
                     value.leEcdsa = buffData.subarray(pos, pos + len);
-                }
-                else if (magic == FORMAT_MAGICS_LE.LE_UNSIGNED) {
+                } else if (magic == FORMAT_MAGICS_LE.LE_UNSIGNED) {
                     value.leUnsigned = buffData.subarray(pos, pos + len);
-                }
-                else if (magic == FORMAT_MAGICS_LE.JSON) {
+                } else if (magic == FORMAT_MAGICS_LE.JSON) {
                     value.parsed = JSON.parse(buffData.subarray(pos + UINT32_NUM_BYTES, pos + len).toString());
-                }
-                else {
+                } else {
                     throw new Error(`unknown magic:  ${magic.toString()}`);
                 }
                 pos += len;
             }
-            handler({ type: "binary", value });
+            handler({
+                type: "binary",
+                value
+            });
         });
     }
     subscribe(request) {
@@ -124,11 +114,10 @@ export class PythLazerClient {
         wsp.sendRequest(request);
     }
     /**
-     * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.
-     * The connections may still try to reconnect in the background. To shut down the pool, call `shutdown()`.
-     * @param handler - Function to be called when all connections are down
-     */
-    addAllConnectionsDownListener(handler) {
+   * Registers a handler function that will be called whenever all WebSocket connections are down or attempting to reconnect.
+   * The connections may still try to reconnect in the background. To shut down the pool, call `shutdown()`.
+   * @param handler - Function to be called when all connections are down
+   */ addAllConnectionsDownListener(handler) {
         const wsp = this.getWebSocketPool();
         wsp.addAllConnectionsDownListener(handler);
     }
@@ -137,27 +126,25 @@ export class PythLazerClient {
         wsp.shutdown();
     }
     /**
-     * Private helper method to make authenticated HTTP requests with Bearer token
-     * @param url - The URL to fetch
-     * @param options - Additional fetch options
-     * @returns Promise resolving to the fetch Response
-     */
-    async authenticatedFetch(url, options = {}) {
+   * Private helper method to make authenticated HTTP requests with Bearer token
+   * @param url - The URL to fetch
+   * @param options - Additional fetch options
+   * @returns Promise resolving to the fetch Response
+   */ async authenticatedFetch(url, options = {}) {
         const headers = {
             Authorization: `Bearer ${this.token}`,
-            ...options.headers,
+            ...options.headers
         };
         return fetch(url, {
             ...options,
-            headers,
+            headers
         });
     }
     /**
-     * Queries the symbols endpoint to get available price feed symbols.
-     * @param params - Optional query parameters to filter symbols
-     * @returns Promise resolving to array of symbol information
-     */
-    async getSymbols(params) {
+   * Queries the symbols endpoint to get available price feed symbols.
+   * @param params - Optional query parameters to filter symbols
+   * @returns Promise resolving to array of symbol information
+   */ async getSymbols(params) {
         const url = new URL(`${this.metadataServiceUrl}/v1/symbols`);
         if (params?.query) {
             url.searchParams.set("query", params.query);
@@ -170,61 +157,62 @@ export class PythLazerClient {
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch symbols: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * Queries the latest price endpoint to get current price data.
-     * @param params - Parameters for the latest price request
-     * @returns Promise resolving to JsonUpdate with current price data
-     */
-    async getLatestPrice(params) {
+   * Queries the latest price endpoint to get current price data.
+   * @param params - Parameters for the latest price request
+   * @returns Promise resolving to JsonUpdate with current price data
+   */ async getLatestPrice(params) {
         const url = `${this.priceServiceUrl}/v1/latest_price`;
         try {
             const body = JSON.stringify(params);
-            this.logger.debug("getLatestPrice", { url, body });
+            this.logger.debug("getLatestPrice", {
+                url,
+                body
+            });
             const response = await this.authenticatedFetch(url, {
                 method: "POST",
                 headers: {
-                    "Content-Type": "application/json",
+                    "Content-Type": "application/json"
                 },
-                body: body,
+                body: body
             });
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch latest price: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * Queries the price endpoint to get historical price data at a specific timestamp.
-     * @param params - Parameters for the price request including timestamp
-     * @returns Promise resolving to JsonUpdate with price data at the specified time
-     */
-    async getPrice(params) {
+   * Queries the price endpoint to get historical price data at a specific timestamp.
+   * @param params - Parameters for the price request including timestamp
+   * @returns Promise resolving to JsonUpdate with price data at the specified time
+   */ async getPrice(params) {
         const url = `${this.priceServiceUrl}/v1/price`;
         try {
             const body = JSON.stringify(params);
-            this.logger.debug("getPrice", { url, body });
+            this.logger.debug("getPrice", {
+                url,
+                body
+            });
             const response = await this.authenticatedFetch(url, {
                 method: "POST",
                 headers: {
-                    "Content-Type": "application/json",
+                    "Content-Type": "application/json"
                 },
-                body: body,
+                body: body
             });
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
             }
-            return (await response.json());
-        }
-        catch (error) {
+            return await response.json();
+        } catch (error) {
             throw new Error(`Failed to fetch price: ${error instanceof Error ? error.message : String(error)}`);
         }
     }

package/dist/esm/index.mjs

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

package/dist/esm/package.json

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