@n1xyz/nord-ts 0.1.3 → 0.1.5

package/src/gen/openapi.ts

@@ -60,7 +60,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["Info2"];
+                        "application/json": components["schemas"]["MarketsInfo"];
                     };
                 };
             };
@@ -362,6 +362,14 @@ export interface paths {
                         "application/json": number;
                     };
                 };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UserNotFound"];
+                    };
+                };
             };
         };
         put?: never;
@@ -1069,6 +1077,161 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/state/info": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["StateInfo"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/fee/brackets/info": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": [
+                            components["schemas"]["FeeTierId"],
+                            components["schemas"]["FeeTierConfig"]
+                        ][];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/account/{account_id}/fee/tier": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    account_id: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FeeTierId"];
+                    };
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UserNotFound"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/accounts/fee-tiers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description List fee tiers assigned to accounts. */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description fetch results starting with this page; query starts with first entry if page isn't specified */
+                    startInclusive?: number | null;
+                    /** @description Query returns up to 50 trades in one go. */
+                    pageSize?: number | null;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["PageResult_for_uint32_and_AccountFeeTier"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/tv": {
         parameters: {
             query?: never;
@@ -1968,7 +2131,7 @@ export interface components {
         } & {
             [key: string]: unknown;
         };
-        Info2: {
+        MarketsInfo: {
             markets: components["schemas"]["MarketInfo"][];
             tokens: components["schemas"]["TokenInfo"][];
         };
@@ -2042,6 +2205,7 @@ export interface components {
         ActionNotFound: null;
         /** @description Returns fee parts per market per balance change per action per account. Fee is taken from user without return. Please note that some operations need some deposit which will be returned - these are not part of fees. */
         FillRole: "maker" | "taker";
+        UserNotFound: null;
         OrderbookInfo: {
             /** Format: uint64 */
             updateId: number;
@@ -2119,7 +2283,6 @@ export interface components {
             pubkey: string;
             expiry: string;
         };
-        UserNotFound: null;
         PageQueryPart_for_String: {
             /** @description fetch results starting with this page; query starts with first entry if page isn't specified */
             startInclusive?: string | null;
@@ -2476,6 +2639,56 @@ export interface components {
             version?: components["schemas"]["BinaryId"] | null;
         };
         BinaryId: string;
+        StateInfo: {
+            version: components["schemas"]["ExecutableVersion"];
+            state: components["schemas"]["EngineStateHeader"];
+        };
+        EngineStateHeader: {
+            /** Format: uint16 */
+            version: number;
+            /** Format: uint64 */
+            action_id: number;
+            /** Format: uint64 */
+            action_nonce: number;
+            /** Format: uint64 */
+            timestamp: number;
+            paused: boolean;
+        };
+        /** Format: uint32 */
+        FeeTierId: number;
+        FeeTierConfig: {
+            /** Format: uint16 */
+            maker_fee_bps: number;
+            /** Format: uint16 */
+            taker_fee_bps: number;
+        };
+        PageQueryPart_for_uint32: {
+            /**
+             * Format: uint32
+             * @description fetch results starting with this page; query starts with first entry if page isn't specified
+             */
+            startInclusive?: number | null;
+            /**
+             * Format: uint8
+             * @description Query returns up to 50 trades in one go.
+             * @default null
+             */
+            pageSize: number | null;
+        };
+        PageResult_for_uint32_and_AccountFeeTier: {
+            /** @description Set of items for requested by query. */
+            items: components["schemas"]["AccountFeeTier"][];
+            /**
+             * Format: uint32
+             * @description If request contains more data, this is the id is set with which next request should be performed to get next page. If no more data, then it is undefined.
+             */
+            nextStartInclusive?: number | null;
+        };
+        AccountFeeTier: {
+            /** Format: uint32 */
+            accountId: number;
+            feeTier: components["schemas"]["FeeTierId"];
+        };
         /** @description TV config query response https://www.tradingview.com/charting-library-docs/latest/connecting_data/UDF/#data-feed-configuration-data */
         TvConfigResponse: {
             supported_resolutions: components["schemas"]["Resolution"][];

package/src/nord/api/actions.ts

@@ -2,7 +2,6 @@ import Decimal from "decimal.js";
 import * as proto from "../../gen/nord_pb";
 import { paths } from "../../gen/openapi";
 import createClient from "openapi-fetch";
-
 import { create } from "@bufbuild/protobuf";
 import {
   FillMode,
@@ -21,6 +20,32 @@ import {
   toScaledU64,
 } from "../../utils";
 import { sizeDelimitedEncode } from "@bufbuild/protobuf/wire";
+import { NordError } from "../utils/NordError";
+
+type ReceiptKind = NonNullable<proto.Receipt["kind"]>;
+type ExtractReceiptKind<K extends ReceiptKind["case"]> = Extract<
+  ReceiptKind,
+  { case: K }
+>;
+
+export function formatReceiptError(receipt: proto.Receipt): string {
+  if (receipt.kind?.case === "err") {
+    const err = receipt.kind.value;
+    return proto.Error[err] ?? err.toString();
+  }
+  return receipt.kind?.case ?? "unknown";
+}
+
+export function expectReceiptKind<K extends ReceiptKind["case"]>(
+  receipt: proto.Receipt,
+  expected: K,
+  action: string,
+): asserts receipt is proto.Receipt & { kind: ExtractReceiptKind<K> } {
+  if (receipt.kind?.case !== expected) {
+    const label = formatReceiptError(receipt);
+    throw new NordError(`Failed to ${action}: ${label}`);
+  }
+}
 
 async function sessionSign(
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
@@ -39,7 +64,7 @@ async function walletSign(
 }
 
 // Helper to create an action with common fields
-function createAction(
+export function createAction(
   currentTimestamp: bigint,
   nonce: number,
   kind: proto.Action["kind"],
@@ -51,7 +76,7 @@ function createAction(
   });
 }
 
-async function sendAction(
+export async function sendAction(
   serverUrl: string,
   makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>,
   action: proto.Action,
@@ -508,7 +533,6 @@ export async function removeTrigger(
   }
   throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
 }
-
 export type AtomicSubaction =
   | {
       kind: "place";

package/src/nord/client/Nord.ts

@@ -10,17 +10,28 @@ import {
   AccountPnlQuery,
   ActionResponse,
   AggregateMetrics,
-  Info,
+  MarketsInfo,
   Market,
   MarketStats,
   NordConfig,
   OrderbookQuery,
   OrderbookResponse,
+  FeeTierConfig,
   PeakTpsPeriodUnit,
   SubscriptionPattern,
   Token,
   TradesResponse,
   User,
+  AccountTriggerInfo,
+  HistoryTriggerQuery,
+  TriggerHistoryPage,
+  FeeTierId,
+  AccountFeeTierPage,
+  PageResultStringOrderInfo,
+  PageResultStringTrade,
+  OrderInfoFromApi,
+  TokenStats,
+  FillRole,
 } from "../../types";
 import * as utils from "../../utils";
 import { NordWebSocketClient } from "../../websocket/index";
@@ -55,9 +66,6 @@ export class Nord {
   /** Base URL for the Nord web server */
   public readonly webServerUrl: string;
 
-  /** Bridge verification key */
-  public readonly bridgeVk: PublicKey;
-
   /** Solana RPC URL */
   public readonly solanaUrl: string;
 
@@ -70,7 +78,7 @@ export class Nord {
   /** Map of symbol to market_id */
   private symbolToMarketId: Map<string, number> = new Map();
 
-  /** Proton client for bridge and hansel operations */
+  /** Proton client for proton related operations */
   public protonClient: ProtonClient;
 
   /** HTTP client for Nord operations */
@@ -81,23 +89,19 @@ export class Nord {
    *
    * @param config - Configuration options for the Nord client
    * @param config.webServerUrl - Base URL for the Nord web server
-   * @param config.bridgeVk - Bridge verification key
    * @param config.solanaUrl - Solana cluster URL
    * @throws {Error} If required configuration is missing
    */
   private constructor({
-    bridgeVk,
     solanaUrl,
     webServerUrl,
     protonClient,
   }: Readonly<{
-    bridgeVk: PublicKey;
     solanaUrl: string;
     webServerUrl: string;
     protonClient: ProtonClient;
   }>) {
     this.webServerUrl = webServerUrl;
-    this.bridgeVk = bridgeVk;
     this.solanaUrl = solanaUrl;
     this.protonClient = protonClient;
     this.httpClient = createClient<paths>({ baseUrl: webServerUrl });
@@ -226,13 +230,13 @@ export class Nord {
    *
    * @param nordConfig - Configuration options for the Nord client
    * @param nordConfig.webServerUrl - Base URL for the Nord web server
-   * @param nordConfig.bridgeVk - Bridge verification key
+   * @param nordConfig.app - App address
    * @param nordConfig.solanaUrl - Solana cluster URL
    * @returns Initialized Nord client
    * @throws {NordError} If initialization fails
    */
   public static async initNord({
-    bridgeVk: bridgeVk_,
+    app,
     solanaUrl,
     webServerUrl,
   }: Readonly<NordConfig>): Promise<Nord> {
@@ -240,14 +244,12 @@ export class Nord {
     // this is a dogshit api, only here to be compatible with the shitty
     // vibecoded code and not break zero one team's workflow.
     const connection = new Connection(solanaUrl, { commitment: "confirmed" });
-    const bridgeVk = new PublicKey(bridgeVk_);
     const protonClient = await ProtonClient.init({
       protonUrl: webServerUrl,
-      bridgeVk,
+      app: new PublicKey(app),
       solConn: connection,
     });
     const nord = new Nord({
-      bridgeVk,
       protonClient,
       solanaUrl,
       webServerUrl,
@@ -619,10 +621,35 @@ export class Nord {
    * @returns Information about markets and tokens
    * @throws {NordError} If the request fails
    */
-  public async getInfo(): Promise<Info> {
+  public async getInfo(): Promise<MarketsInfo> {
     return await this.GET("/info", {});
   }
 
+  /**
+   * Fetch the current fee tier brackets configured on Nord.
+   *
+   * @returns Array of fee tier identifiers paired with their configuration
+   * @throws {NordError} If the request fails
+   */
+  public async getFeeBrackets(): Promise<Array<[FeeTierId, FeeTierConfig]>> {
+    return await this.GET("/fee/brackets/info", {});
+  }
+
+  /**
+   * Retrieve the fee tier assigned to a specific account.
+   *
+   * @param accountId - Account identifier to query
+   * @returns Fee tier details for the requested account
+   * @throws {NordError} If the request fails
+   */
+  public async getAccountFeeTier(accountId: number): Promise<FeeTierId> {
+    return await this.GET("/account/{account_id}/fee/tier", {
+      params: {
+        path: { account_id: accountId },
+      },
+    });
+  }
+
   /**
    * Get account information
    *
@@ -638,6 +665,76 @@ export class Nord {
     });
   }
 
+  /**
+   * Get the public key associated with an account id.
+   *
+   * @param accountId - Account id to query
+   * @returns Base58-encoded account public key
+   * @throws {NordError} If the request fails
+   */
+  public async getAccountPubkey(accountId: number): Promise<string> {
+    return await this.GET("/account/{account_id}/pubkey", {
+      params: {
+        path: { account_id: accountId },
+      },
+    });
+  }
+
+  /**
+   * Get the withdrawal fee charged for an account.
+   *
+   * @param accountId - Account id to query
+   * @returns Withdrawal fee quoted in quote token units
+   * @throws {NordError} If the request fails
+   */
+  public async getAccountWithdrawalFee(accountId: number): Promise<number> {
+    return await this.GET("/account/{account_id}/fees/withdrawal", {
+      params: {
+        path: { account_id: accountId },
+      },
+    });
+  }
+
+  /**
+   * Get open orders for an account.
+   *
+   * @param accountId - Account id to query
+   * @param query - Optional pagination parameters
+   * @returns Page of orders keyed by client order id
+   * @throws {NordError} If the request fails
+   */
+  public async getAccountOrders(
+    accountId: number,
+    query?: { startInclusive?: string | null; pageSize?: number | null },
+  ): Promise<PageResultStringOrderInfo> {
+    return await this.GET("/account/{account_id}/orders", {
+      params: {
+        path: { account_id: accountId },
+        query: {
+          startInclusive: query?.startInclusive,
+          pageSize: query?.pageSize,
+        },
+      },
+    });
+  }
+
+  /**
+   * List account fee tiers with pagination support.
+   */
+  public async getAccountsFeeTiers(query?: {
+    startInclusive?: number | null;
+    pageSize?: number | null;
+  }): Promise<AccountFeeTierPage> {
+    return await this.GET("/accounts/fee-tiers", {
+      params: {
+        query: {
+          startInclusive: query?.startInclusive ?? undefined,
+          pageSize: query?.pageSize ?? undefined,
+        },
+      },
+    });
+  }
+
   /**
    * Get profit and loss history for an account
    *
@@ -680,6 +777,86 @@ export class Nord {
     });
   }
 
+  /**
+   * Fetch the per-market fee quote for an account.
+   *
+   * @param params - Market id, fee kind, and account id to quote
+   * @returns Fee in quote token units (negative means fee is charged)
+   * @throws {NordError} If the request fails
+   */
+  public async getMarketFee({
+    marketId,
+    feeKind,
+    accountId,
+  }: {
+    marketId: number;
+    feeKind: FillRole;
+    accountId: number;
+  }): Promise<number> {
+    return await this.GET("/market/{market_id}/fees/{fee_kind}/{account_id}", {
+      params: {
+        path: {
+          market_id: marketId,
+          fee_kind: feeKind,
+          account_id: accountId,
+        },
+      },
+    });
+  }
+
+  /**
+   * Fetch token statistics such as index price and oracle metadata.
+   *
+   * @param tokenId - Token identifier
+   * @returns Token stats
+   * @throws {NordError} If the request fails
+   */
+  public async getTokenStats(tokenId: number): Promise<TokenStats> {
+    return await this.GET("/tokens/{token_id}/stats", {
+      params: {
+        path: { token_id: tokenId },
+      },
+    });
+  }
+
+  /**
+   * Get order summary by order id.
+   *
+   * @param orderId - Order identifier
+   * @returns Order information
+   * @throws {NordError} If the request fails
+   */
+  public async getOrder(orderId: string): Promise<OrderInfoFromApi> {
+    return await this.GET("/order/{order_id}", {
+      params: {
+        path: { order_id: orderId },
+      },
+    });
+  }
+
+  /**
+   * Get trade history for a specific order.
+   *
+   * @param orderId - Order identifier
+   * @param query - Optional pagination parameters
+   * @returns Page of trades associated with the order
+   * @throws {NordError} If the request fails
+   */
+  public async getOrderTrades(
+    orderId: string,
+    query?: { startInclusive?: string | null; pageSize?: number | null },
+  ): Promise<PageResultStringTrade> {
+    return await this.GET("/order/{order_id}/trades", {
+      params: {
+        path: { order_id: orderId },
+        query: {
+          startInclusive: query?.startInclusive,
+          pageSize: query?.pageSize,
+        },
+      },
+    });
+  }
+
   /**
    * Check if an account exists for the given address
    *
@@ -690,4 +867,70 @@ export class Nord {
   public async accountExists(pubkey: string | PublicKey): Promise<boolean> {
     return !!(await this.getUser({ pubkey }));
   }
+
+  /**
+   * Fetch active triggers for an account.
+   *
+   * @param params Optional parameters containing an explicit account id.
+   * @throws {NordError} If no account can be resolved or the request fails.
+   */
+  async getAccountTriggers(params?: {
+    accountId?: number;
+  }): Promise<AccountTriggerInfo[]> {
+    const accountId = params?.accountId;
+
+    if (accountId == null) {
+      throw new NordError(
+        "Account ID is undefined. Make sure to call updateAccountId() before requesting triggers.",
+      );
+    }
+
+    try {
+      const triggers = await this.GET("/account/{account_id}/triggers", {
+        params: {
+          path: { account_id: accountId },
+        },
+      });
+      return triggers ?? [];
+    } catch (error) {
+      throw new NordError("Failed to fetch account triggers", { cause: error });
+    }
+  }
+
+  /**
+   * Fetch trigger history for an account.
+   *
+   * @param params Optional parameters with account id and history query filters.
+   * @throws {NordError} If no account can be resolved or the request fails.
+   */
+  async getAccountTriggerHistory(
+    params: HistoryTriggerQuery & { accountId?: number },
+  ): Promise<TriggerHistoryPage> {
+    const accountId = params?.accountId;
+
+    if (accountId == null) {
+      throw new NordError(
+        "Account ID is undefined. Make sure to call updateAccountId() before requesting trigger history.",
+      );
+    }
+
+    const { accountId: _, ...query } = params;
+    try {
+      return await this.GET("/account/{account_id}/triggers/history", {
+        params: {
+          path: { account_id: accountId },
+          query: {
+            since: query.since,
+            until: query.until,
+            pageSize: query.pageSize,
+            startInclusive: query.startInclusive,
+          },
+        },
+      });
+    } catch (error) {
+      throw new NordError("Failed to fetch account trigger history", {
+        cause: error,
+      });
+    }
+  }
 }