@n1xyz/nord-ts 0.0.12 → 0.0.14

package/dist/types.d.ts

@@ -15,6 +15,16 @@ export declare enum PeakTpsPeriodUnit {
     Month = "m",
     Year = "y"
 }
+/**
+ * Nord subscription type for trades or deltas
+ */
+export type SubscriptionType = 'trades' | 'deltas' | 'account';
+/**
+ * Pattern for a valid Nord subscription
+ * Format should be: "<type>@<parameter>"
+ * Examples: "trades@BTCUSDC", "deltas@ETHUSDC", "account@42"
+ */
+export type SubscriptionPattern = `${SubscriptionType}@${string}` | string;
 /**
  * Configuration options for the Nord client
  */
@@ -27,11 +37,24 @@ export interface NordConfig {
     solanaUrl: string;
     /** Whether to initialize WebSockets on creation, defaults to true */
     initWebSockets?: boolean;
-    /** Initial subscriptions for the trades WebSocket (e.g., ["trades@BTCUSDC"]) */
-    tradesSubscriptions?: string[];
-    /** Initial subscriptions for the deltas WebSocket (e.g., ["deltas@BTCUSDC"]) */
-    deltasSubscriptions?: string[];
+    /**
+     * Initial subscriptions for the trades WebSocket
+     * Supports both formats:
+     * - Legacy format: ["BTCUSDC", "ETHUSDC"]
+     * - New format: ["trades@BTCUSDC", "trades@ETHUSDC"]
+     */
+    tradesSubscriptions?: SubscriptionPattern[];
+    /**
+     * Initial subscriptions for the deltas WebSocket
+     * Supports both formats:
+     * - Legacy format: ["BTCUSDC", "ETHUSDC"]
+     * - New format: ["deltas@BTCUSDC", "deltas@ETHUSDC"]
+     */
+    deltasSubscriptions?: SubscriptionPattern[];
 }
+/**
+ * Configuration options for the Nord client
+ */
 export interface TokenInfo {
     address: string;
     precision: number;
@@ -355,22 +378,22 @@ export interface ActionNonceResponse {
 export declare enum WebSocketMessageType {
     Subscribe = "subscribe",
     Unsubscribe = "unsubscribe",
-    TradeUpdate = "trade",
+    TradeUpdate = "trades",
     DeltaUpdate = "delta",
-    UserUpdate = "user"
+    AccountUpdate = "account"
 }
 /**
  * WebSocket subscription request
  */
 export interface WebSocketSubscription {
-    type: WebSocketMessageType;
+    e: WebSocketMessageType;
     streams: string[];
 }
 /**
  * WebSocket trade update message
  */
 export interface WebSocketTradeUpdate {
-    type: WebSocketMessageType.TradeUpdate;
+    e: WebSocketMessageType.TradeUpdate;
     symbol: string;
     trades: Trade[];
     timestamp: number;
@@ -379,7 +402,7 @@ export interface WebSocketTradeUpdate {
  * WebSocket delta update message
  */
 export interface WebSocketDeltaUpdate {
-    type: WebSocketMessageType.DeltaUpdate;
+    e: WebSocketMessageType.DeltaUpdate;
     last_update_id: number;
     update_id: number;
     market_symbol: string;
@@ -390,11 +413,11 @@ export interface WebSocketDeltaUpdate {
 /**
  * WebSocket user update message
  */
-export interface WebSocketUserUpdate {
-    type: WebSocketMessageType.UserUpdate;
-    userId: number;
+export interface WebSocketAccountUpdate {
+    e: WebSocketMessageType.AccountUpdate;
+    accountId: number;
     account: Account;
     timestamp: number;
 }
-export type WebSocketMessage = WebSocketSubscription | WebSocketTradeUpdate | WebSocketDeltaUpdate | WebSocketUserUpdate;
+export type WebSocketMessage = WebSocketSubscription | WebSocketTradeUpdate | WebSocketDeltaUpdate | WebSocketAccountUpdate;
 export {};

package/dist/types.js

@@ -97,7 +97,7 @@ var WebSocketMessageType;
 (function (WebSocketMessageType) {
     WebSocketMessageType["Subscribe"] = "subscribe";
     WebSocketMessageType["Unsubscribe"] = "unsubscribe";
-    WebSocketMessageType["TradeUpdate"] = "trade";
+    WebSocketMessageType["TradeUpdate"] = "trades";
     WebSocketMessageType["DeltaUpdate"] = "delta";
-    WebSocketMessageType["UserUpdate"] = "user";
+    WebSocketMessageType["AccountUpdate"] = "account";
 })(WebSocketMessageType || (exports.WebSocketMessageType = WebSocketMessageType = {}));

package/dist/websocket/NordWebSocketClient.d.ts

@@ -4,9 +4,6 @@ import { NordWebSocketClientEvents } from "./events";
  * WebSocket client for Nord exchange
  *
  * This client connects to one of the specific Nord WebSocket endpoints:
- * - /ws/trades - For trade updates
- * - /ws/deltas - For orderbook delta updates
- * - /ws/user - For user-specific updates
  *
  * Each endpoint handles a specific type of data and subscriptions must match
  * the endpoint type (e.g., only 'trades@BTCUSDC' subscriptions are valid on

package/dist/websocket/NordWebSocketClient.js

@@ -7,16 +7,13 @@ exports.NordWebSocketClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const types_1 = require("../types");
-const VALID_STREAM_TYPES = ["trades", "deltas", "user"];
+const VALID_STREAM_TYPES = ["trades", "delta", "account"];
 // Constants for WebSocket readyState
 const WS_OPEN = 1;
 /**
  * WebSocket client for Nord exchange
  *
  * This client connects to one of the specific Nord WebSocket endpoints:
- * - /ws/trades - For trade updates
- * - /ws/deltas - For orderbook delta updates
- * - /ws/user - For user-specific updates
  *
  * Each endpoint handles a specific type of data and subscriptions must match
  * the endpoint type (e.g., only 'trades@BTCUSDC' subscriptions are valid on
@@ -64,8 +61,8 @@ class NordWebSocketClient extends events_1.EventEmitter {
         if (!VALID_STREAM_TYPES.includes(type)) {
             throw new Error(`Invalid stream type: ${type}. Valid types are: ${VALID_STREAM_TYPES.join(", ")}`);
         }
-        if (type === "user" && !/^\d+$/.test(params)) {
-            throw new Error(`Invalid user ID in stream: ${params}. Expected numeric ID`);
+        if (type === "account" && !/^\d+$/.test(params)) {
+            throw new Error(`Invalid account ID in stream: ${params}. Expected numeric ID`);
         }
     }
     /**
@@ -228,7 +225,7 @@ class NordWebSocketClient extends events_1.EventEmitter {
             return;
         }
         const message = {
-            type: types_1.WebSocketMessageType.Subscribe,
+            e: types_1.WebSocketMessageType.Subscribe,
             streams,
         };
         try {
@@ -266,7 +263,7 @@ class NordWebSocketClient extends events_1.EventEmitter {
             return;
         }
         const message = {
-            type: types_1.WebSocketMessageType.Unsubscribe,
+            e: types_1.WebSocketMessageType.Unsubscribe,
             streams,
         };
         try {
@@ -311,18 +308,18 @@ class NordWebSocketClient extends events_1.EventEmitter {
      * @param message WebSocket message
      */
     handleMessage(message) {
-        switch (message.type) {
+        switch (message.e) {
             case types_1.WebSocketMessageType.TradeUpdate:
-                this.emit("trade", message);
+                this.emit("trades", message);
                 break;
             case types_1.WebSocketMessageType.DeltaUpdate:
                 this.emit("delta", message);
                 break;
-            case types_1.WebSocketMessageType.UserUpdate:
-                this.emit("user", message);
+            case types_1.WebSocketMessageType.AccountUpdate:
+                this.emit("account", message);
                 break;
             default:
-                this.emit("error", new Error(`Unknown message type: ${message.type}`));
+                this.emit("error", new Error(`Unknown message type: ${message.e}`));
         }
     }
     /**

package/dist/websocket/events.d.ts

@@ -1,4 +1,4 @@
-import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketUserUpdate } from "../types";
+import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketAccountUpdate } from "../types";
 /**
  * Event type definitions for the NordWebSocketClient
  */
@@ -8,7 +8,7 @@ export interface NordWebSocketEvents {
     error: (error: Error) => void;
     trade: (update: WebSocketTradeUpdate) => void;
     delta: (update: WebSocketDeltaUpdate) => void;
-    user: (update: WebSocketUserUpdate) => void;
+    account: (update: WebSocketAccountUpdate) => void;
 }
 /**
  * Type declaration for NordWebSocketClient event methods

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Typescript for Nord",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/idl/bridge.ts

@@ -927,4 +927,3 @@ export const BRIDGE_IDL: Idl = {
     },
   ],
 };
-

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";
@@ -77,27 +77,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 +140,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 +157,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,22 +75,25 @@ 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
  */
@@ -101,26 +104,29 @@ function calculatePeakTps(text: string): number {
 
 /**
  * Extract latency from Prometheus metrics
- * 
+ *
  * @param text - Prometheus-formatted metrics text
  * @returns Average latency in seconds
  */
 function extractLatency(text: string): number {
   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 +241,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();