@n1xyz/nord-ts 0.0.12 → 0.0.15

package/src/nord/client/Nord.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "events";
+import { Connection, PublicKey } from "@solana/web3.js";
 import {
   Account,
   ActionQuery,
@@ -14,11 +15,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 +37,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
  */
@@ -42,8 +56,11 @@ export class Nord {
   /** Base URL for the Nord web server */
   public readonly webServerUrl: string;
 
-  /** Solana program ID */
-  public readonly solanaProgramId: string;
+  /** Bridge verification key */
+  public readonly bridgeVk: string;
+
+  /** Optional Solana program ID (will be derived from bridgeVk) */
+  private _solanaProgramId!: string;
 
   /** Solana RPC URL */
   public readonly solanaUrl: string;
@@ -57,113 +74,92 @@ 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
    *
    * @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 = true,
-    tradesSubscriptions,
-    deltasSubscriptions,
-  }: NordConfig) {
-    if (!webServerUrl) {
+  constructor(config: NordConfig) {
+    if (!config.webServerUrl) {
       throw new NordError("webServerUrl is required");
     }
 
-    if (!solanaProgramId) {
-      throw new NordError("solanaProgramId is required");
+    if (!config.bridgeVk) {
+      throw new NordError("bridgeVk is required");
     }
 
-    if (!solanaUrl) {
+    if (!config.solanaUrl) {
       throw new NordError("solanaUrl is required");
     }
 
-    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();
-    }
+    this.webServerUrl = config.webServerUrl;
+    this.bridgeVk = config.bridgeVk;
+    this.solanaUrl = config.solanaUrl;
   }
 
   /**
-   * 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);
   }
 
   /**
@@ -212,20 +208,49 @@ export 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
    */
   public static async initNord(nordConfig: NordConfig): Promise<Nord> {
     const nord = new Nord(nordConfig);
-    await nord.fetchNordInfo();
+    await nord.init();
     return nord;
   }
 
+  /**
+   * Initialize the Nord client by deriving program ID and fetching info
+   * @private
+   */
+  private async init(): Promise<void> {
+    const connection = new Connection(this.solanaUrl);
+    const bridgeVkPubkey = new PublicKey(this.bridgeVk);
+
+    const bridgeAccount = await connection.getAccountInfo(bridgeVkPubkey);
+    if (!bridgeAccount) {
+      throw new NordError(`Bridge account ${this.bridgeVk} not found`);
+    }
+
+    this._solanaProgramId = bridgeAccount.owner.toString();
+    await this.fetchNordInfo();
+  }
+
+  /**
+   * Get the Solana program ID derived from bridge VK
+   *
+   * @returns Program ID string
+   * @throws {NordError} If program ID hasn't been initialized
+   */
+  public getSolanaProgramId(): string {
+    if (!this._solanaProgramId) {
+      throw new NordError(
+        "Solana program ID not initialized. Have you called Nord.initNord()?",
+      );
+    }
+    return this._solanaProgramId;
+  }
+
   /**
    * Get market statistics
    *
@@ -268,7 +293,7 @@ export class Nord {
   async getLastActionId(): Promise<number> {
     return queries.getLastActionId(this.webServerUrl);
   }
-  
+
   /**
    * Fetch aggregate metrics from the Nord API
    *
@@ -364,68 +389,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 +418,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 +434,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 +462,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 +558,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
  */
@@ -311,7 +300,7 @@ export class NordUser {
     if (
       !this.getSolanaPublicKey() ||
       !this.connection ||
-      !this.nord.solanaProgramId
+      !this.nord.getSolanaProgramId()
     ) {
       throw new NordError(
         "Solana public key, connection, and program ID are required to initialize bridge client",
@@ -342,9 +331,10 @@ export class NordUser {
     this.bridgeClient = new SolanaBridgeClient(
       {
         rpcUrl: this.connection.rpcEndpoint,
-        programId: this.nord.solanaProgramId,
+        programId: this.nord.getSolanaProgramId(),
         commitment: "confirmed",
         tokenInfos: this.splTokenInfos,
+        bridgeVk: this.nord.bridgeVk,
       },
       wallet,
     );
@@ -473,16 +463,6 @@ export class NordUser {
       const mint = new PublicKey(tokenInfo.mint);
       // Get the user's token account
       const fromAccount = await this.getAssociatedTokenAccount(mint);
-
-      // Get the bridge's token account
-      const [authority] = await this.bridgeClient.findAuthorityPda();
-      const toAccount = await getAssociatedTokenAddress(
-        mint,
-        authority,
-        true,
-        TOKEN_2022_PROGRAM_ID,
-      );
-
       // Convert amount to BN with proper decimals
       const amountBN = utilsToBN(amount, tokenInfo.precision);
 
@@ -491,7 +471,6 @@ export class NordUser {
         amount: amountBN,
         mint,
         fromAccount,
-        toAccount,
       });
     } catch (error) {
       throw new NordError(
@@ -599,23 +578,23 @@ export class NordUser {
    * @throws {NordError} If the operation fails
    */
   async fetchInfo(): Promise<void> {
-    interface FetchOrder {
+    type OpenOrder = {
       orderId: number;
-      size: number;
-      price: number;
       marketId: number;
       side: "ask" | "bid";
-      originalOrderSize?: number;
+      size: number;
+      price: number;
+      originalOrderSize: number;
       clientOrderId?: number | null;
-    }
+    };
 
-    interface Balance {
+    type Balance = {
       tokenId: number;
       token: string;
       amount: number;
-    }
+    };
 
-    interface Position {
+    type Position = {
       marketId: number;
       openOrders: number;
       perp?: {
@@ -627,9 +606,9 @@ export class NordUser {
         isLong: boolean;
       };
       actionId: number;
-    }
+    };
 
-    interface Margins {
+    type Margins = {
       omf: number;
       mf: number;
       imf: number;
@@ -638,32 +617,31 @@ export class NordUser {
       pon: number;
       pn: number;
       bankruptcy: boolean;
-    }
+    };
 
-    interface Account {
+    type Account = {
       updateId: number;
-      orders: FetchOrder[];
+      orders: OpenOrder[];
       positions: Position[];
       balances: Balance[];
       margins: Margins;
-      actionNonce?: number | null;
-      accountId: number;
-    }
+    };
 
     if (this.accountIds !== undefined) {
-      const accountsData = await Promise.all(
-        this.accountIds.map(async (accountId) => {
-          const response = await checkedFetch(
-            `${this.nord.webServerUrl}/account?account_id=${accountId}`,
-          );
-          const accountData = (await response.json()) as Account;
-          // Ensure we have the correct accountId
-          return {
-            ...accountData,
-            accountId,
-          };
-        }),
-      );
+      const accountsData: (Account & { accountId: number })[] =
+        await Promise.all(
+          this.accountIds.map(async (accountId) => {
+            const response = await checkedFetch(
+              `${this.nord.webServerUrl}/account/${accountId}`,
+            );
+            const accountData = (await response.json()) as Account;
+            // Ensure we have the correct accountId
+            return {
+              ...accountData,
+              accountId,
+            };
+          }),
+        );
 
       for (const accountData of accountsData) {
         // Process balances
@@ -678,13 +656,7 @@ export class NordUser {
 
         // Process orders
         this.orders[accountData.accountId] = accountData.orders.map(
-          (order: {
-            orderId: number;
-            side: string;
-            size: number;
-            price: number;
-            marketId: number;
-          }) => {
+          (order: OpenOrder) => {
             return {
               orderId: order.orderId,
               isLong: order.side === "bid",
@@ -892,44 +864,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
    *