@n1xyz/nord-ts 0.0.12 → 0.0.14

package/src/nord/client/Nord.ts

@@ -14,11 +14,12 @@ import {
   PeakTpsPeriodUnit,
   RollmanActionResponse,
   RollmanActionsResponse,
+  SubscriptionPattern,
   Token,
   TradesQuery,
   TradesResponse,
   UserAccountIdsQuery,
-  UserAccountIdsResponse
+  UserAccountIdsResponse,
 } from "../../types";
 import { NordWebSocketClient } from "../../websocket/index";
 import * as core from "../api/core";
@@ -35,6 +36,18 @@ 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
  */
@@ -57,36 +70,6 @@ export class Nord {
   /** Map of symbol to market_id */
   private symbolToMarketId: Map<string, number> = new Map();
 
-  /**
-   * WebSocket client for trades
-   * @private
-   */
-  private tradesWs: NordWebSocketClient | null = null;
-
-  /**
-   * WebSocket client for orderbook deltas
-   * @private
-   */
-  private deltasWs: NordWebSocketClient | null = null;
-
-  /**
-   * WebSocket client for user updates
-   * @private
-   */
-  private userWs: NordWebSocketClient | null = null;
-
-  /**
-   * Initial subscriptions for the trades WebSocket
-   * @private
-   */
-  private tradesSubscriptions?: string[];
-
-  /**
-   * Initial subscriptions for the deltas WebSocket
-   * @private
-   */
-  private deltasSubscriptions?: string[];
-
   /**
    * Create a new Nord client
    *
@@ -94,19 +77,9 @@ export class Nord {
    * @param config.webServerUrl - Base URL for the Nord web server
    * @param config.solanaProgramId - Solana program ID
    * @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 = true,
-    tradesSubscriptions,
-    deltasSubscriptions,
-  }: NordConfig) {
+  constructor({ webServerUrl, solanaProgramId, solanaUrl }: NordConfig) {
     if (!webServerUrl) {
       throw new NordError("webServerUrl is required");
     }
@@ -122,48 +95,67 @@ export class Nord {
     this.webServerUrl = webServerUrl;
     this.solanaProgramId = solanaProgramId;
     this.solanaUrl = solanaUrl;
-
-    // Store subscription parameters
-    this.tradesSubscriptions = tradesSubscriptions;
-    this.deltasSubscriptions = deltasSubscriptions;
-
-    // Initialize WebSocket clients only if initWebSockets is true
-    if (initWebSockets) {
-      this.initializeWebSockets();
-    }
   }
 
   /**
-   * 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"]
+   * });
    */
-  public initializeWebSockets(
-    tradesSubscriptions?: string[],
-    deltasSubscriptions?: string[],
-  ): void {
-    // Use provided subscriptions or fall back to stored ones
-    const trades = tradesSubscriptions || this.tradesSubscriptions;
-    const deltas = deltasSubscriptions || this.deltasSubscriptions;
-
-    // Initialize WebSocket clients for each endpoint with subscriptions
-    this.tradesWs = core.initWebSocketClient(
-      this.webServerUrl,
-      "trades",
-      trades,
-    );
-    this.deltasWs = core.initWebSocketClient(
-      this.webServerUrl,
-      "deltas",
-      deltas,
-    );
+  public createWebSocketClient(
+    options: WebSocketSubscriptionOptions,
+  ): NordWebSocketClient {
+    const subscriptions: SubscriptionPattern[] = [];
+
+    // Add trade subscriptions
+    if (options.trades && options.trades.length > 0) {
+      options.trades.forEach((symbol) => {
+        subscriptions.push(`trades@${symbol}` as SubscriptionPattern);
+      });
+    }
+
+    // Add delta subscriptions
+    if (options.deltas && options.deltas.length > 0) {
+      options.deltas.forEach((symbol) => {
+        subscriptions.push(`deltas@${symbol}` as SubscriptionPattern);
+      });
+    }
+
+    // Add account subscriptions
+    if (options.accounts && options.accounts.length > 0) {
+      options.accounts.forEach((accountId) => {
+        if (isNaN(accountId) || accountId <= 0) {
+          throw new NordError(
+            `Invalid account ID: ${accountId}. Must be a positive number.`,
+          );
+        }
+        subscriptions.push(`account@${accountId}` as SubscriptionPattern);
+      });
+    }
+
+    // Validate that at least one subscription was provided
+    if (subscriptions.length === 0) {
+      throw new NordError("At least one subscription must be provided");
+    }
+
+    // Create and return a new WebSocket client
+    return core.initWebSocketClient(this.webServerUrl, subscriptions);
   }
 
   /**
@@ -214,9 +206,6 @@ export class Nord {
    * @param nordConfig.webServerUrl - Base URL for the Nord web server
    * @param nordConfig.solanaProgramId - Solana program ID
    * @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
    */
@@ -268,7 +257,7 @@ export class Nord {
   async getLastActionId(): Promise<number> {
     return queries.getLastActionId(this.webServerUrl);
   }
-  
+
   /**
    * Fetch aggregate metrics from the Nord API
    *
@@ -364,68 +353,22 @@ export class Nord {
     return metrics.queryPrometheus(this.webServerUrl, params);
   }
 
-  /**
-   * Get the trades WebSocket client (default)
-   * If not already initialized, it will be created
-   *
-   * @returns WebSocket client for trades
-   */
-  public getWebSocketClient(): NordWebSocketClient {
-    if (!this.tradesWs) {
-      this.initializeWebSockets();
-    }
-    return this.tradesWs!;
-  }
-
-  /**
-   * Get the trades WebSocket client
-   * If not already initialized, it will be created
-   *
-   * @returns WebSocket client for trades
-   */
-  public getTradesWebSocketClient(): NordWebSocketClient {
-    if (!this.tradesWs) {
-      this.initializeWebSockets();
-    }
-    return this.tradesWs!;
-  }
-
-  /**
-   * Get the deltas WebSocket client
-   * If not already initialized, it will be created
-   *
-   * @returns WebSocket client for orderbook deltas
-   */
-  public getDeltasWebSocketClient(): NordWebSocketClient {
-    if (!this.deltasWs) {
-      this.initializeWebSockets();
-    }
-    return this.deltasWs!;
-  }
-
-  /**
-   * Get the user WebSocket client
-   * If not already initialized, it will be created
-   *
-   * @returns WebSocket client for user updates
-   */
-  public getUserWebSocketClient(): NordWebSocketClient {
-    if (!this.userWs) {
-      // Initialize user WebSocket client on demand
-      this.userWs = core.initWebSocketClient(this.webServerUrl, "user");
-      return this.userWs;
-    }
-    return this.userWs;
-  }
-
   /**
    * Subscribe to orderbook updates for a market
    *
    * @param symbol - Market symbol
    * @returns Orderbook subscription
+   * @throws {NordError} If symbol is invalid
    */
   public subscribeOrderbook(symbol: string): OrderbookSubscription {
+    if (!symbol || typeof symbol !== "string") {
+      throw new NordError("Invalid market symbol");
+    }
+
     const subscription = new EventEmitter() as OrderbookSubscription;
+    const wsClient = this.createWebSocketClient({
+      deltas: [symbol],
+    });
 
     const handleDelta = (update: {
       symbol: string;
@@ -439,17 +382,11 @@ export class Nord {
       subscription.emit("message", update);
     };
 
-    // Initialize deltas websocket if it doesn't exist
-    if (!this.deltasWs) {
-      this.initializeWebSockets();
-    }
-
-    this.deltasWs!.on("delta", handleDelta);
-    this.deltasWs!.subscribe([`deltas@${symbol}`]);
+    wsClient.on("delta", handleDelta);
 
     subscription.close = () => {
-      this.deltasWs!.unsubscribe([`deltas@${symbol}`]);
-      this.deltasWs!.removeListener("delta", handleDelta);
+      wsClient.unsubscribe([`deltas@${symbol}`]);
+      wsClient.removeListener("delta", handleDelta);
       subscription.removeAllListeners();
     };
 
@@ -461,9 +398,17 @@ export class Nord {
    *
    * @param symbol - Market symbol
    * @returns Trade subscription
+   * @throws {NordError} If symbol is invalid
    */
   public subscribeTrades(symbol: string): TradeSubscription {
+    if (!symbol || typeof symbol !== "string") {
+      throw new NordError("Invalid market symbol");
+    }
+
     const subscription = new EventEmitter() as TradeSubscription;
+    const wsClient = this.createWebSocketClient({
+      trades: [symbol],
+    });
 
     const handleTrade = (update: {
       symbol: string;
@@ -481,17 +426,47 @@ export class Nord {
       subscription.emit("message", update);
     };
 
-    // Initialize trades websocket if it doesn't exist
-    if (!this.tradesWs) {
-      this.initializeWebSockets();
+    wsClient.on("trades", handleTrade);
+
+    subscription.close = () => {
+      wsClient.unsubscribe([`trades@${symbol}`]);
+      wsClient.removeListener("trades", handleTrade);
+      subscription.removeAllListeners();
+    };
+
+    return subscription;
+  }
+
+  /**
+   * Subscribe to account updates
+   *
+   * @param accountId - Account ID to subscribe to
+   * @returns User subscription
+   * @throws {NordError} If accountId is invalid
+   */
+  public subscribeAccount(accountId: number): UserSubscription {
+    if (isNaN(accountId) || accountId <= 0) {
+      throw new NordError("Invalid account ID");
     }
 
-    this.tradesWs!.on("trade", handleTrade);
-    this.tradesWs!.subscribe([`trades@${symbol}`]);
+    const subscription = new EventEmitter() as UserSubscription;
+    const wsClient = this.createWebSocketClient({
+      accounts: [accountId],
+    });
+
+    const handleAccountUpdate = (update: any) => {
+      if (update.account_id !== accountId) {
+        return;
+      }
+
+      subscription.emit("message", update);
+    };
+
+    wsClient.on("account", handleAccountUpdate);
 
     subscription.close = () => {
-      this.tradesWs!.unsubscribe([`trades@${symbol}`]);
-      this.tradesWs!.removeListener("trade", handleTrade);
+      wsClient.unsubscribe([`account@${accountId}`]);
+      wsClient.removeListener("account", handleAccountUpdate);
       subscription.removeAllListeners();
     };
 
@@ -547,11 +522,6 @@ export class Nord {
       query = { market_id: marketId };
     }
 
-    // Ensure market_id is provided
-    if (query.market_id === undefined) {
-      throw new NordError("market_id is required for orderbook query");
-    }
-
     return market.getOrderbook(this.webServerUrl, query);
   }
 

package/src/nord/client/NordUser.ts

@@ -111,17 +111,6 @@ export interface TransferParams {
   toAccountId: number;
 }
 
-/**
- * Parameters for creating a new account
- */
-export interface CreateAccountParams {
-  /** Token ID for initial funding */
-  tokenId: number;
-
-  /** Initial funding amount */
-  amount: Decimal.Value;
-}
-
 /**
  * User class for interacting with the Nord protocol
  */
@@ -892,44 +881,6 @@ export class NordUser {
     }
   }
 
-  /**
-   * Create a new account
-   *
-   * @param params - Account creation parameters
-   * @returns New NordUser instance
-   * @throws {NordError} If the operation fails
-   */
-  async createAccount(params: CreateAccountParams): Promise<NordUser> {
-    try {
-      this.checkSessionValidity();
-      // Create a new keypair for the account
-      const keypair = Keypair.generate();
-
-      // Create a new NordUser
-      const newUser = NordUser.fromPrivateKey(
-        this.nord,
-        keypair.secretKey,
-        this.connection,
-      );
-
-      // Transfer initial funds
-      await this.transferToAccount({
-        to: newUser,
-        tokenId: params.tokenId,
-        amount: params.amount,
-        fromAccountId: optExpect(this.accountIds?.[0], "No account ID"),
-        toAccountId: optExpect(
-          newUser.accountIds?.[0],
-          "No account ID for new user",
-        ),
-      });
-
-      return newUser;
-    } catch (error) {
-      throw new NordError("Failed to create account", { cause: error });
-    }
-  }
-
   /**
    * Helper function to retry a promise with exponential backoff
    *

package/src/types.ts

@@ -17,6 +17,18 @@ export enum PeakTpsPeriodUnit {
   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
  */
@@ -29,12 +41,25 @@ 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;
@@ -411,16 +436,16 @@ export interface ActionNonceResponse {
 export 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[]; // Array of streams to subscribe/unsubscribe (e.g. ["trades@BTCUSDC", "deltas@BTCUSDC"])
 }
 
@@ -428,7 +453,7 @@ export interface WebSocketSubscription {
  * WebSocket trade update message
  */
 export interface WebSocketTradeUpdate {
-  type: WebSocketMessageType.TradeUpdate;
+  e: WebSocketMessageType.TradeUpdate;
   symbol: string;
   trades: Trade[];
   timestamp: number;
@@ -438,7 +463,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;
@@ -450,9 +475,9 @@ 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;
 }
@@ -461,4 +486,4 @@ export type WebSocketMessage =
   | WebSocketSubscription
   | WebSocketTradeUpdate
   | WebSocketDeltaUpdate
-  | WebSocketUserUpdate;
+  | WebSocketAccountUpdate;

package/src/websocket/NordWebSocketClient.ts

@@ -6,7 +6,7 @@ import {
   WebSocketSubscription,
   WebSocketTradeUpdate,
   WebSocketDeltaUpdate,
-  WebSocketUserUpdate,
+  WebSocketAccountUpdate,
 } from "../types";
 import { NordWebSocketClientEvents } from "./events";
 
@@ -27,7 +27,7 @@ type BrowserWebSocket = {
 
 type WebSocketInstance = WebSocket | BrowserWebSocket;
 
-const VALID_STREAM_TYPES = ["trades", "deltas", "user"];
+const VALID_STREAM_TYPES = ["trades", "delta", "account"];
 
 // Constants for WebSocket readyState
 const WS_OPEN = 1;
@@ -36,9 +36,6 @@ 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
@@ -104,9 +101,9 @@ export class NordWebSocketClient
       );
     }
 
-    if (type === "user" && !/^\d+$/.test(params)) {
+    if (type === "account" && !/^\d+$/.test(params)) {
       throw new Error(
-        `Invalid user ID in stream: ${params}. Expected numeric ID`,
+        `Invalid account ID in stream: ${params}. Expected numeric ID`,
       );
     }
   }
@@ -304,7 +301,7 @@ export class NordWebSocketClient
     }
 
     const message: WebSocketSubscription = {
-      type: WebSocketMessageType.Subscribe,
+      e: WebSocketMessageType.Subscribe,
       streams,
     };
 
@@ -351,7 +348,7 @@ export class NordWebSocketClient
     }
 
     const message: WebSocketSubscription = {
-      type: WebSocketMessageType.Unsubscribe,
+      e: WebSocketMessageType.Unsubscribe,
       streams,
     };
 
@@ -399,18 +396,18 @@ export class NordWebSocketClient
    * @param message WebSocket message
    */
   private handleMessage(message: WebSocketMessage): void {
-    switch (message.type) {
+    switch (message.e) {
       case WebSocketMessageType.TradeUpdate:
-        this.emit("trade", message as WebSocketTradeUpdate);
+        this.emit("trades", message as WebSocketTradeUpdate);
         break;
       case WebSocketMessageType.DeltaUpdate:
         this.emit("delta", message as WebSocketDeltaUpdate);
         break;
-      case WebSocketMessageType.UserUpdate:
-        this.emit("user", message as WebSocketUserUpdate);
+      case WebSocketMessageType.AccountUpdate:
+        this.emit("account", message as WebSocketAccountUpdate);
         break;
       default:
-        this.emit("error", new Error(`Unknown message type: ${message.type}`));
+        this.emit("error", new Error(`Unknown message type: ${message.e}`));
     }
   }
 

package/src/websocket/events.ts

@@ -1,7 +1,7 @@
 import {
   WebSocketTradeUpdate,
   WebSocketDeltaUpdate,
-  WebSocketUserUpdate,
+  WebSocketAccountUpdate,
 } from "../types";
 
 /**
@@ -13,7 +13,7 @@ export interface NordWebSocketEvents {
   error: (error: Error) => void;
   trade: (update: WebSocketTradeUpdate) => void;
   delta: (update: WebSocketDeltaUpdate) => void;
-  user: (update: WebSocketUserUpdate) => void;
+  account: (update: WebSocketAccountUpdate) => void;
 }
 
 /**