@n1xyz/nord-ts 0.1.0 → 0.1.2

package/dist/gen/openapi.d.ts

@@ -83,8 +83,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;
@@ -108,6 +112,14 @@ export interface paths {
                         "application/json": components["schemas"]["RangeTooLarge"];
                     };
                 };
+                501: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["NotImplemented"];
+                    };
+                };
             };
         };
         put?: never;
@@ -136,6 +148,14 @@ export interface paths {
                         "application/octet-stream": unknown;
                     };
                 };
+                413: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["PayloadTooLarge"];
+                    };
+                };
                 415: {
                     headers: {
                         /**
@@ -778,7 +798,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["TriggerInfo"][] | null;
+                        "application/json": components["schemas"]["AccountTriggerInfo"][] | null;
                     };
                 };
             };
@@ -975,6 +995,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;
@@ -1910,12 +2003,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;
@@ -1928,6 +2034,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";
@@ -2258,14 +2368,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
@@ -2333,6 +2452,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/dist/nord/api/actions.d.ts

@@ -1,6 +1,6 @@
 import Decimal from "decimal.js";
 import * as proto from "../../gen/nord_pb";
-import { FillMode, Side, QuoteSize } from "../../types";
+import { FillMode, Side, QuoteSize, TriggerKind } from "../../types";
 import { BigIntValue } from "../../utils";
 export declare function prepareAction(action: proto.Action, makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>): Promise<Uint8Array<ArrayBufferLike>>;
 export declare function createSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
@@ -68,6 +68,27 @@ export declare function transfer(serverUrl: string, signFn: (message: Uint8Array
     amount: bigint;
     accountCreated: boolean;
 }>;
+export declare 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;
+}>;
+export declare 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;
+}>;
 export type AtomicSubaction = {
     kind: "place";
     marketId: number;

package/dist/nord/api/actions.js

@@ -43,6 +43,8 @@ exports.withdraw = withdraw;
 exports.placeOrder = placeOrder;
 exports.cancelOrder = cancelOrder;
 exports.transfer = transfer;
+exports.addTrigger = addTrigger;
+exports.removeTrigger = removeTrigger;
 exports.atomic = atomic;
 const proto = __importStar(require("../../gen/nord_pb"));
 const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
@@ -66,7 +68,7 @@ function createAction(currentTimestamp, nonce, kind) {
         kind,
     });
 }
-async function sendAction(serverUrl, makeSignedMessage, action, actionErrorDesc) {
+async function sendAction(serverUrl, makeSignedMessage, action) {
     const body = await prepareAction(action, makeSignedMessage);
     // NOTE: restructure and reuse client as it is in Nord.ts
     const client = (0, openapi_fetch_1.default)({ baseUrl: serverUrl });
@@ -77,14 +79,18 @@ async function sendAction(serverUrl, makeSignedMessage, action, actionErrorDesc)
             },
         },
         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 = (0, utils_1.decodeLengthDelimited)(rawResp, proto.ReceiptSchema);
     if (resp.kind?.case === "err") {
-        throw new Error(`Could not ${actionErrorDesc}, reason: ${proto.Error[resp.kind.value]}`);
+        throw new Error(`Could not execute ${action.kind.case}, reason: ${proto.Error[resp.kind.value]}`);
     }
     return resp;
 }
@@ -92,12 +98,17 @@ async function sendAction(serverUrl, makeSignedMessage, action, actionErrorDesc)
 // `makeSignedMessage` must include the original message and signature.
 async function prepareAction(action, makeSignedMessage) {
     const encoded = (0, wire_1.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) {
-        throw new Error(`Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_HTTP_REQUEST_BODY_SIZE} bytes).`);
+    // 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_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;
 }
 async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
@@ -119,7 +130,7 @@ async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, p
             expiryTimestamp: expiry,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action, "create a new session");
+    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action);
     if (resp.kind?.case === "createSessionResult") {
         return {
             actionId: resp.actionId,
@@ -137,7 +148,7 @@ async function revokeSession(serverUrl, walletSignFn, currentTimestamp, nonce, p
             sessionId: BigInt(params.sessionId),
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action, "revoke session");
+    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action);
     return { actionId: resp.actionId };
 }
 async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
@@ -153,7 +164,7 @@ async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
             amount,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "withdraw");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "withdrawResult") {
         return { actionId: resp.actionId, ...resp.kind.value };
     }
@@ -165,7 +176,7 @@ async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
     const price = (0, utils_1.toScaledU64)(params.price ?? 0, params.priceDecimals);
     const size = (0, utils_1.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;
     (0, utils_1.assert)(price > 0n || size > 0n || scaledQuote !== undefined, "OrderLimit must include at least one of: size, price, or quoteSize");
     const action = createAction(currentTimestamp, nonce, {
@@ -191,7 +202,7 @@ async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
             delegatorAccountId: params.liquidateeId,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "place order");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "placeOrderResult") {
         return {
             actionId: resp.actionId,
@@ -213,7 +224,7 @@ async function cancelOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
             delegatorAccountId: params.liquidateeId,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "cancel order");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "cancelOrderResult") {
         return {
             actionId: resp.actionId,
@@ -236,7 +247,7 @@ async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
             amount: (0, utils_1.toScaledU64)(params.amount ?? 0, params.tokenDecimals),
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "transfer");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "transferred") {
         return {
             actionId: resp.actionId,
@@ -251,6 +262,63 @@ async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
         throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
+async function addTrigger(serverUrl, signFn, currentTimestamp, nonce, params) {
+    const triggerPrice = (0, utils_1.toScaledU64)(params.triggerPrice, params.priceDecimals);
+    (0, utils_1.assert)(triggerPrice > 0n, "Trigger price must be positive");
+    const limitPrice = params.limitPrice === undefined
+        ? undefined
+        : (0, utils_1.toScaledU64)(params.limitPrice, params.priceDecimals);
+    if (limitPrice !== undefined) {
+        (0, utils_1.assert)(limitPrice > 0n, "Limit price must be positive");
+    }
+    const key = (0, protobuf_1.create)(proto.TriggerKeySchema, {
+        kind: params.kind === types_1.TriggerKind.StopLoss
+            ? proto.TriggerKind.STOP_LOSS
+            : proto.TriggerKind.TAKE_PROFIT,
+        side: params.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
+    });
+    const prices = (0, protobuf_1.create)(proto.Action_TriggerPricesSchema, {
+        triggerPrice,
+        limitPrice,
+    });
+    const action = createAction(currentTimestamp, nonce, {
+        case: "addTrigger",
+        value: (0, protobuf_1.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}`);
+}
+async function removeTrigger(serverUrl, signFn, currentTimestamp, nonce, params) {
+    const key = (0, protobuf_1.create)(proto.TriggerKeySchema, {
+        kind: params.kind === types_1.TriggerKind.StopLoss
+            ? proto.TriggerKind.STOP_LOSS
+            : proto.TriggerKind.TAKE_PROFIT,
+        side: params.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
+    });
+    const action = createAction(currentTimestamp, nonce, {
+        case: "removeTrigger",
+        value: (0, protobuf_1.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}`);
+}
 async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
     (0, utils_1.assert)(params.actions.length > 0 && params.actions.length <= 4, "Atomic action must contain between 1 and 4 sub-actions");
     const subactions = params.actions.map((a) => {
@@ -258,7 +326,7 @@ async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
             const price = (0, utils_1.toScaledU64)(a.price ?? 0, a.priceDecimals);
             const size = (0, utils_1.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)
             (0, utils_1.assert)(price > 0n || size > 0n || scaledQuote !== undefined, "OrderLimit must include at least one of: size, price, or quoteSize");
@@ -300,7 +368,7 @@ async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
             actions: subactions,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "execute atomic action");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "atomic") {
         return {
             actionId: resp.actionId,

package/dist/nord/api/triggers.d.ts

@@ -0,0 +1,7 @@
+import { 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 declare function getAccountTriggers(serverUrl: string, accountId: number): Promise<AccountTriggerInfo[]>;
+export declare function getAccountTriggerHistory(serverUrl: string, accountId: number, options: HistoryTriggerQuery): Promise<TriggerHistoryPage>;

package/dist/nord/api/triggers.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountTriggers = getAccountTriggers;
+exports.getAccountTriggerHistory = getAccountTriggerHistory;
+const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
+async function getAccountTriggers(serverUrl, accountId) {
+    const client = (0, openapi_fetch_1.default)({ 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 ?? [];
+}
+async function getAccountTriggerHistory(serverUrl, accountId, options) {
+    const client = (0, openapi_fetch_1.default)({ 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/dist/nord/client/Nord.d.ts

@@ -1,7 +1,7 @@
 import { ProtonClient } from "@n1xyz/proton";
 import { PublicKey } from "@solana/web3.js";
 import { EventEmitter } from "events";
-import { Account, ActionResponse, AggregateMetrics, Info, Market, MarketStats, NordConfig, OrderbookQuery, OrderbookResponse, PeakTpsPeriodUnit, Token, TradesResponse, User } from "../../types";
+import { Account, AccountPnlPage, AccountPnlQuery, ActionResponse, AggregateMetrics, Info, Market, MarketStats, NordConfig, OrderbookQuery, OrderbookResponse, PeakTpsPeriodUnit, Token, TradesResponse, User } from "../../types";
 import { NordWebSocketClient } from "../../websocket/index";
 import { OrderbookSubscription, TradeSubscription } from "../models/Subscriber";
 /**
@@ -263,6 +263,15 @@ export declare class Nord {
      * @throws {NordError} If the request fails
      */
     getAccount(accountId: number): Promise<Account>;
+    /**
+     * 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
+     */
+    getAccountPnl(accountId: number, query?: Partial<AccountPnlQuery>): Promise<AccountPnlPage>;
     /**
      * Get market statistics (alias for marketsStats for backward compatibility)
      *

package/dist/nord/client/Nord.js

@@ -502,6 +502,27 @@ 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
+     */
+    async getAccountPnl(accountId, query) {
+        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)
      *

package/dist/nord/client/NordUser.d.ts

@@ -1,8 +1,9 @@
 import { Connection, PublicKey, Transaction, SendOptions } from "@solana/web3.js";
 import Decimal from "decimal.js";
-import { FillMode, Side, SPLTokenInfo, QuoteSize } from "../../types";
+import { FillMode, Side, SPLTokenInfo, QuoteSize, TriggerKind } from "../../types";
 import * as proto from "../../gen/nord_pb";
 import { BigIntValue } from "../../utils";
+import type { AccountTriggerInfo, TriggerHistoryPage, HistoryTriggerQuery } from "../api/triggers";
 import { Nord } from "./Nord";
 /**
  * Parameters for creating a NordUser instance
@@ -48,6 +49,20 @@ export interface PlaceOrderParams {
     /** Account ID to place the order from */
     accountId?: number;
 }
+export interface AddTriggerParams {
+    marketId: number;
+    side: Side;
+    kind: TriggerKind;
+    triggerPrice: Decimal.Value;
+    limitPrice?: Decimal.Value;
+    accountId?: number;
+}
+export interface RemoveTriggerParams {
+    marketId: number;
+    side: Side;
+    kind: TriggerKind;
+    accountId?: number;
+}
 /**
  * Parameters for transferring tokens between accounts
  */
@@ -288,6 +303,44 @@ export declare class NordUser {
         orderId: bigint;
         accountId: number;
     }>;
+    /**
+     * Add a trigger for the current session
+     *
+     * @param params - Trigger parameters including market, side, and prices
+     * @returns Object containing the actionId of the submitted trigger
+     * @throws {NordError} If the operation fails
+     */
+    addTrigger(params: AddTriggerParams): Promise<{
+        actionId: bigint;
+    }>;
+    /**
+     * Remove a trigger for the current session
+     *
+     * @param params - Trigger parameters identifying the trigger to remove
+     * @returns Object containing the actionId of the removal action
+     * @throws {NordError} If the operation fails
+     */
+    removeTrigger(params: RemoveTriggerParams): Promise<{
+        actionId: bigint;
+    }>;
+    /**
+     * 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.
+     */
+    getAccountTriggers(params?: {
+        accountId?: number;
+    }): Promise<AccountTriggerInfo[]>;
+    /**
+     * 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.
+     */
+    getAccountTriggerHistory(params: HistoryTriggerQuery & {
+        accountId?: number;
+    }): Promise<TriggerHistoryPage>;
     /**
      * Transfer tokens to another account
      *