@n1xyz/nord-ts 0.1.3 → 0.1.5

package/src/nord/client/NordUser.ts

@@ -21,39 +21,30 @@ import {
   SPLTokenInfo,
   QuoteSize,
   TriggerKind,
+  fillModeToProtoFillMode,
 } from "../../types";
 import * as proto from "../../gen/nord_pb";
 import {
   BigIntValue,
   checkedFetch,
+  assert,
   findMarket,
   findToken,
   optExpect,
   keypairFromPrivateKey,
+  toScaledU64,
 } from "../../utils";
+import { create } from "@bufbuild/protobuf";
 import {
-  cancelOrder,
   createSession,
-  placeOrder,
   revokeSession,
-  transfer,
-  withdraw,
-  atomic as atomicAction,
-  AtomicSubaction as ApiAtomicSubaction,
-  addTrigger as addTriggerAction,
-  removeTrigger as removeTriggerAction,
+  atomic,
+  expectReceiptKind,
+  AtomicSubaction,
 } from "../api/actions";
-import type {
-  AccountTriggerInfo,
-  TriggerHistoryPage,
-  HistoryTriggerQuery,
-} from "../api/triggers";
-import {
-  getAccountTriggers as fetchAccountTriggers,
-  getAccountTriggerHistory as fetchAccountTriggerHistory,
-} from "../api/triggers";
 import { NordError } from "../utils/NordError";
 import { Nord } from "./Nord";
+import { NordClient } from "./NordClient";
 
 /**
  * Parameters for creating a NordUser instance
@@ -114,6 +105,8 @@ export interface PlaceOrderParams {
 
   /** Account ID to place the order from */
   accountId?: number;
+
+  clientOrderId?: BigIntValue;
 }
 
 export interface AddTriggerParams {
@@ -190,26 +183,7 @@ export interface UserAtomicSubaction {
 /**
  * User class for interacting with the Nord protocol
  */
-export class NordUser {
-  /** Nord client instance */
-  public readonly nord: Nord;
-
-  /** User's blockchain address */
-  public readonly address: PublicKey;
-
-  /** Function to sign messages with the user's wallet */
-  public readonly walletSignFn: (
-    message: Uint8Array | string,
-  ) => Promise<Uint8Array>;
-
-  /** Function to sign messages with the user's session key */
-  public readonly sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
-
-  /** Function to sign transactions with the user's wallet */
-  public readonly transactionSignFn: <T extends Transaction>(
-    tx: T,
-  ) => Promise<T>;
-
+export class NordUser extends NordClient {
   /** User balances by token symbol */
   public balances: {
     [key: string]: { accountId: number; balance: number; symbol: string }[];
@@ -249,24 +223,6 @@ export class NordUser {
   /** User's account IDs */
   public accountIds?: number[];
 
-  /** Current session ID */
-  public sessionId?: bigint;
-
-  /** User's public key */
-  public publicKey: PublicKey;
-
-  /** Session public key */
-  public sessionPubKey: Uint8Array;
-
-  /** Last timestamp used */
-  public lastTs = 0;
-
-  /** Last nonce used */
-  public lastNonce = 0;
-
-  /** Solana connection */
-  public connection: Connection;
-
   /** SPL token information */
   public splTokenInfos: SPLTokenInfo[] = [];
 
@@ -297,28 +253,24 @@ export class NordUser {
       throw new NordError("Session public key is required");
     }
 
+    let parsedAddress: PublicKey;
     try {
-      this.address = new PublicKey(address);
+      parsedAddress = new PublicKey(address);
     } catch (error) {
       throw new NordError("Invalid Solana address", { cause: error });
     }
 
-    this.nord = nord;
-    this.walletSignFn = walletSignFn;
-    this.sessionSignFn = sessionSignFn;
-    this.transactionSignFn = transactionSignFn;
-    this.sessionPubKey = sessionPubKey;
-    this.publicKey = publicKey;
-    this.connection =
-      connection ||
-      new Connection(nord.solanaUrl, {
-        commitment: "confirmed",
-      });
-
-    // Set sessionId if provided
-    if (sessionId !== undefined) {
-      this.sessionId = sessionId;
-    }
+    super({
+      nord,
+      address: parsedAddress,
+      walletSignFn,
+      sessionSignFn,
+      transactionSignFn,
+      connection,
+      sessionId,
+      sessionPubKey,
+      publicKey,
+    });
 
     // Convert tokens from info endpoint to SPLTokenInfo
     if (this.nord.tokens && this.nord.tokens.length > 0) {
@@ -344,8 +296,9 @@ export class NordUser {
       sessionSignFn: this.sessionSignFn,
       transactionSignFn: this.transactionSignFn,
       connection: this.connection,
-      sessionPubKey: this.sessionPubKey,
+      sessionPubKey: new Uint8Array(this.sessionPubKey),
       publicKey: this.publicKey,
+      sessionId: this.sessionId,
     });
 
     // Copy other properties
@@ -353,11 +306,8 @@ export class NordUser {
     cloned.positions = { ...this.positions };
     cloned.margins = { ...this.margins };
     cloned.accountIds = this.accountIds ? [...this.accountIds] : undefined;
-    cloned.sessionId = this.sessionId;
-    cloned.publicKey = this.publicKey;
-    cloned.lastTs = this.lastTs;
-    cloned.lastNonce = this.lastNonce;
     cloned.splTokenInfos = [...this.splTokenInfos];
+    this.cloneClientState(cloned);
 
     return cloned;
   }
@@ -486,7 +436,7 @@ export class NordUser {
   }
 
   /**
-   * Deposit SPL tokens to the bridge
+   * Deposit SPL tokens to the app
    *
    * @param amount - Amount to deposit
    * @param tokenId - Token ID
@@ -504,7 +454,7 @@ export class NordUser {
   }
 
   /**
-   * Deposit SPL tokens to the bridge
+   * Deposit SPL tokens to the app
    *
    * @param amount - Amount to deposit
    * @param tokenId - Token ID
@@ -573,7 +523,19 @@ export class NordUser {
    * @returns Nonce as number
    */
   getNonce(): number {
-    return ++this.lastNonce;
+    return this.nextActionNonce();
+  }
+
+  private async submitSessionAction(
+    kind: proto.Action["kind"],
+  ): Promise<proto.Receipt> {
+    return this.submitSignedAction(kind, async (message) => {
+      const signature = await this.sessionSignFn(message);
+      const signed = new Uint8Array(message.length + signature.length);
+      signed.set(message);
+      signed.set(signature, message.length);
+      return signed;
+    });
   }
 
   /**
@@ -763,19 +725,21 @@ export class NordUser {
   }>): Promise<{ actionId: bigint }> {
     try {
       this.checkSessionValidity();
-      const { actionId } = await withdraw(
-        this.nord.webServerUrl,
-        this.sessionSignFn,
-        await this.nord.getTimestamp(),
-        this.getNonce(),
-        {
-          sizeDecimals: findToken(this.nord.tokens, tokenId).decimals,
-          sessionId: optExpect(this.sessionId, "No session"),
-          tokenId: tokenId,
-          amount,
-        },
-      );
-      return { actionId };
+      const token = findToken(this.nord.tokens, tokenId);
+      const scaledAmount = toScaledU64(amount, token.decimals);
+      if (scaledAmount <= 0n) {
+        throw new NordError("Withdraw amount must be positive");
+      }
+      const receipt = await this.submitSessionAction({
+        case: "withdraw",
+        value: create(proto.Action_WithdrawSchema, {
+          sessionId: BigInt(optExpect(this.sessionId, "No session")),
+          tokenId,
+          amount: scaledAmount,
+        }),
+      });
+      expectReceiptKind(receipt, "withdrawResult", "withdraw");
+      return { actionId: receipt.actionId };
     } catch (error) {
       throw new NordError(
         `Failed to withdraw ${amount} of token ID ${tokenId}`,
@@ -802,27 +766,48 @@ export class NordUser {
       if (!market) {
         throw new NordError(`Market with ID ${params.marketId} not found`);
       }
+      const sessionId = optExpect(this.sessionId, "No session");
+      const price = toScaledU64(params.price ?? 0, market.priceDecimals);
+      const size = toScaledU64(params.size ?? 0, market.sizeDecimals);
+      const scaledQuote = params.quoteSize
+        ? params.quoteSize.toWire(market.priceDecimals, market.sizeDecimals)
+        : undefined;
+      assert(
+        price > 0n || size > 0n || scaledQuote !== undefined,
+        "OrderLimit must include at least one of: size, price, or quoteSize",
+      );
 
-      const result = await placeOrder(
-        this.nord.webServerUrl,
-        this.sessionSignFn,
-        await this.nord.getTimestamp(),
-        this.getNonce(),
-        {
-          sessionId: optExpect(this.sessionId, "No session"),
-          senderId: params.accountId,
-          sizeDecimals: market.sizeDecimals,
-          priceDecimals: market.priceDecimals,
+      const receipt = await this.submitSessionAction({
+        case: "placeOrder",
+        value: create(proto.Action_PlaceOrderSchema, {
+          sessionId: BigInt(sessionId),
+          senderAccountId: params.accountId,
           marketId: params.marketId,
-          side: params.side,
-          fillMode: params.fillMode,
+          side: params.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+          fillMode: fillModeToProtoFillMode(params.fillMode),
           isReduceOnly: params.isReduceOnly,
-          size: params.size,
-          price: params.price,
-          quoteSize: params.quoteSize,
-        },
-      );
-      return result;
+          price,
+          size,
+          quoteSize:
+            scaledQuote === undefined
+              ? undefined
+              : create(proto.QuoteSizeSchema, {
+                  size: scaledQuote.size,
+                  price: scaledQuote.price,
+                }),
+          clientOrderId:
+            params.clientOrderId === undefined
+              ? undefined
+              : BigInt(params.clientOrderId),
+        }),
+      });
+      expectReceiptKind(receipt, "placeOrderResult", "place order");
+      const result = receipt.kind.value;
+      return {
+        actionId: receipt.actionId,
+        orderId: result.posted?.orderId,
+        fills: result.fills,
+      };
     } catch (error) {
       throw new NordError("Failed to place order", { cause: error });
     }
@@ -848,18 +833,20 @@ export class NordUser {
       providedAccountId != null ? providedAccountId : this.accountIds?.[0];
     try {
       this.checkSessionValidity();
-      const result = await cancelOrder(
-        this.nord.webServerUrl,
-        this.sessionSignFn,
-        await this.nord.getTimestamp(),
-        this.getNonce(),
-        {
-          sessionId: optExpect(this.sessionId, "No session"),
-          senderId: accountId,
-          orderId,
-        },
-      );
-      return result;
+      const receipt = await this.submitSessionAction({
+        case: "cancelOrderById",
+        value: create(proto.Action_CancelOrderByIdSchema, {
+          orderId: BigInt(orderId),
+          sessionId: BigInt(optExpect(this.sessionId, "No session")),
+          senderAccountId: accountId,
+        }),
+      });
+      expectReceiptKind(receipt, "cancelOrderResult", "cancel order");
+      return {
+        actionId: receipt.actionId,
+        orderId: receipt.kind.value.orderId,
+        accountId: receipt.kind.value.accountId,
+      };
     } catch (error) {
       throw new NordError(`Failed to cancel order ${orderId}`, {
         cause: error,
@@ -881,23 +868,41 @@ export class NordUser {
       if (!market) {
         throw new NordError(`Market with ID ${params.marketId} not found`);
       }
-      const result = await addTriggerAction(
-        this.nord.webServerUrl,
-        this.sessionSignFn,
-        await this.nord.getTimestamp(),
-        this.getNonce(),
-        {
-          sessionId: optExpect(this.sessionId, "No session"),
+      const triggerPrice = toScaledU64(
+        params.triggerPrice,
+        market.priceDecimals,
+      );
+      assert(triggerPrice > 0n, "Trigger price must be positive");
+      const limitPrice =
+        params.limitPrice === undefined
+          ? undefined
+          : toScaledU64(params.limitPrice, market.priceDecimals);
+      if (limitPrice !== undefined) {
+        assert(limitPrice > 0n, "Limit price must be positive");
+      }
+      const key = create(proto.TriggerKeySchema, {
+        kind:
+          params.kind === TriggerKind.StopLoss
+            ? proto.TriggerKind.STOP_LOSS
+            : proto.TriggerKind.TAKE_PROFIT,
+        side: params.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+      });
+      const prices = create(proto.Action_TriggerPricesSchema, {
+        triggerPrice,
+        limitPrice,
+      });
+      const receipt = await this.submitSessionAction({
+        case: "addTrigger",
+        value: create(proto.Action_AddTriggerSchema, {
+          sessionId: BigInt(optExpect(this.sessionId, "No session")),
           marketId: params.marketId,
-          side: params.side,
-          kind: params.kind,
-          priceDecimals: market.priceDecimals,
-          triggerPrice: params.triggerPrice,
-          limitPrice: params.limitPrice,
+          key,
+          prices,
           accountId: params.accountId,
-        },
-      );
-      return result;
+        }),
+      });
+      expectReceiptKind(receipt, "triggerAdded", "add trigger");
+      return { actionId: receipt.actionId };
     } catch (error) {
       throw new NordError("Failed to add trigger", { cause: error });
     }
@@ -919,80 +924,29 @@ export class NordUser {
       if (!market) {
         throw new NordError(`Market with ID ${params.marketId} not found`);
       }
-      const result = await removeTriggerAction(
-        this.nord.webServerUrl,
-        this.sessionSignFn,
-        await this.nord.getTimestamp(),
-        this.getNonce(),
-        {
-          sessionId: optExpect(this.sessionId, "No session"),
+      const key = create(proto.TriggerKeySchema, {
+        kind:
+          params.kind === TriggerKind.StopLoss
+            ? proto.TriggerKind.STOP_LOSS
+            : proto.TriggerKind.TAKE_PROFIT,
+        side: params.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+      });
+      const receipt = await this.submitSessionAction({
+        case: "removeTrigger",
+        value: create(proto.Action_RemoveTriggerSchema, {
+          sessionId: BigInt(optExpect(this.sessionId, "No session")),
           marketId: params.marketId,
-          side: params.side,
-          kind: params.kind,
+          key,
           accountId: params.accountId,
-        },
-      );
-      return result;
+        }),
+      });
+      expectReceiptKind(receipt, "triggerRemoved", "remove trigger");
+      return { actionId: receipt.actionId };
     } catch (error) {
       throw new NordError("Failed to remove trigger", { cause: error });
     }
   }
 
-  /**
-   * 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 ?? this.accountIds?.[0];
-
-    if (accountId == null) {
-      throw new NordError(
-        "Account ID is undefined. Make sure to call updateAccountId() before requesting triggers.",
-      );
-    }
-
-    try {
-      return await fetchAccountTriggers(this.nord.webServerUrl, accountId);
-    } 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: providedAccountId, ...query } = params;
-    const accountId = providedAccountId ?? this.accountIds?.[0];
-
-    if (accountId == null) {
-      throw new NordError(
-        "Account ID is undefined. Make sure to call updateAccountId() before requesting trigger history.",
-      );
-    }
-
-    try {
-      return await fetchAccountTriggerHistory(
-        this.nord.webServerUrl,
-        accountId,
-        query,
-      );
-    } catch (error) {
-      throw new NordError("Failed to fetch account trigger history", {
-        cause: error,
-      });
-    }
-  }
-
   /**
    * Transfer tokens to another account
    *
@@ -1004,20 +958,22 @@ export class NordUser {
       this.checkSessionValidity();
       const token = findToken(this.nord.tokens, params.tokenId);
 
-      await transfer(
-        this.nord.webServerUrl,
-        this.sessionSignFn,
-        await this.nord.getTimestamp(),
-        this.getNonce(),
-        {
-          sessionId: optExpect(this.sessionId, "No session"),
+      const amount = toScaledU64(params.amount, token.decimals);
+      if (amount <= 0n) {
+        throw new NordError("Transfer amount must be positive");
+      }
+
+      const receipt = await this.submitSessionAction({
+        case: "transfer",
+        value: create(proto.Action_TransferSchema, {
+          sessionId: BigInt(optExpect(this.sessionId, "No session")),
           fromAccountId: optExpect(params.fromAccountId, "No source account"),
           toAccountId: optExpect(params.toAccountId, "No target account"),
           tokenId: params.tokenId,
-          tokenDecimals: token.decimals,
-          amount: params.amount,
-        },
-      );
+          amount,
+        }),
+      });
+      expectReceiptKind(receipt, "transferred", "transfer tokens");
     } catch (error) {
       throw new NordError("Failed to transfer tokens", { cause: error });
     }
@@ -1054,7 +1010,7 @@ export class NordUser {
         );
       }
 
-      const apiActions: ApiAtomicSubaction[] = userActions.map((act) => {
+      const apiActions: AtomicSubaction[] = userActions.map((act) => {
         if (act.kind === "place") {
           const market = findMarket(this.nord.markets, act.marketId!);
           if (!market) {
@@ -1072,15 +1028,15 @@ export class NordUser {
             price: act.price,
             quoteSize: act.quoteSize,
             clientOrderId: act.clientOrderId,
-          } as ApiAtomicSubaction;
+          } as AtomicSubaction;
         }
         return {
           kind: "cancel",
           orderId: act.orderId,
-        } as ApiAtomicSubaction;
+        } as AtomicSubaction;
       });
 
-      const result = await atomicAction(
+      const result = await atomic(
         this.nord.webServerUrl,
         this.sessionSignFn,
         await this.nord.getTimestamp(),
@@ -1252,13 +1208,4 @@ export class NordUser {
       });
     }
   }
-
-  /**
-   * Get the Solana public key derived from the address
-   *
-   * @returns The Solana public key
-   */
-  getSolanaPublicKey(): PublicKey {
-    return this.address;
-  }
 }

package/src/nord/index.ts

@@ -1,6 +1,17 @@
 // Export main client classes
 export { Nord } from "./client/Nord";
 export { NordUser } from "./client/NordUser";
+export { NordAdmin } from "./client/NordAdmin";
+export { NordClient } from "./client/NordClient";
+export type { NordClientParams } from "./client/NordClient";
+export type {
+  CreateTokenParams,
+  CreateMarketParams,
+  PythSetWormholeGuardiansParams,
+  PythSetSymbolFeedParams,
+  FreezeMarketParams,
+  UnfreezeMarketParams,
+} from "./client/NordAdmin";
 
 // Export utility classes
 export { NordError } from "./utils/NordError";

package/src/types.ts

@@ -38,8 +38,8 @@ export type SubscriptionPattern = `${SubscriptionType}@${string}` | string;
 export interface NordConfig {
   /** Base URL for the Nord web server */
   webServerUrl: string;
-  /** Bridge verification key */
-  bridgeVk: string;
+  /** App address */
+  app: string;
   /** Solana cluster URL */
   solanaUrl: string;
   /**
@@ -49,9 +49,9 @@ export interface NordConfig {
   initWebSockets?: boolean;
 }
 
-export type Info = components["schemas"]["Info2"];
-export type Market = Info["markets"][number];
-export type Token = Info["tokens"][number];
+export type MarketsInfo = components["schemas"]["MarketsInfo"];
+export type Market = MarketsInfo["markets"][number];
+export type Token = MarketsInfo["tokens"][number];
 export type Account = components["schemas"]["Account"];
 export type TradesResponse =
   components["schemas"]["PageResult_for_String_and_Trade"];
@@ -92,6 +92,16 @@ export type AccountPnlQuery = components["schemas"]["AccountPnlQuery"];
 export type AccountPnl = components["schemas"]["AccountPnl"];
 export type AccountPnlPage =
   components["schemas"]["PageResult_for_uint64_and_AccountPnl"];
+export type AccountTriggerInfo = components["schemas"]["AccountTriggerInfo"];
+export type TriggerHistoryPage =
+  components["schemas"]["PageResult_for_uint64_and_HistoryTriggerInfo"];
+export type HistoryTriggerQuery = components["schemas"]["AccountTriggersQuery"];
+export type FeeTierConfig = components["schemas"]["FeeTierConfig"];
+export type FeeTierId = components["schemas"]["FeeTierId"];
+export type TokenStats = components["schemas"]["TokenStats"];
+export type AccountFeeTier = components["schemas"]["AccountFeeTier"];
+export type AccountFeeTierPage =
+  components["schemas"]["PageResult_for_uint32_and_AccountFeeTier"];
 
 /**
  * Configuration options for the Nord client

package/src/utils.ts

@@ -233,6 +233,11 @@ export function checkPubKeyLength(keyType: KeyType, len: number): void {
   }
 }
 
+export function decodeHex(value: string): Uint8Array {
+  const hex = value.startsWith("0x") ? value.slice(2) : value;
+  return Uint8Array.from(Buffer.from(hex, "hex"));
+}
+
 export function findMarket(markets: Market[], marketId: number): Market {
   if (marketId < 0 || markets.length - 1 < marketId) {
     throw new Error(`The market with marketId=${marketId} not found`);