@n1xyz/nord-ts 0.0.18-8121ed05.0 → 0.0.19

package/src/nord/client/Nord.ts

@@ -1,35 +1,32 @@
 import { EventEmitter } from "events";
+import { PublicKey, Connection } from "@solana/web3.js";
+import createClient, { Client, FetchOptions } from "openapi-fetch";
 import {
+  Info,
   Account,
-  ActionQuery,
   ActionResponse,
-  ActionsResponse,
   AggregateMetrics,
-  Info,
   Market,
-  MarketsStatsResponse,
   NordConfig,
   OrderbookQuery,
   OrderbookResponse,
   PeakTpsPeriodUnit,
-  RollmanActionResponse,
-  RollmanActionsResponse,
   SubscriptionPattern,
   Token,
-  TradesQuery,
   TradesResponse,
-  UserAccountIdsQuery,
-  UserAccountIdsResponse,
+  User,
+  MarketStats,
 } from "../../types";
 import { ProtonClient } from "@n1xyz/proton";
+import * as proto from "../../gen/nord";
+// import { base64 } from "@scure/base";
 import { NordWebSocketClient } from "../../websocket/index";
 import * as core from "../api/core";
-import * as market from "../api/market";
 import * as metrics from "../api/metrics";
-import * as queries from "../api/queries";
+import * as utils from "../../utils";
 import { OrderbookSubscription, TradeSubscription } from "../models/Subscriber";
 import { NordError } from "../utils/NordError";
-import { PublicKey, Connection } from "@solana/web3.js";
+import type { paths } from "../../gen/openapi.ts";
 
 /**
  * User subscription interface
@@ -72,9 +69,12 @@ export class Nord {
   /** Map of symbol to market_id */
   private symbolToMarketId: Map<string, number> = new Map();
 
-  /** Proton client for bridge and indexd operations */
+  /** Proton client for bridge and hansel operations */
   public protonClient: ProtonClient;
 
+  /** HTTP client for Nord operations */
+  private httpClient: Client<paths>;
+
   /**
    * Create a new Nord client
    *
@@ -99,6 +99,7 @@ export class Nord {
     this.bridgeVk = bridgeVk;
     this.solanaUrl = solanaUrl;
     this.protonClient = protonClient;
+    this.httpClient = createClient<paths>({ baseUrl: webServerUrl });
   }
 
   /**
@@ -162,6 +163,22 @@ export class Nord {
     return core.initWebSocketClient(this.webServerUrl, subscriptions);
   }
 
+  private async GET<P extends keyof paths & string>(
+    path: P,
+    options: FetchOptions<paths[P]["get"]>,
+  ) {
+    const r = await this.httpClient.GET(path, options);
+    if (r.error) {
+      throw new NordError(`failed to GET ${path}`, { cause: r.error });
+    }
+    if (r.data === undefined) {
+      // this should never happen, but the type checker seems unhappy.
+      // if we catch this we'll need to debug accordingly.
+      throw new NordError("internal assertion violation", { cause: r });
+    }
+    return r.data;
+  }
+
   /**
    * Get the current timestamp from the Nord server
    *
@@ -169,7 +186,7 @@ export class Nord {
    * @throws {NordError} If the request fails
    */
   async getTimestamp(): Promise<bigint> {
-    return core.getTimestamp(this.webServerUrl);
+    return BigInt(await this.GET("/timestamp", {}));
   }
 
   /**
@@ -179,7 +196,7 @@ export class Nord {
    * @throws {NordError} If the request fails
    */
   async getActionNonce(): Promise<number> {
-    return core.getLastEventNonce(this.webServerUrl);
+    return await this.GET("/event/last-acked-nonce", {});
   }
 
   /**
@@ -189,7 +206,7 @@ export class Nord {
    */
   async fetchNordInfo(): Promise<void> {
     try {
-      const info = await core.getInfo(this.webServerUrl);
+      const info = await this.GET("/info", {});
       this.markets = info.markets;
       this.tokens = info.tokens;
 
@@ -246,16 +263,6 @@ export class Nord {
     await this.fetchNordInfo();
   }
 
-  /**
-   * Get market statistics
-   *
-   * @returns Market statistics response
-   * @throws {NordError} If the request fails
-   */
-  public async marketsStats(): Promise<MarketsStatsResponse> {
-    return market.marketsStats(this.webServerUrl);
-  }
-
   /**
    * Query a specific action
    *
@@ -263,8 +270,19 @@ export class Nord {
    * @returns Action response
    * @throws {NordError} If the request fails
    */
-  async queryAction(query: ActionQuery): Promise<ActionResponse> {
-    return queries.queryAction(this.webServerUrl, query);
+  async queryAction({
+    action_id,
+  }: {
+    action_id: number;
+  }): Promise<ActionResponse | null> {
+    return (
+      (
+        await this.queryRecentActions({
+          from: action_id,
+          to: action_id,
+        })
+      )[0] ?? null
+    );
   }
 
   /**
@@ -275,8 +293,23 @@ export class Nord {
    * @returns Actions response
    * @throws {NordError} If the request fails
    */
-  async queryRecentActions(from: number, to: number): Promise<ActionsResponse> {
-    return queries.queryRecentActions(this.webServerUrl, from, to);
+  async queryRecentActions(query: {
+    from: number;
+    to: number;
+  }): Promise<ActionResponse[]> {
+    const xs = await this.GET("/action", {
+      params: {
+        query,
+      },
+    });
+    return xs.map((x) => ({
+      actionId: x.actionId,
+      action: utils.decodeLengthDelimited(
+        Buffer.from(x.payload, "base64"),
+        proto.Action,
+      ),
+      physicalExecTime: new Date(x.physicalTime * 1000),
+    }));
   }
 
   /**
@@ -286,7 +319,7 @@ export class Nord {
    * @throws {NordError} If the request fails
    */
   async getLastActionId(): Promise<number> {
-    return queries.getLastActionId(this.webServerUrl);
+    return await this.GET("/action/last-executed-id", {});
   }
 
   /**
@@ -351,28 +384,6 @@ export class Nord {
     return metrics.getTotalTransactions(this.webServerUrl);
   }
 
-  /**
-   * Query an action from Rollman
-   *
-   * @param query - Action query parameters
-   * @returns Rollman action response
-   * @throws {NordError} If the request fails
-   */
-  async actionQueryRollman(query: ActionQuery): Promise<RollmanActionResponse> {
-    return queries.actionQueryRollman(this.webServerUrl, query);
-  }
-
-  /**
-   * Query actions from Rollman
-   *
-   * @param last_n - Number of recent actions to query
-   * @returns Rollman actions response
-   * @throws {NordError} If the request fails
-   */
-  async actionsQueryRollman(last_n: number): Promise<RollmanActionsResponse> {
-    return queries.actionsQueryRollman(this.webServerUrl, last_n);
-  }
-
   /**
    * Query Prometheus metrics
    *
@@ -511,8 +522,38 @@ export class Nord {
    * @returns Trades response
    * @throws {NordError} If the request fails
    */
-  public async getTrades(query: TradesQuery): Promise<TradesResponse> {
-    return market.getTrades(this.webServerUrl, query);
+  public async getTrades(
+    query: Readonly<{
+      marketId?: number;
+      takerId?: number;
+      makerId?: number;
+      takerSide?: "bid" | "ask";
+      pageSize?: number;
+      sinceRcf3339?: string;
+      untilRfc3339?: string;
+      pageId?: string;
+    }>,
+  ): Promise<TradesResponse> {
+    if (query.sinceRcf3339 && !utils.isRfc3339(query.sinceRcf3339)) {
+      throw new NordError(`Invalid RFC3339 timestamp: ${query.sinceRcf3339}`);
+    }
+    if (query.untilRfc3339 && !utils.isRfc3339(query.untilRfc3339)) {
+      throw new NordError(`Invalid RFC3339 timestamp: ${query.untilRfc3339}`);
+    }
+    return await this.GET("/trades", {
+      params: {
+        query: {
+          takerId: query.takerId,
+          makerId: query.makerId,
+          marketId: query.marketId,
+          pageSize: query.pageSize,
+          takerSide: query.takerSide,
+          since: query.sinceRcf3339,
+          until: query.untilRfc3339,
+          startInclusive: query.pageId,
+        },
+      },
+    });
   }
 
   /**
@@ -522,10 +563,18 @@ export class Nord {
    * @returns User account IDs response
    * @throws {NordError} If the request fails
    */
-  public async getUserAccountIds(
-    query: UserAccountIdsQuery,
-  ): Promise<UserAccountIdsResponse> {
-    return market.getUserAccountIds(this.webServerUrl, query);
+  public async getUser(query: {
+    pubkey: string | PublicKey;
+  }): Promise<User | null> {
+    const r = await this.httpClient.GET("/user/{pubkey}", {
+      params: {
+        path: { pubkey: query.pubkey.toString() },
+      },
+    });
+    if (r.response.status === 404) {
+      return null;
+    }
+    return r.data!;
   }
 
   /**
@@ -539,21 +588,31 @@ export class Nord {
    */
   public async getOrderbook(query: OrderbookQuery): Promise<OrderbookResponse> {
     // If only symbol is provided, convert it to market_id
+    let marketId: number;
     if (query.symbol && query.market_id === undefined) {
       // If the map is empty, try to fetch market information first
       if (this.symbolToMarketId.size === 0) {
         await this.fetchNordInfo();
       }
 
-      const marketId = this.symbolToMarketId.get(query.symbol);
-      if (marketId === undefined) {
+      const id = this.symbolToMarketId.get(query.symbol);
+      if (id === undefined) {
         throw new NordError(`Unknown market symbol: ${query.symbol}`);
       }
-
-      query = { market_id: marketId };
+      marketId = id;
+    } else if (query.market_id !== undefined) {
+      marketId = query.market_id;
+    } else {
+      throw new NordError(
+        "Either symbol or market_id must be provided for orderbook query",
+      );
     }
 
-    return market.getOrderbook(this.webServerUrl, query);
+    return await this.GET("/market/{market_id}/orderbook", {
+      params: {
+        path: { market_id: marketId },
+      },
+    });
   }
 
   /**
@@ -563,7 +622,7 @@ export class Nord {
    * @throws {NordError} If the request fails
    */
   public async getInfo(): Promise<Info> {
-    return core.getInfo(this.webServerUrl);
+    return await this.GET("/info", {});
   }
 
   /**
@@ -574,17 +633,28 @@ export class Nord {
    * @throws {NordError} If the request fails
    */
   public async getAccount(accountId: number): Promise<Account> {
-    return core.getAccount(this.webServerUrl, accountId);
+    return await this.GET("/account/{account_id}", {
+      params: {
+        path: { account_id: accountId },
+      },
+    });
   }
 
   /**
    * Get market statistics (alias for marketsStats for backward compatibility)
    *
-   * @deprecated Use marketsStats instead
    * @returns Market statistics response
    */
-  public async getMarketStats(): Promise<MarketsStatsResponse> {
-    return this.marketsStats();
+  public async getMarketStats({
+    marketId,
+  }: {
+    marketId: number;
+  }): Promise<MarketStats> {
+    return await this.GET("/market/{market_id}/stats", {
+      params: {
+        path: { market_id: marketId },
+      },
+    });
   }
 
   /**
@@ -592,13 +662,9 @@ export class Nord {
    *
    * @param address - The public key address to check
    * @returns True if the account exists, false otherwise
+   * @deprecated use getUser instead
    */
-  public async accountExists(address: string): Promise<boolean> {
-    try {
-      await market.getUserAccountIds(this.webServerUrl, { pubkey: address });
-      return true;
-    } catch {
-      return false;
-    }
+  public async accountExists(pubkey: string | PublicKey): Promise<boolean> {
+    return !!(await this.getUser({ pubkey }));
   }
 }

package/src/nord/client/NordUser.ts

@@ -9,8 +9,9 @@ import Decimal from "decimal.js";
 import * as ed from "@noble/ed25519";
 import { sha512 } from "@noble/hashes/sha512";
 ed.etc.sha512Sync = sha512;
-import { SPLTokenInfo, DepositSplParams, floatToBn } from "@n1xyz/proton";
-import { FillMode, Order, Side } from "../../types";
+import { floatToScaledBigIntLossy } from "@n1xyz/proton";
+import { FillMode, Order, Side, SPLTokenInfo } from "../../types";
+import * as proto from "../../gen/nord";
 import {
   BigIntValue,
   checkedFetch,
@@ -26,6 +27,8 @@ import {
   revokeSession,
   transfer,
   withdraw,
+  atomic as atomicAction,
+  AtomicSubaction as ApiAtomicSubaction,
 } from "../api/actions";
 import { NordError } from "../utils/NordError";
 import { Nord } from "./Nord";
@@ -47,7 +50,7 @@ export interface NordUserParams {
   sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
 
   /** Function to sign transactions with the user's wallet (optional) */
-  transactionSignFn: (transaction: any) => Promise<any>;
+  transactionSignFn: <T extends Transaction>(tx: T) => Promise<T>;
 
   /** Solana connection (optional) */
   connection?: Connection;
@@ -111,6 +114,41 @@ export interface TransferParams {
   toAccountId: number;
 }
 
+/**
+ * Parameters for individual atomic subactions (user-friendly version)
+ */
+export interface UserAtomicSubaction {
+  /** The type of action to perform. */
+  kind: "place" | "cancel";
+
+  /** The market ID to place the order in. */
+  marketId?: number;
+
+  /** The order ID to cancel. */
+  orderId?: BigIntValue;
+
+  /** Order side (bid or ask) */
+  side?: Side;
+
+  /** Fill mode (limit, market, etc.) */
+  fillMode?: FillMode;
+
+  /** Whether the order is reduce-only. */
+  isReduceOnly?: boolean;
+
+  /** The size of the order. */
+  size?: Decimal.Value;
+
+  /** Order price */
+  price?: Decimal.Value;
+
+  /** Quote size (for market orders) */
+  quoteSize?: Decimal.Value;
+
+  /** The client order ID of the order. */
+  clientOrderId?: BigIntValue;
+}
+
 /**
  * User class for interacting with the Nord protocol
  */
@@ -130,16 +168,15 @@ export class NordUser {
   public readonly sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
 
   /** Function to sign transactions with the user's wallet */
-  public readonly transactionSignFn: (transaction: any) => Promise<any>;
+  public readonly transactionSignFn: <T extends Transaction>(
+    tx: T,
+  ) => Promise<T>;
 
   /** User balances by token symbol */
   public balances: {
     [key: string]: { accountId: number; balance: number; symbol: string }[];
   } = {};
 
-  /** User orders by market symbol */
-  public orders: { [key: string]: Order[] } = {};
-
   /** User positions by account ID */
   public positions: {
     [key: string]: {
@@ -275,7 +312,6 @@ export class NordUser {
 
     // Copy other properties
     cloned.balances = { ...this.balances };
-    cloned.orders = { ...this.orders };
     cloned.positions = { ...this.positions };
     cloned.margins = { ...this.margins };
     cloned.accountIds = this.accountIds ? [...this.accountIds] : undefined;
@@ -416,10 +452,37 @@ export class NordUser {
    *
    * @param amount - Amount to deposit
    * @param tokenId - Token ID
+   * @param recipient - Recipient address; defaults to the user's address
    * @returns Transaction signature
+   * @deprecated Use deposit instead
    * @throws {NordError} If required parameters are missing or operation fails
    */
-  async depositSpl(amount: number, tokenId: number): Promise<string> {
+  async depositSpl(
+    amount: number,
+    tokenId: number,
+    recipient?: PublicKey,
+  ): Promise<string> {
+    return this.deposit({ amount, tokenId, recipient });
+  }
+
+  /**
+   * Deposit SPL tokens to the bridge
+   *
+   * @param amount - Amount to deposit
+   * @param tokenId - Token ID
+   * @param recipient - Recipient address; defaults to the user's address
+   * @returns Transaction signature
+   * @throws {NordError} If required parameters are missing or operation fails
+   */
+  async deposit({
+    amount,
+    tokenId,
+    recipient,
+  }: Readonly<{
+    amount: number;
+    tokenId: number;
+    recipient?: PublicKey;
+  }>): Promise<string> {
     try {
       // Find the token info
       const tokenInfo = this.splTokenInfos.find((t) => t.tokenId === tokenId);
@@ -428,35 +491,28 @@ export class NordUser {
       }
 
       const mint = new PublicKey(tokenInfo.mint);
-      // Get the user's token account
       const fromAccount = await this.getAssociatedTokenAccount(mint);
+      const payer = this.getSolanaPublicKey();
 
-      // Convert amount to BN with proper decimals
-      const amountBN = floatToBn(amount, tokenInfo.precision);
-
-      // Create deposit parameters
-      const depositParams: DepositSplParams = {
-        amount: amountBN,
+      const { ix, extraSigner } = await this.nord.protonClient.buildDepositIx({
+        payer,
+        recipient: recipient ?? payer,
+        quantAmount: floatToScaledBigIntLossy(amount, tokenInfo.precision),
         mint,
-        fromAccount,
-      };
-
-      // Build the deposit transaction using proton client
-      const depositTx = await this.nord.protonClient.buildDepositTx(
-        depositParams,
-        this.getSolanaPublicKey(),
-        this.connection,
-      );
+        sourceTokenAccount: fromAccount,
+      });
 
-      const { blockhash } = await this.connection.getLatestBlockhash();
+      const { blockhash } =
+        await this.connection.getLatestBlockhash("confirmed");
+      const tx = new Transaction();
 
-      depositTx.recentBlockhash = blockhash;
-      depositTx.feePayer = this.getSolanaPublicKey();
+      tx.add(ix);
+      tx.recentBlockhash = blockhash;
+      tx.feePayer = payer;
 
-      const signedTx = await this.transactionSignFn(depositTx);
+      const signedTx = await this.transactionSignFn(tx);
+      signedTx.partialSign(extraSigner);
 
-      // TODO: should use `VersionedTransaction` and remove any for `transactionSignFn`,
-      // this is incredibly annoying to debug and i could've saved 30 mins.
       const signature = await this.connection.sendRawTransaction(
         signedTx.serialize(),
       );
@@ -490,10 +546,14 @@ export class NordUser {
         throw new NordError("Public key is required to update account ID");
       }
 
-      const resp = await this.nord.getUserAccountIds({
+      const resp = await this.nord.getUser({
         pubkey: this.publicKey.toBase58(),
       });
 
+      if (!resp) {
+        throw new NordError(`User ${this.publicKey.toBase58()} not found`);
+      }
+
       this.accountIds = resp.accountIds;
     } catch (error) {
       throw new NordError("Failed to update account ID", { cause: error });
@@ -582,19 +642,6 @@ export class NordUser {
           });
         }
 
-        // Process orders
-        this.orders[accountData.accountId] = accountData.orders.map(
-          (order: OpenOrder) => {
-            return {
-              orderId: order.orderId,
-              isLong: order.side === "bid",
-              size: order.size,
-              price: order.price,
-              marketId: order.marketId,
-            };
-          },
-        );
-
         // Process positions
         this.positions[accountData.accountId] = accountData.positions;
 
@@ -610,7 +657,6 @@ export class NordUser {
    * @throws {NordError} If the operation fails
    */
   async refreshSession(): Promise<void> {
-    console.log(this.publicKey);
     this.sessionId = await createSession(
       this.nord.webServerUrl,
       this.walletSignFn,
@@ -666,10 +712,13 @@ export class NordUser {
    * @param amount - Amount to withdraw
    * @throws {NordError} If the operation fails
    */
-  async withdraw(
-    tokenId: number,
-    amount: number,
-  ): Promise<{ actionId: bigint }> {
+  async withdraw({
+    amount,
+    tokenId,
+  }: Readonly<{
+    tokenId: number;
+    amount: number;
+  }>): Promise<{ actionId: bigint }> {
     try {
       this.checkSessionValidity();
       const { actionId } = await withdraw(
@@ -796,6 +845,78 @@ export class NordUser {
     }
   }
 
+  /**
+   * Execute up to four place/cancel operations atomically.
+   * Per Market:
+   * 1. cancels can only be in the start (one cannot predict future order ids)
+   * 2. intermediate trades can trade only
+   * 3. placements go last
+   *
+   * Across Markets, order action can be any
+   *
+   * @param userActions array of user-friendly subactions
+   * @param providedAccountId optional account performing the action (defaults to first account)
+   */
+  async atomic(
+    userActions: UserAtomicSubaction[],
+    providedAccountId?: number,
+  ): Promise<proto.Receipt_AtomicResult> {
+    try {
+      this.checkSessionValidity();
+
+      const accountId =
+        providedAccountId != null ? providedAccountId : this.accountIds?.[0];
+
+      if (accountId == null) {
+        throw new NordError(
+          "Account ID is undefined. Make sure to call updateAccountId() before atomic operations.",
+        );
+      }
+
+      const apiActions: ApiAtomicSubaction[] = userActions.map((act) => {
+        if (act.kind === "place") {
+          const market = findMarket(this.nord.markets, act.marketId!);
+          if (!market) {
+            throw new NordError(`Market ${act.marketId} not found`);
+          }
+          return {
+            kind: "place",
+            marketId: act.marketId,
+            side: act.side,
+            fillMode: act.fillMode,
+            isReduceOnly: act.isReduceOnly,
+            sizeDecimals: market.sizeDecimals,
+            priceDecimals: market.priceDecimals,
+            size: act.size,
+            price: act.price,
+            quoteSizeSize: act.quoteSize, // treated as quote size; we pass only size component
+            quoteSizePrice: undefined,
+            clientOrderId: act.clientOrderId,
+          } as ApiAtomicSubaction;
+        }
+        return {
+          kind: "cancel",
+          orderId: act.orderId,
+        } as ApiAtomicSubaction;
+      });
+
+      const result = await atomicAction(
+        this.nord.webServerUrl,
+        this.sessionSignFn,
+        await this.nord.getTimestamp(),
+        this.getNonce(),
+        {
+          sessionId: optExpect(this.sessionId, "No session"),
+          accountId: accountId,
+          actions: apiActions,
+        },
+      );
+      return result;
+    } catch (error) {
+      throw new NordError("Atomic operation failed", { cause: error });
+    }
+  }
+
   /**
    * Helper function to retry a promise with exponential backoff
    *