@n1xyz/nord-ts 0.1.0 → 0.1.2

package/src/gen/openapi.ts

@@ -84,8 +84,12 @@ export interface paths {
         get: {
             parameters: {
                 query: {
+                    /** @description Start action ID (exclusive) */
                     from: number;
+                    /** @description End action ID (inclusive) */
                     to: number;
+                    /** @description Optionally provided binary version of client, so nord server can ensure all actions provided are executable by client. */
+                    clientVersion?: components["schemas"]["ExecutableVersion"] | null;
                 };
                 header?: never;
                 path?: never;
@@ -109,6 +113,14 @@ export interface paths {
                         "application/json": components["schemas"]["RangeTooLarge"];
                     };
                 };
+                501: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["NotImplemented"];
+                    };
+                };
             };
         };
         put?: never;
@@ -137,6 +149,14 @@ export interface paths {
                         "application/octet-stream": unknown;
                     };
                 };
+                413: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["PayloadTooLarge"];
+                    };
+                };
                 415: {
                     headers: {
                         /**
@@ -779,7 +799,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["TriggerInfo"][] | null;
+                        "application/json": components["schemas"]["AccountTriggerInfo"][] | null;
                     };
                 };
             };
@@ -976,6 +996,79 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/state/download": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Returns state download link and metadata, as defined by nearest(up to equality) snapshot `time` or `action_id`` or `timestamp`. If not specified, returns latest snapshot. Example: /state/download?actionId=1 /state/download?time&2025-09-22T12:34:56Z /state/download?timestamp&1695380000 - Does not implemented yet. To get the latest snap use: /state/download - w/o any params.
+         *
+         *     The link from responce can be inserted to search bar in browser to download. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["StateDownloadMeta"];
+                    };
+                };
+                501: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["NotImplemented"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/state/download/{snapshot_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Typical HTTP file download endpoint. Actually same as provided by S3 storages. Means supports Range header, Content-Length, Content-Type, ETag and so on, and relevant headers. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    snapshot_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: never;
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/tv": {
         parameters: {
             query?: never;
@@ -1911,12 +2004,25 @@ export interface components {
         AcceptedMediaType: {
             expected: string;
         };
+        PayloadTooLarge: {
+            /** Format: uint */
+            limit: number;
+        };
         ActionsQuery: {
-            /** Format: uint64 */
+            /**
+             * Format: uint64
+             * @description Start action ID (exclusive)
+             */
             from: number;
-            /** Format: uint64 */
+            /**
+             * Format: uint64
+             * @description End action ID (inclusive)
+             */
             to: number;
+            /** @description Optionally provided binary version of client, so nord server can ensure all actions provided are executable by client. */
+            clientVersion?: components["schemas"]["ExecutableVersion"] | null;
         };
+        ExecutableVersion: string;
         ActionsItem: {
             /** Format: uint64 */
             actionId: number;
@@ -1929,6 +2035,10 @@ export interface components {
             /** Format: uint16 */
             maximal: number;
         };
+        NotImplemented: {
+            /** @description Human readable message describing what to expect next. */
+            message: string;
+        };
         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";
@@ -2259,14 +2369,23 @@ export interface components {
         /** @enum {string} */
         TriggerKind: "stopLoss" | "takeProfit";
         /** @enum {string} */
-        TriggerStatus: "active" | "success" | "cancel" | "fail" | "remove";
-        TriggerInfo: {
+        TriggerStatus: "Active" | "Success" | "Removed" | "Canceled";
+        /** @description Trigger into per account. */
+        AccountTriggerInfo: {
             /** Format: uint32 */
             marketId: number;
+            key: components["schemas"]["TriggerKey"];
+            triggerPrices: components["schemas"]["TriggerPrice"];
+            /** Format: uint64 */
+            actionId: number;
+        };
+        TriggerKey: {
             side: components["schemas"]["Side"];
             kind: components["schemas"]["TriggerKind"];
-            triggerPrice: components["schemas"]["PositivePriceMantissa"];
-            limitPrice?: components["schemas"]["PositivePriceMantissa"] | null;
+        };
+        TriggerPrice: {
+            trigger: components["schemas"]["PositivePriceMantissa"];
+            settlement?: components["schemas"]["PositivePriceMantissa"] | null;
         };
         /**
          * Format: uint64
@@ -2334,6 +2453,29 @@ export interface components {
              */
             pageSize: number | null;
         };
+        DownloadFilter: components["schemas"]["Op_for_DataDateTime"] | components["schemas"]["Op_for_uint64"] | components["schemas"]["Op_for_uint64"] | null;
+        /** @description Parses tag (anycase), and value in round braces using `from_str`. */
+        Op_for_DataDateTime: {
+            le: components["schemas"]["DataDateTime"];
+        };
+        DataDateTime: string;
+        /** @description Parses tag (anycase), and value in round braces using `from_str`. */
+        Op_for_uint64: {
+            /** Format: uint64 */
+            le: number;
+        };
+        StateDownloadMeta: {
+            /** @description Hash of the state file. Used as ETag. */
+            hash: number[];
+            /**
+             * Format: uri
+             * @description Link to download the state file.
+             */
+            link: string;
+            /** @description Version of binary which produced this state snapshot. So can decide whether it is compatible with client. todo(repl): After upgrade release make it non-optional. */
+            version?: components["schemas"]["BinaryId"] | null;
+        };
+        BinaryId: string;
         /** @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

@@ -1,6 +1,6 @@
 import Decimal from "decimal.js";
 import * as proto from "../../gen/nord_pb";
-import { paths, components } from "../../gen/openapi";
+import { paths } from "../../gen/openapi";
 import createClient from "openapi-fetch";
 
 import { create } from "@bufbuild/protobuf";
@@ -10,11 +10,11 @@ import {
   KeyType,
   Side,
   QuoteSize,
+  TriggerKind,
 } from "../../types";
 import {
   assert,
   BigIntValue,
-  checkedFetch,
   checkPubKeyLength,
   decodeLengthDelimited,
   SESSION_TTL,
@@ -55,7 +55,6 @@ async function sendAction(
   serverUrl: string,
   makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>,
   action: proto.Action,
-  actionErrorDesc: string,
 ): Promise<proto.Receipt> {
   const body = await prepareAction(action, makeSignedMessage);
   // NOTE: restructure and reuse client as it is in Nord.ts
@@ -67,13 +66,19 @@ async function sendAction(
       },
     },
     body: body,
+    // NOTE: openapi-fetch ignores headers and types/const headers in schema, and always assume all things are JSON
+    // to handle multi type bodies, need these overrides and later adhoc parsing
+    bodySerializer: (body) => body,
+    parseAs: "stream",
   });
 
   if (response.error) {
-    throw new Error(`Failed to ${actionErrorDesc}, HTTP status ${response}`);
+    throw new Error(
+      `Failed to ${action.kind.case}, HTTP status ${JSON.stringify(response.error)}`,
+    );
   }
 
-  const rawResp = new Uint8Array(await response.response.arrayBuffer());
+  const rawResp = new Uint8Array(await response.response.bytes());
 
   const resp: proto.Receipt = decodeLengthDelimited(
     rawResp,
@@ -82,7 +87,7 @@ async function sendAction(
 
   if (resp.kind?.case === "err") {
     throw new Error(
-      `Could not ${actionErrorDesc}, reason: ${proto.Error[resp.kind.value]}`,
+      `Could not execute ${action.kind.case}, reason: ${proto.Error[resp.kind.value]}`,
     );
   }
 
@@ -96,14 +101,21 @@ export async function prepareAction(
   makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>,
 ) {
   const encoded = sizeDelimitedEncode(proto.ActionSchema, action);
-  // NOTE(agent): keep in sync with MAX_HTTP_REQUEST_BODY_SIZE in rust code
-  const MAX_HTTP_REQUEST_BODY_SIZE = 1024;
-  if (encoded.byteLength > MAX_HTTP_REQUEST_BODY_SIZE) {
+  // NOTE(agent): keep in sync with MAX_ENCODED_ACTION_SIZE in Rust code
+  const MAX_ENCODED_ACTION_SIZE = 1024;
+  if (encoded.byteLength > MAX_ENCODED_ACTION_SIZE) {
+    console.warn("Encoded message:", encoded);
     throw new Error(
-      `Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_HTTP_REQUEST_BODY_SIZE} bytes).`,
+      `Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_ENCODED_ACTION_SIZE} bytes).`,
     );
   }
   const body = await makeSignedMessage(encoded);
+  if (body.byteLength > MAX_ENCODED_ACTION_SIZE) {
+    console.warn("Encoded length:", encoded.byteLength);
+    throw new Error(
+      `Signed message size (${body.byteLength} bytes) is greater than max payload size (${MAX_ENCODED_ACTION_SIZE} bytes).`,
+    );
+  }
   return body;
 }
 
@@ -147,7 +159,6 @@ export async function createSession(
     serverUrl,
     (m) => walletSign(walletSignFn, m),
     action,
-    "create a new session",
   );
 
   if (resp.kind?.case === "createSessionResult") {
@@ -180,7 +191,6 @@ export async function revokeSession(
     serverUrl,
     (m) => walletSign(walletSignFn, m),
     action,
-    "revoke session",
   );
 
   return { actionId: resp.actionId };
@@ -217,7 +227,6 @@ export async function withdraw(
     serverUrl,
     (m) => sessionSign(signFn, m),
     action,
-    "withdraw",
   );
 
   if (resp.kind?.case === "withdrawResult") {
@@ -257,7 +266,7 @@ export async function placeOrder(
   const size = toScaledU64(params.size ?? 0, params.sizeDecimals);
 
   const scaledQuote = params.quoteSize
-    ? params.quoteSize.toScaledU64(params.priceDecimals, params.sizeDecimals)
+    ? params.quoteSize.toWire(params.priceDecimals, params.sizeDecimals)
     : undefined;
 
   assert(
@@ -295,7 +304,6 @@ export async function placeOrder(
     serverUrl,
     (m) => sessionSign(signFn, m),
     action,
-    "place order",
   );
 
   if (resp.kind?.case === "placeOrderResult") {
@@ -339,7 +347,6 @@ export async function cancelOrder(
     serverUrl,
     (m) => sessionSign(signFn, m),
     action,
-    "cancel order",
   );
 
   if (resp.kind?.case === "cancelOrderResult") {
@@ -389,7 +396,6 @@ export async function transfer(
     serverUrl,
     (m) => sessionSign(signFn, m),
     action,
-    "transfer",
   );
 
   if (resp.kind?.case === "transferred") {
@@ -406,6 +412,103 @@ export async function transfer(
   }
 }
 
+export async function addTrigger(
+  serverUrl: string,
+  signFn: (message: Uint8Array) => Promise<Uint8Array>,
+  currentTimestamp: bigint,
+  nonce: number,
+  params: {
+    sessionId: BigIntValue;
+    marketId: number;
+    side: Side;
+    kind: TriggerKind;
+    priceDecimals: number;
+    triggerPrice: Decimal.Value;
+    limitPrice?: Decimal.Value;
+    accountId?: number;
+  },
+): Promise<{ actionId: bigint }> {
+  const triggerPrice = toScaledU64(params.triggerPrice, params.priceDecimals);
+  assert(triggerPrice > 0n, "Trigger price must be positive");
+  const limitPrice =
+    params.limitPrice === undefined
+      ? undefined
+      : toScaledU64(params.limitPrice, params.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 action = createAction(currentTimestamp, nonce, {
+    case: "addTrigger",
+    value: create(proto.Action_AddTriggerSchema, {
+      sessionId: BigInt(params.sessionId),
+      marketId: params.marketId,
+      key,
+      prices,
+      accountId: params.accountId,
+    }),
+  });
+  const resp = await sendAction(
+    serverUrl,
+    (m) => sessionSign(signFn, m),
+    action,
+  );
+  if (resp.kind?.case === "triggerAdded") {
+    return { actionId: resp.actionId };
+  }
+  throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
+}
+
+export async function removeTrigger(
+  serverUrl: string,
+  signFn: (message: Uint8Array) => Promise<Uint8Array>,
+  currentTimestamp: bigint,
+  nonce: number,
+  params: {
+    sessionId: BigIntValue;
+    marketId: number;
+    side: Side;
+    kind: TriggerKind;
+    accountId?: number;
+  },
+): Promise<{ actionId: bigint }> {
+  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 action = createAction(currentTimestamp, nonce, {
+    case: "removeTrigger",
+    value: create(proto.Action_RemoveTriggerSchema, {
+      sessionId: BigInt(params.sessionId),
+      marketId: params.marketId,
+      key,
+      accountId: params.accountId,
+    }),
+  });
+  const resp = await sendAction(
+    serverUrl,
+    (m) => sessionSign(signFn, m),
+    action,
+  );
+  if (resp.kind?.case === "triggerRemoved") {
+    return { actionId: resp.actionId };
+  }
+  throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
+}
+
 export type AtomicSubaction =
   | {
       kind: "place";
@@ -452,7 +555,7 @@ export async function atomic(
       const price = toScaledU64(a.price ?? 0, a.priceDecimals);
       const size = toScaledU64(a.size ?? 0, a.sizeDecimals);
       const scaledQuote = a.quoteSize
-        ? a.quoteSize.toScaledU64(a.priceDecimals, a.sizeDecimals)
+        ? a.quoteSize.toWire(a.priceDecimals, a.sizeDecimals)
         : undefined;
 
       // Require at least one limit to be set (non-zero size, non-zero price, or quoteSize)
@@ -510,7 +613,6 @@ export async function atomic(
     serverUrl,
     (m) => sessionSign(signFn, m),
     action,
-    "execute atomic action",
   );
   if (resp.kind?.case === "atomic") {
     return {

package/src/nord/api/triggers.ts

@@ -0,0 +1,57 @@
+import createClient from "openapi-fetch";
+
+import { paths, components } from "../../gen/openapi";
+
+type AccountTriggerInfo = components["schemas"]["AccountTriggerInfo"];
+type TriggerHistoryPage =
+  components["schemas"]["PageResult_for_uint64_and_HistoryTriggerInfo"];
+type HistoryTriggerQuery = components["schemas"]["AccountTriggersQuery"];
+
+export type { AccountTriggerInfo, TriggerHistoryPage, HistoryTriggerQuery };
+
+export async function getAccountTriggers(
+  serverUrl: string,
+  accountId: number,
+): Promise<AccountTriggerInfo[]> {
+  const client = createClient<paths>({ baseUrl: serverUrl });
+  const response = await client.GET("/account/{account_id}/triggers", {
+    params: {
+      path: { account_id: accountId },
+    },
+  });
+
+  if (response.data === undefined) {
+    throw new Error(
+      `Failed to fetch triggers for account ${accountId}: HTTP ${response.response.status}`,
+    );
+  }
+
+  return response.data ?? [];
+}
+
+export async function getAccountTriggerHistory(
+  serverUrl: string,
+  accountId: number,
+  options: HistoryTriggerQuery,
+): Promise<TriggerHistoryPage> {
+  const client = createClient<paths>({ baseUrl: serverUrl });
+  const response = await client.GET("/account/{account_id}/triggers/history", {
+    params: {
+      path: { account_id: accountId },
+      query: {
+        since: options.since,
+        until: options.until,
+        pageSize: options.pageSize,
+        startInclusive: options.startInclusive,
+      },
+    },
+  });
+
+  if (!response.data) {
+    throw new Error(
+      `Failed to fetch trigger history for account ${accountId}: HTTP ${response.response.status}`,
+    );
+  }
+
+  return response.data;
+}

package/src/nord/client/Nord.ts

@@ -6,6 +6,8 @@ import * as proto from "../../gen/nord_pb";
 import type { paths } from "../../gen/openapi.ts";
 import {
   Account,
+  AccountPnlPage,
+  AccountPnlQuery,
   ActionResponse,
   AggregateMetrics,
   Info,
@@ -636,6 +638,31 @@ export class Nord {
     });
   }
 
+  /**
+   * Get profit and loss history for an account
+   *
+   * @param accountId - Account ID to query
+   * @param query - Optional time and pagination filters
+   * @returns Page of PnL entries ordered from latest to oldest
+   * @throws {NordError} If the request fails
+   */
+  public async getAccountPnl(
+    accountId: number,
+    query?: Partial<AccountPnlQuery>,
+  ): Promise<AccountPnlPage> {
+    return await this.GET("/account/{account_id}/pnl", {
+      params: {
+        path: { account_id: accountId },
+        query: {
+          since: query?.since,
+          until: query?.until,
+          startInclusive: query?.startInclusive,
+          pageSize: query?.pageSize,
+        },
+      },
+    });
+  }
+
   /**
    * Get market statistics (alias for marketsStats for backward compatibility)
    *