@pythnetwork/pyth-lazer-sdk 4.0.0 → 5.2.0

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

@@ -1,79 +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");
+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++) {
-            const url = urls[i % urls.length];
+        for(let i = 0; i < numConnections; i++){
+            const baseUrl = urls[i % urls.length];
+            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: {
-                    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);
                     }
                 }
@@ -82,37 +94,42 @@ class WebSocketPool {
                 rws.onError = config.onError;
             }
             // Handle all client messages ourselves. Dedupe before sending to registered message handlers.
-            rws.onMessage = pool.dedupeHandler;
+            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);
+                });
+            };
             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));
+        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.bufferFromWebsocketData)(data);
+        return buff.toString("hex");
+    }
     /**
-     * Handles incoming websocket messages by deduplicating identical messages received across
-     * multiple connections before forwarding to registered handlers
-     */
-    dedupeHandler = (data) => {
-        const cacheKey = typeof data === "string"
-            ? data
-            : Buffer.from(data).toString("hex");
+   * 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");
             return;
@@ -121,12 +138,10 @@ class WebSocketPool {
         if (typeof data === "string") {
             this.handleErrorMessages(data);
         }
-        for (const handler of this.messageListeners) {
-            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));
         }
     }
@@ -141,7 +156,7 @@ class WebSocketPool {
         this.subscriptions.delete(subscriptionId);
         const request = {
             type: "unsubscribe",
-            subscriptionId,
+            subscriptionId
         };
         this.sendRequest(request);
     }
@@ -149,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();
@@ -168,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();
             }
         }
@@ -178,7 +192,7 @@ class WebSocketPool {
         }
     }
     shutdown() {
-        for (const rws of this.rwsPool) {
+        for (const rws of this.rwsPool){
             rws.closeWebSocket();
         }
         this.rwsPool = [];
@@ -188,4 +202,3 @@ class WebSocketPool {
         clearInterval(this.checkConnectionStatesInterval);
     }
 }
-exports.WebSocketPool = WebSocketPool;

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

@@ -4,6 +4,7 @@ import type { Logger } from "ts-log";
 import type { Request } from "../protocol.js";
 import type { ResilientWebSocketConfig } from "./resilient-websocket.js";
 import { ResilientWebSocket } from "./resilient-websocket.js";
+type WebSocketOnMessageCallback = (data: WebSocket.Data) => void | Promise<void>;
 export type WebSocketPoolConfig = {
     urls?: string[];
     numConnections?: number;
@@ -33,15 +34,16 @@ export declare class WebSocketPool {
      * Checks for error responses in JSON messages and throws appropriate errors
      */
     private handleErrorMessages;
+    private constructCacheKeyFromWebsocketData;
     /**
      * Handles incoming websocket messages by deduplicating identical messages received across
      * multiple connections before forwarding to registered handlers
      */
-    dedupeHandler: (data: WebSocket.Data) => void;
+    dedupeHandler: (data: WebSocket.Data) => Promise<void>;
     sendRequest(request: Request): void;
     addSubscription(request: Request): void;
     removeSubscription(subscriptionId: number): void;
-    addMessageListener(handler: (data: WebSocket.Data) => void): void;
+    addMessageListener(handler: WebSocketOnMessageCallback): void;
     /**
      * Calls the handler if all websocket connections are currently down or in reconnecting state.
      * The connections may still try to reconnect in the background.
@@ -52,3 +54,4 @@ export declare class WebSocketPool {
     private checkConnectionStates;
     shutdown(): void;
 }
+export {};

package/dist/cjs/util/buffer-util.cjs

@@ -0,0 +1,33 @@
+// 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
+"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 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 (Array.isArray(data)) {
+        // an array of buffers is highly unlikely, but it is a possibility
+        // indicated by the WebSocket Data interface
+        return BufferClassToUse.concat(data);
+    }
+    return data;
+}

package/dist/cjs/util/buffer-util.d.ts

@@ -0,0 +1,7 @@
+import type { Data } from "isomorphic-ws";
+/**
+ * given a relatively unknown websocket frame data object,
+ * returns a valid Buffer instance that is safe to use
+ * isomorphically in any JS runtime environment
+ */
+export declare function bufferFromWebsocketData(data: Data): Promise<Buffer>;

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/env-util.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Detects if this code is running within any Service or WebWorker context.
+ * @returns true if in a worker of some kind, false if otherwise
+ */
+export declare function envIsServiceOrWebWorker(): boolean;
+/**
+ * Detects if the code is running in a regular DOM or Web Worker context.
+ * @returns true if running in a DOM or Web Worker context, false if running in Node.js
+ */
+export declare function envIsBrowser(): boolean;
+/**
+ * a convenience method that returns whether or not
+ * this code is executing in some type of browser-centric environment
+ *
+ * @returns true if in the browser's main UI thread or in a worker, false if otherwise
+ */
+export declare function envIsBrowserOrWorker(): boolean;

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/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./buffer-util.js";
+export * from "./env-util.js";
+export * from "./url-util.js";

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/cjs/util/url-util.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Given a URL to a hosted lazer stream service and a possible auth token,
+ * appends the auth token as a query parameter and returns the URL with the token
+ * contained within.
+ * If the URL provided is nullish, it is returned as-is (in the same nullish format).
+ * If the token is nullish, the baseUrl given is returned, instead.
+ */
+export declare function addAuthTokenToWebSocketUrl(baseUrl: string | null | undefined, authToken: string | null | undefined): string | null | undefined;

package/dist/esm/client.mjs

@@ -0,0 +1,219 @@
+import { dummyLogger } from "ts-log";
+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;
+export class PythLazerClient {
+    token;
+    metadataServiceUrl;
+    priceServiceUrl;
+    logger;
+    wsp;
+    constructor(token, metadataServiceUrl, priceServiceUrl, logger, wsp){
+        this.token = token;
+        this.metadataServiceUrl = metadataServiceUrl;
+        this.priceServiceUrl = priceServiceUrl;
+        this.logger = logger;
+        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) {
+        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;
+        // 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.create(config.webSocketPoolConfig, token, logger);
+        }
+        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) {
+        const wsp = this.getWebSocketPool();
+        wsp.addMessageListener(async (data)=>{
+            if (typeof data == "string") {
+                handler({
+                    type: "json",
+                    value: JSON.parse(data)
+                });
+                return;
+            }
+            const buffData = await bufferFromWebsocketData(data);
+            let pos = 0;
+            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");
+            }
+            // 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();
+                pos += UINT16_NUM_BYTES;
+                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) {
+                    value.solana = buffData.subarray(pos, pos + len);
+                } else if (magic == FORMAT_MAGICS_LE.LE_ECDSA) {
+                    value.leEcdsa = buffData.subarray(pos, pos + len);
+                } else if (magic == FORMAT_MAGICS_LE.LE_UNSIGNED) {
+                    value.leUnsigned = buffData.subarray(pos, pos + len);
+                } else if (magic == 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()}`);
+                }
+                pos += len;
+            }
+            handler({
+                type: "binary",
+                value
+            });
+        });
+    }
+    subscribe(request) {
+        const wsp = this.getWebSocketPool();
+        if (request.type !== "subscribe") {
+            throw new Error("Request must be a subscribe request");
+        }
+        wsp.addSubscription(request);
+    }
+    unsubscribe(subscriptionId) {
+        const wsp = this.getWebSocketPool();
+        wsp.removeSubscription(subscriptionId);
+    }
+    send(request) {
+        const wsp = this.getWebSocketPool();
+        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);
+    }
+    shutdown() {
+        const wsp = this.getWebSocketPool();
+        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
+        };
+        return fetch(url, {
+            ...options,
+            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) {
+        const url = new URL(`${this.metadataServiceUrl}/v1/symbols`);
+        if (params?.query) {
+            url.searchParams.set("query", params.query);
+        }
+        if (params?.asset_type) {
+            url.searchParams.set("asset_type", params.asset_type);
+        }
+        try {
+            const response = await this.authenticatedFetch(url.toString());
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
+            }
+            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) {
+        const url = `${this.priceServiceUrl}/v1/latest_price`;
+        try {
+            const body = JSON.stringify(params);
+            this.logger.debug("getLatestPrice", {
+                url,
+                body
+            });
+            const response = await this.authenticatedFetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: body
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
+            }
+            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) {
+        const url = `${this.priceServiceUrl}/v1/price`;
+        try {
+            const body = JSON.stringify(params);
+            this.logger.debug("getPrice", {
+                url,
+                body
+            });
+            const response = await this.authenticatedFetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: body
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${String(response.status)} - ${await response.text()}`);
+            }
+            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" }