@n1xyz/nord-ts 0.1.1 → 0.1.3

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;
@@ -786,7 +798,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["TriggerInfo"][] | null;
+                        "application/json": components["schemas"]["AccountTriggerInfo"][] | null;
                     };
                 };
             };
@@ -983,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;
@@ -1923,11 +2008,20 @@ export interface components {
             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;
@@ -1940,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";
@@ -2270,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
@@ -2345,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"));
@@ -174,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, {
@@ -260,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) => {
@@ -267,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");

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
      *

package/dist/nord/client/NordUser.js

@@ -42,6 +42,7 @@ ed.etc.sha512Sync = sha512_1.sha512;
 const proton_1 = require("@n1xyz/proton");
 const utils_1 = require("../../utils");
 const actions_1 = require("../api/actions");
+const triggers_1 = require("../api/triggers");
 const NordError_1 = require("../utils/NordError");
 /**
  * User class for interacting with the Nord protocol
@@ -460,6 +461,102 @@ class NordUser {
             });
         }
     }
+    /**
+     * 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
+     */
+    async addTrigger(params) {
+        try {
+            this.checkSessionValidity();
+            const market = (0, utils_1.findMarket)(this.nord.markets, params.marketId);
+            if (!market) {
+                throw new NordError_1.NordError(`Market with ID ${params.marketId} not found`);
+            }
+            const result = await (0, actions_1.addTrigger)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                marketId: params.marketId,
+                side: params.side,
+                kind: params.kind,
+                priceDecimals: market.priceDecimals,
+                triggerPrice: params.triggerPrice,
+                limitPrice: params.limitPrice,
+                accountId: params.accountId,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to add trigger", { cause: error });
+        }
+    }
+    /**
+     * 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
+     */
+    async removeTrigger(params) {
+        try {
+            this.checkSessionValidity();
+            const market = (0, utils_1.findMarket)(this.nord.markets, params.marketId);
+            if (!market) {
+                throw new NordError_1.NordError(`Market with ID ${params.marketId} not found`);
+            }
+            const result = await (0, actions_1.removeTrigger)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                marketId: params.marketId,
+                side: params.side,
+                kind: params.kind,
+                accountId: params.accountId,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new NordError_1.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) {
+        const accountId = params?.accountId ?? this.accountIds?.[0];
+        if (accountId == null) {
+            throw new NordError_1.NordError("Account ID is undefined. Make sure to call updateAccountId() before requesting triggers.");
+        }
+        try {
+            return await (0, triggers_1.getAccountTriggers)(this.nord.webServerUrl, accountId);
+        }
+        catch (error) {
+            throw new NordError_1.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) {
+        const { accountId: providedAccountId, ...query } = params;
+        const accountId = providedAccountId ?? this.accountIds?.[0];
+        if (accountId == null) {
+            throw new NordError_1.NordError("Account ID is undefined. Make sure to call updateAccountId() before requesting trigger history.");
+        }
+        try {
+            return await (0, triggers_1.getAccountTriggerHistory)(this.nord.webServerUrl, accountId, query);
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to fetch account trigger history", {
+                cause: error,
+            });
+        }
+    }
     /**
      * Transfer tokens to another account
      *

package/dist/types.d.ts

@@ -72,6 +72,9 @@ export type SideFromApi = components["schemas"]["Side"];
 export type FillModeFromApi = components["schemas"]["FillMode"];
 export type PlacementOrigin = components["schemas"]["PlacementOrigin"];
 export type FinalizationReason = components["schemas"]["FinalizationReason"];
+export type AccountPnlQuery = components["schemas"]["AccountPnlQuery"];
+export type AccountPnl = components["schemas"]["AccountPnl"];
+export type AccountPnlPage = components["schemas"]["PageResult_for_uint64_and_AccountPnl"];
 /**
  * Configuration options for the Nord client
  */
@@ -94,8 +97,8 @@ export declare enum KeyType {
     Bls12_381 = 2
 }
 export declare enum Side {
-    Ask = 0,
-    Bid = 1
+    Ask = "ask",
+    Bid = "bid"
 }
 export declare enum FillMode {
     Limit = 0,
@@ -103,6 +106,16 @@ export declare enum FillMode {
     ImmediateOrCancel = 2,
     FillOrKill = 3
 }
+export declare enum TriggerKind {
+    StopLoss = 0,
+    TakeProfit = 1
+}
+export declare enum TriggerStatus {
+    Active = 0,
+    Success = 1,
+    Cancel = 2,
+    Remove = 4
+}
 export interface SubscriberConfig {
     streamURL: string;
     maxBufferLen?: number;
@@ -255,7 +268,7 @@ export declare class QuoteSize {
     size: Decimal;
     constructor(quotePrice: Decimal.Value, quoteSize: Decimal.Value);
     value(): Decimal;
-    toScaledU64(marketPriceDecimals: number, marketSizeDecimals: number): {
+    toWire(marketPriceDecimals: number, marketSizeDecimals: number): {
         price: bigint;
         size: bigint;
     };