@n1xyz/nord-ts 0.1.4 → 0.1.6

package/src/gen/openapi.ts

@@ -362,6 +362,14 @@ export interface paths {
                         "application/json": number;
                     };
                 };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UserNotFound"];
+                    };
+                };
             };
         };
         put?: never;
@@ -1103,6 +1111,127 @@ export interface paths {
         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;
@@ -2076,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;
@@ -2153,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;
@@ -2525,6 +2654,41 @@ export interface components {
             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>,

package/src/nord/client/Nord.ts

@@ -16,6 +16,7 @@ import {
   NordConfig,
   OrderbookQuery,
   OrderbookResponse,
+  FeeTierConfig,
   PeakTpsPeriodUnit,
   SubscriptionPattern,
   Token,
@@ -24,6 +25,13 @@ import {
   AccountTriggerInfo,
   HistoryTriggerQuery,
   TriggerHistoryPage,
+  FeeTierId,
+  AccountFeeTierPage,
+  PageResultStringOrderInfo,
+  PageResultStringTrade,
+  OrderInfoFromApi,
+  TokenStats,
+  FillRole,
 } from "../../types";
 import * as utils from "../../utils";
 import { NordWebSocketClient } from "../../websocket/index";
@@ -231,13 +239,14 @@ export class Nord {
     app,
     solanaUrl,
     webServerUrl,
+    protonUrl,
   }: Readonly<NordConfig>): Promise<Nord> {
     // TODO: we should parametrize the connectionn not have it done here.
     // 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 protonClient = await ProtonClient.init({
-      protonUrl: webServerUrl,
+      protonUrl: protonUrl ?? webServerUrl,
       app: new PublicKey(app),
       solConn: connection,
     });
@@ -617,6 +626,31 @@ export class Nord {
     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
    *
@@ -632,6 +666,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
    *
@@ -674,6 +778,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
    *