@n1xyz/nord-ts 0.0.17 → 0.0.18

package/src/nord/api/actions.ts

@@ -3,15 +3,12 @@ import * as proto from "../../gen/nord";
 import { FillMode, fillModeToProtoFillMode, KeyType, Side } from "../../types";
 import {
   assert,
-  bigIntToProtoU128,
   BigIntValue,
   checkedFetch,
   checkPubKeyLength,
   decodeLengthDelimited,
   encodeLengthDelimited,
-  optMap,
   SESSION_TTL,
-  toScaledU128,
   toScaledU64,
 } from "../../utils";
 
@@ -35,6 +32,7 @@ function makeSendHttp(
   serverUrl: string,
 ): (encoded: Uint8Array) => Promise<Uint8Array> {
   return async (body) => {
+    // TODO: this should be changed to use openapi
     const response = await checkedFetch(`${serverUrl}/action`, {
       method: "POST",
       headers: {
@@ -271,15 +269,17 @@ async function placeOrderImpl(
     // NOTE: if `size` equals 1.0, it will sell whole unit, for example 1.0 BTC
     size?: Decimal.Value;
     price?: Decimal.Value;
-    quoteSize?: Decimal.Value;
+    quoteSizeSize?: Decimal.Value;
+    quoteSizePrice?: Decimal.Value;
     clientOrderId?: BigIntValue;
   },
 ): Promise<bigint | undefined> {
   const price = toScaledU64(params.price ?? 0, params.priceDecimals);
   const size = toScaledU64(params.size ?? 0, params.sizeDecimals);
-  const quoteSize = toScaledU128(
-    params.quoteSize ?? 0,
-    params.priceDecimals + params.sizeDecimals,
+  const quoteSize = toScaledU64(params.quoteSizeSize ?? 0, params.sizeDecimals);
+  const quotePrice = toScaledU64(
+    params.quoteSizePrice ?? 0,
+    params.priceDecimals,
   );
 
   // Compose action object
@@ -297,8 +297,11 @@ async function placeOrderImpl(
         isReduceOnly: params.isReduceOnly,
         price,
         size,
-        quoteSize: bigIntToProtoU128(quoteSize),
-        clientOrderId: optMap(params.clientOrderId, (x) => BigInt(x)),
+        quoteSize: { size: quoteSize, price: quotePrice },
+        clientOrderId:
+          params.clientOrderId === undefined
+            ? undefined
+            : BigInt(params.clientOrderId),
         delegatorAccountId: params.liquidateeId,
       },
     },
@@ -478,6 +481,124 @@ export async function transfer(
     params,
   );
 }
+
+export type AtomicSubaction =
+  | {
+      kind: "place";
+      // Market and order parameters – identical semantics to placeOrder()
+      marketId: number;
+      side: Side;
+      fillMode: FillMode;
+      isReduceOnly: boolean;
+      // decimals for scaling
+      sizeDecimals: number;
+      priceDecimals: number;
+      // at least one of the three has to be specified; 0 treated as "not set"
+      size?: Decimal.Value;
+      price?: Decimal.Value;
+      quoteSizeSize?: Decimal.Value;
+      quoteSizePrice?: Decimal.Value;
+      clientOrderId?: BigIntValue;
+    }
+  | {
+      kind: "cancel";
+      orderId: BigIntValue;
+    };
+
+async function atomicImpl(
+  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
+  signFn: (message: Uint8Array) => Promise<Uint8Array>,
+  currentTimestamp: bigint,
+  nonce: number,
+  params: {
+    sessionId: BigIntValue;
+    accountId?: number;
+    actions: AtomicSubaction[];
+  },
+): Promise<proto.Receipt_AtomicResult> {
+  assert(
+    params.actions.length > 0 && params.actions.length <= 4,
+    "Atomic action must contain between 1 and 4 sub-actions",
+  );
+
+  const subactions: proto.AtomicSubactionKind[] = params.actions.map((a) => {
+    if (a.kind === "place") {
+      const price = toScaledU64(a.price ?? 0, a.priceDecimals);
+      const size = toScaledU64(a.size ?? 0, a.sizeDecimals);
+      const quoteSizeSize = toScaledU64(a.quoteSizeSize ?? 0, a.sizeDecimals);
+      const quoteSizePrice = toScaledU64(
+        a.quoteSizePrice ?? 0,
+        a.priceDecimals,
+      );
+      const tradeOrPlace: proto.TradeOrPlace = {
+        marketId: a.marketId,
+        orderType: {
+          side: a.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+          fillMode: fillModeToProtoFillMode(a.fillMode),
+          isReduceOnly: a.isReduceOnly,
+        },
+        limit: {
+          price,
+          size,
+          quoteSize: { size: quoteSizeSize, price: quoteSizePrice },
+        },
+        clientOrderId:
+          a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
+      };
+      return {
+        inner: { $case: "tradeOrPlace", value: tradeOrPlace },
+      } as proto.AtomicSubactionKind;
+    }
+    return {
+      inner: { $case: "cancelOrder", value: { orderId: BigInt(a.orderId) } },
+    } as proto.AtomicSubactionKind;
+  });
+
+  const action: proto.Action = {
+    currentTimestamp,
+    nonce,
+    kind: {
+      $case: "atomic",
+      value: {
+        sessionId: BigInt(params.sessionId),
+        accountId: params.accountId, // optional
+        actions: subactions,
+      },
+    },
+  };
+
+  const resp = await sendAction(
+    sendFn,
+    (m) => sessionSign(signFn, m),
+    action,
+    "execute atomic action",
+  );
+  if (resp.kind?.$case === "atomic") {
+    return resp.kind.value;
+  }
+  throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+}
+
+export async function atomic(
+  serverUrl: string,
+  signFn: (message: Uint8Array) => Promise<Uint8Array>,
+  currentTimestamp: bigint,
+  nonce: number,
+  params: {
+    sessionId: BigIntValue;
+    accountId?: number;
+    actions: AtomicSubaction[];
+  },
+): Promise<proto.Receipt_AtomicResult> {
+  return atomicImpl(
+    makeSendHttp(serverUrl),
+    signFn,
+    currentTimestamp,
+    nonce,
+    params,
+  );
+}
+
 /**
  * For testing purposes
  */
@@ -488,4 +609,5 @@ export const _private = {
   placeOrderImpl,
   cancelOrderImpl,
   transferImpl,
+  atomicImpl,
 };

package/src/nord/api/core.ts

@@ -3,77 +3,6 @@ import { checkedFetch } from "../../utils";
 import { NordWebSocketClient } from "../../websocket/index";
 import { NordError } from "../utils/NordError";
 
-/**
- * Get the current timestamp from the Nord server
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @returns Current timestamp as a bigint
- * @throws {NordError} If the request fails
- */
-export async function getTimestamp(webServerUrl: string): Promise<bigint> {
-  try {
-    const response = await checkedFetch(`${webServerUrl}/timestamp`);
-    return BigInt(await response.json());
-  } catch (error) {
-    throw new NordError("Failed to get timestamp", { cause: error });
-  }
-}
-
-/**
- * Get the next action nonce from the Nord server
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @returns Next action nonce
- * @throws {NordError} If the request fails
- */
-export async function getLastEventNonce(webServerUrl: string): Promise<number> {
-  try {
-    const response = await checkedFetch(
-      `${webServerUrl}/event/last-acked-nonce`,
-    );
-    const data = await response.json();
-    return data.nonce;
-  } catch (error) {
-    throw new NordError("Failed to get action nonce", { cause: error });
-  }
-}
-
-/**
- * Get information about the Nord server
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @returns Information about markets and tokens
- * @throws {NordError} If the request fails
- */
-export async function getInfo(webServerUrl: string): Promise<Info> {
-  try {
-    const response = await checkedFetch(`${webServerUrl}/info`);
-    return await response.json();
-  } catch (error) {
-    throw new NordError("Failed to get info", { cause: error });
-  }
-}
-
-/**
- * Get account information
- *
- * @param webServerUrl - Base URL for the Nord web server
- * @param accountId - Account ID to get information for
- * @returns Account information
- * @throws {NordError} If the request fails
- */
-export async function getAccount(
-  webServerUrl: string,
-  accountId: number,
-): Promise<Account> {
-  try {
-    const response = await checkedFetch(`${webServerUrl}/account/${accountId}`);
-    return await response.json();
-  } catch (error) {
-    throw new NordError(`Failed to get account ${accountId}`, { cause: error });
-  }
-}
-
 /**
  * Initialize a WebSocket client for Nord
  *

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 }));
   }
 }