@n1xyz/nord-ts 0.0.12 → 0.0.15

package/dist/nord/api/core.js

@@ -67,7 +67,7 @@ async function getInfo(webServerUrl) {
  */
 async function getAccount(webServerUrl, accountId) {
     try {
-        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/account?account_id=${accountId}`);
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/account/${accountId}`);
         return await response.json();
     }
     catch (error) {
@@ -77,22 +77,48 @@ async function getAccount(webServerUrl, accountId) {
 /**
  * Initialize a WebSocket client for Nord
  *
- * Connects to one of the specific Nord WebSocket endpoints:
- * - /ws/trades - For trade updates (default)
- * - /ws/deltas - For orderbook delta updates
- * - /ws/user - For user-specific updates
+ * Connects to the Nord WebSocket endpoint with support for multiple subscription types:
+ * - trades@SYMBOL - For trade updates
+ * - deltas@SYMBOL - For orderbook delta updates
+ * - account@ACCOUNT_ID - For user-specific updates
  *
  * @param webServerUrl - Base URL for the Nord web server
- * @param endpoint - Specific WebSocket endpoint to connect to (trades, deltas, or user)
- * @param initialSubscriptions - Optional array of initial subscriptions (e.g., ["trades@BTCUSDC"])
+ * @param subscriptions - Array of subscriptions (e.g., ["trades@BTCUSDC", "deltas@BTCUSDC", "account@42"])
  * @returns WebSocket client
+ * @throws {NordError} If initialization fails or invalid subscription is provided
  */
-function initWebSocketClient(webServerUrl, endpoint, initialSubscriptions) {
+function initWebSocketClient(webServerUrl, subscriptions, initialSubscriptions) {
     try {
-        // Convert HTTP URL to WebSocket URL with specific endpoint
-        // If no specific endpoint is provided, we'll connect to trades by default
-        const specificEndpoint = endpoint || "trades";
-        const wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws/${specificEndpoint}`;
+        // Determine URL and subscriptions based on parameters
+        let wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws`;
+        let wsSubscriptions = [];
+        // Validate subscriptions parameter
+        if (typeof subscriptions === "string") {
+            // Legacy mode - handle endpoint string
+            if (subscriptions === "trades" ||
+                subscriptions === "delta" ||
+                subscriptions === "account") {
+                wsUrl += `/${subscriptions}`;
+                // If initialSubscriptions provided, use them
+                if (initialSubscriptions && initialSubscriptions.length > 0) {
+                    // Validate initialSubscriptions
+                    initialSubscriptions.forEach(validateSubscription);
+                    wsSubscriptions = initialSubscriptions;
+                }
+            }
+            else {
+                throw new NordError_1.NordError(`Invalid endpoint: ${subscriptions}. Must be "trades", "deltas", or "account".`);
+            }
+        }
+        else if (Array.isArray(subscriptions) && subscriptions.length > 0) {
+            // New mode - validate and combine subscriptions in URL
+            subscriptions.forEach(validateSubscription);
+            wsUrl += `/${subscriptions.join("&")}`;
+        }
+        else {
+            // Default to trades endpoint if no subscriptions specified
+            wsUrl += `/trades`;
+        }
         console.log(`Initializing WebSocket client with URL: ${wsUrl}`);
         // Create and connect the WebSocket client
         const ws = new index_1.NordWebSocketClient(wsUrl);
@@ -103,9 +129,10 @@ function initWebSocketClient(webServerUrl, endpoint, initialSubscriptions) {
         // Add connected handler for debugging
         ws.on("connected", () => {
             console.log("Nord WebSocket connected successfully");
-            // Subscribe to initial subscriptions if provided
-            if (initialSubscriptions && initialSubscriptions.length > 0) {
-                ws.subscribe(initialSubscriptions);
+            // Subscribe to additional subscriptions if provided
+            // For new format, these are already part of the URL
+            if (wsSubscriptions.length > 0) {
+                ws.subscribe(wsSubscriptions);
             }
         });
         // Connect the WebSocket
@@ -119,3 +146,19 @@ function initWebSocketClient(webServerUrl, endpoint, initialSubscriptions) {
         });
     }
 }
+/**
+ * Validates a subscription string follows the correct format
+ *
+ * @param subscription - The subscription to validate
+ * @throws {NordError} If the subscription format is invalid
+ */
+function validateSubscription(subscription) {
+    const [type, param] = subscription.split("@");
+    if (!type || !param || !["trades", "deltas", "account"].includes(type)) {
+        throw new NordError_1.NordError(`Invalid subscription format: ${subscription}. Expected format: "trades@SYMBOL", "deltas@SYMBOL", or "account@ID"`);
+    }
+    // Additional validation for account subscriptions
+    if (type === "account" && isNaN(Number(param))) {
+        throw new NordError_1.NordError(`Invalid account ID in subscription: ${subscription}. Account ID must be a number.`);
+    }
+}

package/dist/nord/api/metrics.js

@@ -43,7 +43,7 @@ async function aggregateMetrics(webServerUrl, txPeakTpsPeriod = 1, txPeakTpsPeri
             tx_total: extractMetricValue(text, "nord_requests_ok_count"),
             tx_tps: calculateTps(text),
             tx_tps_peak: calculatePeakTps(text),
-            request_latency_average: extractLatency(text)
+            request_latency_average: extractLatency(text),
         };
         return metrics;
     }
@@ -59,7 +59,7 @@ async function aggregateMetrics(webServerUrl, txPeakTpsPeriod = 1, txPeakTpsPeri
  * @returns The metric value as a number, or 0 if not found
  */
 function extractMetricValue(text, metricName) {
-    const regex = new RegExp(`^${metricName}\\s+([\\d.]+)`, 'm');
+    const regex = new RegExp(`^${metricName}\\s+([\\d.]+)`, "m");
     const match = text.match(regex);
     return match ? parseFloat(match[1]) : 0;
 }
@@ -91,6 +91,7 @@ function calculateTps(text) {
  */
 function calculatePeakTps(text) {
     // For peak TPS, we'll use a simple heuristic: 2x the current TPS estimate
+    // TODO: fix this
     return calculateTps(text) * 2;
 }
 /**
@@ -100,6 +101,7 @@ function calculatePeakTps(text) {
  * @returns Average latency in seconds
  */
 function extractLatency(text) {
+    // TODO: fix - using average for latency is kinda wack. ok to merge for now but should change.
     const latencySum = extractSummaryValue(text, "nord_requests_ok_latency_sum");
     const latencyCount = extractSummaryValue(text, "nord_requests_ok_latency_count");
     return latencyCount > 0 ? latencySum / latencyCount : 0;
@@ -112,7 +114,7 @@ function extractLatency(text) {
  * @returns The metric value as a number, or 0 if not found
  */
 function extractSummaryValue(text, metricName) {
-    const regex = new RegExp(`^${metricName}\\s+([\\d.]+)`, 'm');
+    const regex = new RegExp(`^${metricName}\\s+([\\d.]+)`, "m");
     const match = text.match(regex);
     return match ? parseFloat(match[1]) : 0;
 }
@@ -208,7 +210,8 @@ async function queryPrometheus(webServerUrl, params) {
             const data = JSON.parse(text);
             return data.data.result[0]?.value[1] || 0;
         }
-        catch (e) {
+        catch (error) {
+            console.log("Prometheus query failed:", error);
             // Try to find a number in the response
             const numberMatch = text.match(/[\d.]+/);
             if (numberMatch) {

package/dist/nord/client/Nord.d.ts

@@ -8,14 +8,27 @@ import { OrderbookSubscription, TradeSubscription } from "../models/Subscriber";
 export interface UserSubscription extends EventEmitter {
     close: () => void;
 }
+/**
+ * WebSocket subscription options interface
+ */
+export interface WebSocketSubscriptionOptions {
+    /** Market symbols to subscribe to for trade updates */
+    trades?: string[];
+    /** Market symbols to subscribe to for orderbook delta updates */
+    deltas?: string[];
+    /** Account IDs to subscribe to for account updates */
+    accounts?: number[];
+}
 /**
  * Main Nord client class for interacting with the Nord API
  */
 export declare class Nord {
     /** Base URL for the Nord web server */
     readonly webServerUrl: string;
-    /** Solana program ID */
-    readonly solanaProgramId: string;
+    /** Bridge verification key */
+    readonly bridgeVk: string;
+    /** Optional Solana program ID (will be derived from bridgeVk) */
+    private _solanaProgramId;
     /** Solana RPC URL */
     readonly solanaUrl: string;
     /** Available markets */
@@ -24,57 +37,38 @@ export declare class Nord {
     tokens: Token[];
     /** Map of symbol to market_id */
     private symbolToMarketId;
-    /**
-     * WebSocket client for trades
-     * @private
-     */
-    private tradesWs;
-    /**
-     * WebSocket client for orderbook deltas
-     * @private
-     */
-    private deltasWs;
-    /**
-     * WebSocket client for user updates
-     * @private
-     */
-    private userWs;
-    /**
-     * Initial subscriptions for the trades WebSocket
-     * @private
-     */
-    private tradesSubscriptions?;
-    /**
-     * Initial subscriptions for the deltas WebSocket
-     * @private
-     */
-    private deltasSubscriptions?;
     /**
      * Create a new Nord client
      *
      * @param config - Configuration options for the Nord client
      * @param config.webServerUrl - Base URL for the Nord web server
-     * @param config.solanaProgramId - Solana program ID
+     * @param config.bridgeVk - Bridge verification key
      * @param config.solanaUrl - Solana cluster URL
-     * @param config.initWebSockets - Whether to initialize WebSockets on creation, defaults to true
-     * @param config.tradesSubscriptions - Optional array of trades subscriptions to initialize with (e.g., ["trades@BTCUSDC"])
-     * @param config.deltasSubscriptions - Optional array of deltas subscriptions to initialize with (e.g., ["deltas@BTCUSDC"])
      * @throws {Error} If required configuration is missing
      */
-    constructor({ webServerUrl, solanaProgramId, solanaUrl, initWebSockets, tradesSubscriptions, deltasSubscriptions, }: NordConfig);
+    constructor(config: NordConfig);
     /**
-     * Initialize WebSocket clients for trades and deltas
+     * Create a WebSocket client with specific subscriptions
      *
-     * This method can be called manually if websockets were not initialized during construction
-     * (i.e., if initWebSockets was set to false in the constructor).
+     * @param options - Subscription options that specify which data streams to subscribe to
+     * @returns A new WebSocket client with the requested subscriptions
+     * @throws {NordError} If invalid subscription options are provided
      *
-     * It initializes the trades and deltas WebSocket clients. The user WebSocket client
-     * is initialized on demand when needed.
+     * @example
+     * // Create a client for trades and deltas from one market and an account
+     * const wsClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC"],
+     *   deltas: ["BTCUSDC"],
+     *   accounts: [123]
+     * });
      *
-     * @param tradesSubscriptions - Optional array of trades subscriptions to initialize with
-     * @param deltasSubscriptions - Optional array of deltas subscriptions to initialize with
+     * @example
+     * // Create a client for trades from multiple markets
+     * const tradesClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC", "ETHUSDC"]
+     * });
      */
-    initializeWebSockets(tradesSubscriptions?: string[], deltasSubscriptions?: string[]): void;
+    createWebSocketClient(options: WebSocketSubscriptionOptions): NordWebSocketClient;
     /**
      * Get the current timestamp from the Nord server
      *
@@ -100,15 +94,24 @@ export declare class Nord {
      *
      * @param nordConfig - Configuration options for the Nord client
      * @param nordConfig.webServerUrl - Base URL for the Nord web server
-     * @param nordConfig.solanaProgramId - Solana program ID
+     * @param nordConfig.bridgeVk - Bridge verification key
      * @param nordConfig.solanaUrl - Solana cluster URL
-     * @param nordConfig.initWebSockets - Whether to initialize WebSockets on creation, defaults to true
-     * @param nordConfig.tradesSubscriptions - Optional array of trades subscriptions (e.g., ["trades@BTCUSDC"])
-     * @param nordConfig.deltasSubscriptions - Optional array of deltas subscriptions (e.g., ["deltas@BTCUSDC"])
      * @returns Initialized Nord client
      * @throws {NordError} If initialization fails
      */
     static initNord(nordConfig: NordConfig): Promise<Nord>;
+    /**
+     * Initialize the Nord client by deriving program ID and fetching info
+     * @private
+     */
+    private init;
+    /**
+     * Get the Solana program ID derived from bridge VK
+     *
+     * @returns Program ID string
+     * @throws {NordError} If program ID hasn't been initialized
+     */
+    getSolanaProgramId(): string;
     /**
      * Get market statistics
      *
@@ -204,39 +207,12 @@ export declare class Nord {
      * @throws {NordError} If the request fails
      */
     queryPrometheus(params: string): Promise<number>;
-    /**
-     * Get the trades WebSocket client (default)
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for trades
-     */
-    getWebSocketClient(): NordWebSocketClient;
-    /**
-     * Get the trades WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for trades
-     */
-    getTradesWebSocketClient(): NordWebSocketClient;
-    /**
-     * Get the deltas WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for orderbook deltas
-     */
-    getDeltasWebSocketClient(): NordWebSocketClient;
-    /**
-     * Get the user WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for user updates
-     */
-    getUserWebSocketClient(): NordWebSocketClient;
     /**
      * Subscribe to orderbook updates for a market
      *
      * @param symbol - Market symbol
      * @returns Orderbook subscription
+     * @throws {NordError} If symbol is invalid
      */
     subscribeOrderbook(symbol: string): OrderbookSubscription;
     /**
@@ -244,8 +220,17 @@ export declare class Nord {
      *
      * @param symbol - Market symbol
      * @returns Trade subscription
+     * @throws {NordError} If symbol is invalid
      */
     subscribeTrades(symbol: string): TradeSubscription;
+    /**
+     * Subscribe to account updates
+     *
+     * @param accountId - Account ID to subscribe to
+     * @returns User subscription
+     * @throws {NordError} If accountId is invalid
+     */
+    subscribeAccount(accountId: number): UserSubscription;
     /**
      * Get trades for a market
      *