@n1xyz/nord-ts 0.0.12 → 0.0.15

package/src/idl/index.ts

@@ -0,0 +1,2 @@
+import data from "./bridge.json";
+export const BRIDGE_IDL = data;

package/src/nord/api/core.ts

@@ -1,4 +1,4 @@
-import { Account, Info } from "../../types";
+import { Account, Info, SubscriptionPattern } from "../../types";
 import { checkedFetch } from "../../utils";
 import { NordWebSocketClient } from "../../websocket/index";
 import { NordError } from "../utils/NordError";
@@ -65,9 +65,7 @@ export async function getAccount(
   accountId: number,
 ): Promise<Account> {
   try {
-    const response = await checkedFetch(
-      `${webServerUrl}/account?account_id=${accountId}`,
-    );
+    const response = await checkedFetch(`${webServerUrl}/account/${accountId}`);
     return await response.json();
   } catch (error) {
     throw new NordError(`Failed to get account ${accountId}`, { cause: error });
@@ -77,27 +75,55 @@ export async function getAccount(
 /**
  * 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
  */
 export function initWebSocketClient(
   webServerUrl: string,
-  endpoint?: "trades" | "deltas" | "user",
-  initialSubscriptions?: string[],
+  subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account",
+  initialSubscriptions?: SubscriptionPattern[],
 ): NordWebSocketClient {
   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: SubscriptionPattern[] = [];
+
+    // 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(
+          `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
@@ -112,9 +138,10 @@ export function initWebSocketClient(
     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);
       }
     });
 
@@ -128,3 +155,26 @@ export function initWebSocketClient(
     });
   }
 }
+
+/**
+ * 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: string): void {
+  const [type, param] = subscription.split("@");
+
+  if (!type || !param || !["trades", "deltas", "account"].includes(type)) {
+    throw new 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(
+      `Invalid account ID in subscription: ${subscription}. Account ID must be a number.`,
+    );
+  }
+}

package/src/nord/api/metrics.ts

@@ -33,19 +33,19 @@ export async function aggregateMetrics(
     const response = await checkedFetch(
       `${webServerUrl}/metrics?tx_peak_tps_period=${txPeakTpsPeriod}&tx_peak_tps_period_unit=${txPeakTpsPeriodUnit}`,
     );
-    
+
     // Get the raw text response (Prometheus format)
     const text = await response.text();
-    
+
     // Parse the Prometheus-formatted metrics text into an AggregateMetrics object
     const metrics: AggregateMetrics = {
       blocks_total: 0,
       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;
   } catch (error) {
     throw new NordError("Failed to fetch aggregate metrics", { cause: error });
@@ -54,20 +54,20 @@ export async function aggregateMetrics(
 
 /**
  * Extract a metric value from Prometheus-formatted text
- * 
+ *
  * @param text - Prometheus-formatted metrics text
  * @param metricName - Name of the metric to extract
  * @returns The metric value as a number, or 0 if not found
  */
 function extractMetricValue(text: string, metricName: string): number {
-  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;
 }
 
 /**
  * Calculate TPS from Prometheus metrics
- * 
+ *
  * @param text - Prometheus-formatted metrics text
  * @returns Calculated TPS value
  */
@@ -75,52 +75,60 @@ function calculateTps(text: string): number {
   // Use the request count and latency to estimate TPS
   const requestCount = extractMetricValue(text, "nord_requests_ok_count");
   const latencySum = extractSummaryValue(text, "nord_requests_ok_latency_sum");
-  const latencyCount = extractSummaryValue(text, "nord_requests_ok_latency_count");
-  
+  const latencyCount = extractSummaryValue(
+    text,
+    "nord_requests_ok_latency_count",
+  );
+
   if (latencySum > 0 && latencyCount > 0) {
     // Average latency in seconds
     const avgLatency = latencySum / latencyCount;
     // If we have valid latency data, estimate TPS as requests per second
     return avgLatency > 0 ? requestCount / (latencyCount * avgLatency) : 0;
   }
-  
+
   // Fallback: just return a small fraction of the total request count
   return requestCount > 0 ? requestCount / 100 : 0;
 }
 
 /**
  * Calculate peak TPS from Prometheus metrics
- * 
+ *
  * @param text - Prometheus-formatted metrics text
  * @returns Calculated peak TPS value
  */
 function calculatePeakTps(text: string): number {
   // For peak TPS, we'll use a simple heuristic: 2x the current TPS estimate
+  // TODO: fix this
   return calculateTps(text) * 2;
 }
 
 /**
  * Extract latency from Prometheus metrics
- * 
+ *
  * @param text - Prometheus-formatted metrics text
  * @returns Average latency in seconds
  */
 function extractLatency(text: string): number {
+  // 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");
-  
+  const latencyCount = extractSummaryValue(
+    text,
+    "nord_requests_ok_latency_count",
+  );
+
   return latencyCount > 0 ? latencySum / latencyCount : 0;
 }
 
 /**
  * Extract a summary value from Prometheus-formatted text
- * 
+ *
  * @param text - Prometheus-formatted metrics text
  * @param metricName - Name of the metric to extract
  * @returns The metric value as a number, or 0 if not found
  */
 function extractSummaryValue(text: string, metricName: string): number {
-  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;
 }
@@ -235,21 +243,21 @@ export async function queryPrometheus(
     const response = await checkedFetch(
       `${webServerUrl}/prometheus?query=${encodeURIComponent(params)}`,
     );
-    
+
     // Handle raw text response
     const text = await response.text();
     try {
       // Try to parse as JSON first
       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) {
         return parseFloat(numberMatch[0]);
       }
-      
+
       // Return 0 if no number is found
       return 0;
     }

package/src/nord/api/queries.ts

@@ -2,17 +2,12 @@ import {
   ActionQuery,
   ActionResponse,
   ActionsResponse,
-  BlockQuery,
-  BlockResponse,
-  BlockSummaryResponse,
   RollmanActionResponse,
   RollmanActionsResponse,
-  RollmanBlockResponse,
 } from "../../types";
 import { checkedFetch } from "../../utils";
 import { NordError } from "../utils/NordError";
 
-
 /**
  * Query a specific action
  *
@@ -60,9 +55,12 @@ export async function queryRecentActions(
     );
     return await response.json();
   } catch (error) {
-    throw new NordError(`Failed to query recent actions (from ${from} to ${to})`, {
-      cause: error,
-    });
+    throw new NordError(
+      `Failed to query recent actions (from ${from} to ${to})`,
+      {
+        cause: error,
+      },
+    );
   }
 }
 
@@ -73,9 +71,7 @@ export async function queryRecentActions(
  * @returns Last action ID
  * @throws {NordError} If the request fails
  */
-export async function getLastActionId(
-  webServerUrl: string,
-): Promise<number> {
+export async function getLastActionId(webServerUrl: string): Promise<number> {
   try {
     const response = await checkedFetch(`${webServerUrl}/last_actionid`);
     const data = await response.json();