@n1xyz/nord-ts 0.1.6 → 0.1.7

package/dist/actions.d.ts

@@ -0,0 +1,57 @@
+import Decimal from "decimal.js";
+import * as proto from "./gen/nord_pb";
+import { paths } from "./gen/openapi";
+import { Client } from "openapi-fetch";
+import { FillMode, Side, QuoteSize } from "./types";
+import { BigIntValue } from "./utils";
+import { PublicKey, Transaction } from "@solana/web3.js";
+type ReceiptKind = NonNullable<proto.Receipt["kind"]>;
+type ExtractReceiptKind<K extends ReceiptKind["case"]> = Extract<ReceiptKind, {
+    case: K;
+}>;
+export declare function formatReceiptError(receipt: proto.Receipt): string;
+export declare function expectReceiptKind<K extends ReceiptKind["case"]>(receipt: proto.Receipt, expected: K, action: string): asserts receipt is proto.Receipt & {
+    kind: ExtractReceiptKind<K>;
+};
+export declare function createAction(currentTimestamp: bigint, nonce: number, kind: proto.Action["kind"]): proto.Action;
+export declare function sendAction(client: Client<paths>, makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>, action: proto.Action): Promise<proto.Receipt>;
+export declare function prepareAction(action: proto.Action, makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>): Promise<Uint8Array<ArrayBufferLike>>;
+export declare function createSession(client: Client<paths>, signTransaction: (tx: Transaction) => Promise<Transaction>, currentTimestamp: bigint, nonce: number, params: {
+    userPubkey: PublicKey;
+    sessionPubkey: PublicKey;
+    expiryTimestamp?: bigint;
+}): Promise<{
+    actionId: bigint;
+    sessionId: bigint;
+}>;
+export declare function revokeSession(client: Client<paths>, signTransaction: (tx: Transaction) => Promise<Transaction>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    userPubkey: PublicKey;
+}): Promise<{
+    actionId: bigint;
+}>;
+export type AtomicSubaction = {
+    kind: "place";
+    marketId: number;
+    side: Side;
+    fillMode: FillMode;
+    isReduceOnly: boolean;
+    sizeDecimals: number;
+    priceDecimals: number;
+    size?: Decimal.Value;
+    price?: Decimal.Value;
+    quoteSize?: QuoteSize;
+    clientOrderId?: BigIntValue;
+} | {
+    kind: "cancel";
+    orderId: BigIntValue;
+};
+export declare function atomic(client: Client<paths>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    accountId?: number;
+    actions: AtomicSubaction[];
+}): Promise<{
+    actionId: bigint;
+    results: proto.Receipt_AtomicSubactionResultKind[];
+}>;
+export {};

package/dist/actions.js

@@ -0,0 +1,229 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatReceiptError = formatReceiptError;
+exports.expectReceiptKind = expectReceiptKind;
+exports.createAction = createAction;
+exports.sendAction = sendAction;
+exports.prepareAction = prepareAction;
+exports.createSession = createSession;
+exports.revokeSession = revokeSession;
+exports.atomic = atomic;
+const proto = __importStar(require("./gen/nord_pb"));
+const protobuf_1 = require("@bufbuild/protobuf");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const wire_1 = require("@bufbuild/protobuf/wire");
+const error_1 = require("./error");
+function formatReceiptError(receipt) {
+    if (receipt.kind?.case === "err") {
+        const err = receipt.kind.value;
+        return proto.Error[err] ?? err.toString();
+    }
+    return receipt.kind?.case ?? "unknown";
+}
+function expectReceiptKind(receipt, expected, action) {
+    if (receipt.kind?.case !== expected) {
+        const label = formatReceiptError(receipt);
+        throw new error_1.NordError(`Failed to ${action}: ${label}`);
+    }
+}
+async function sessionSign(signFn, message) {
+    const signature = await signFn(message);
+    return new Uint8Array([...message, ...signature]);
+}
+// Helper to create an action with common fields
+function createAction(currentTimestamp, nonce, kind) {
+    return (0, protobuf_1.create)(proto.ActionSchema, {
+        currentTimestamp,
+        nonce,
+        kind,
+    });
+}
+async function sendAction(client, makeSignedMessage, action) {
+    const body = await prepareAction(action, makeSignedMessage);
+    const response = await client.POST("/action", {
+        params: {
+            header: {
+                "content-type": "application/octet-stream",
+            },
+        },
+        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 ${action.kind.case}, HTTP status ${JSON.stringify(response.error)}`);
+    }
+    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 execute ${action.kind.case}, reason: ${proto.Error[resp.kind.value]}`);
+    }
+    return resp;
+}
+// Given action and signature function, prepare the signed message to send to server as `body`.
+// `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_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(client, signTransaction, currentTimestamp, nonce, params) {
+    let expiry = 0n;
+    if (params.expiryTimestamp !== undefined) {
+        expiry = params.expiryTimestamp;
+        (0, utils_1.assert)(expiry > currentTimestamp, "Cannot set expiry timestamp in the past");
+    }
+    else {
+        expiry = currentTimestamp + utils_1.SESSION_TTL;
+    }
+    const action = createAction(currentTimestamp, nonce, {
+        case: "createSession",
+        value: (0, protobuf_1.create)(proto.Action_CreateSessionSchema, {
+            userPubkey: params.userPubkey.toBytes(),
+            blstPubkey: params.sessionPubkey.toBytes(),
+            expiryTimestamp: expiry,
+        }),
+    });
+    const resp = await sendAction(client, async (payload) => {
+        return new Uint8Array([
+            ...payload,
+            ...(await (0, utils_1.signUserPayload)({
+                payload,
+                user: params.userPubkey,
+                signTransaction,
+            })),
+        ]);
+    }, action);
+    if (resp.kind?.case === "createSessionResult") {
+        return {
+            actionId: resp.actionId,
+            sessionId: resp.kind.value.sessionId,
+        };
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
+    }
+}
+async function revokeSession(client, signTransaction, currentTimestamp, nonce, params) {
+    const action = createAction(currentTimestamp, nonce, {
+        case: "revokeSession",
+        value: (0, protobuf_1.create)(proto.Action_RevokeSessionSchema, {
+            sessionId: BigInt(params.sessionId),
+        }),
+    });
+    const resp = await sendAction(client, async (payload) => {
+        return new Uint8Array([
+            ...payload,
+            ...(await (0, utils_1.signUserPayload)({
+                payload,
+                user: params.userPubkey,
+                signTransaction,
+            })),
+        ]);
+    }, action);
+    return { actionId: resp.actionId };
+}
+async function atomic(client, 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) => {
+        if (a.kind === "place") {
+            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.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");
+            const tradeOrPlace = (0, protobuf_1.create)(proto.TradeOrPlaceSchema, {
+                marketId: a.marketId,
+                orderType: (0, protobuf_1.create)(proto.OrderTypeSchema, {
+                    side: a.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
+                    fillMode: (0, types_1.fillModeToProtoFillMode)(a.fillMode),
+                    isReduceOnly: a.isReduceOnly,
+                }),
+                limit: (0, protobuf_1.create)(proto.OrderLimitSchema, {
+                    price,
+                    size,
+                    quoteSize: scaledQuote === undefined
+                        ? undefined
+                        : (0, protobuf_1.create)(proto.QuoteSizeSchema, {
+                            size: scaledQuote.size,
+                            price: scaledQuote.price,
+                        }),
+                }),
+                clientOrderId: a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
+            });
+            return (0, protobuf_1.create)(proto.AtomicSubactionKindSchema, {
+                inner: { case: "tradeOrPlace", value: tradeOrPlace },
+            });
+        }
+        return (0, protobuf_1.create)(proto.AtomicSubactionKindSchema, {
+            inner: {
+                case: "cancelOrder",
+                value: (0, protobuf_1.create)(proto.CancelOrderSchema, { orderId: BigInt(a.orderId) }),
+            },
+        });
+    });
+    const action = createAction(currentTimestamp, nonce, {
+        case: "atomic",
+        value: (0, protobuf_1.create)(proto.AtomicSchema, {
+            sessionId: BigInt(params.sessionId),
+            accountId: params.accountId, // optional
+            actions: subactions,
+        }),
+    });
+    const resp = await sendAction(client, (m) => sessionSign(signFn, m), action);
+    if (resp.kind?.case === "atomic") {
+        return {
+            actionId: resp.actionId,
+            results: resp.kind.value.results,
+        };
+    }
+    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
+}

package/dist/client/Nord.d.ts

@@ -0,0 +1,379 @@
+import { ProtonClient } from "@n1xyz/proton";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { EventEmitter } from "events";
+import { Client } from "openapi-fetch";
+import type { paths } from "../gen/openapi.ts";
+import { Account, AccountPnlPage, AccountPnlQuery, ActionResponse, MarketsInfo, Market, MarketStats, NordConfig, OrderbookQuery, OrderbookResponse, FeeTierConfig, Token, TradesResponse, User, AccountTriggerInfo, HistoryTriggerQuery, TriggerHistoryPage, FeeTierId, AccountFeeTierPage, PageResultStringOrderInfo, PageResultStringTrade, OrderInfoFromApi, TokenStats, FillRole } from "../types";
+import { NordWebSocketClient } from "../websocket/index";
+import { OrderbookSubscription, TradeSubscription } from "../websocket/Subscriber";
+/**
+ * User subscription interface
+ */
+export interface UserSubscription extends EventEmitter {
+    close: () => void;
+}
+/**
+ * Main Nord client class for interacting with the Nord API
+ */
+export declare class Nord {
+    /** Base URL for the Nord web server */
+    readonly webServerUrl: string;
+    /** Solana RPC URL */
+    readonly solanaConnection: Connection;
+    /** Available markets */
+    markets: Market[];
+    /** Available tokens */
+    tokens: Token[];
+    /** Map of symbol to market_id */
+    private symbolToMarketId;
+    /** Proton client for proton related operations */
+    protonClient: ProtonClient;
+    /** HTTP client for Nord operations */
+    readonly httpClient: Client<paths>;
+    /**
+     * Create a new Nord client
+     *
+     * @param config - Configuration options for the Nord client
+     * @param config.webServerUrl - Base URL for the Nord web server
+     * @param config.solanaUrl - Solana cluster URL
+     * @throws {Error} If required configuration is missing
+     */
+    private constructor();
+    /**
+     * Create a WebSocket client with specific subscriptions
+     *
+     * @param trades - Market symbols to subscribe to for trade updates
+     * @param deltas - Market symbols to subscribe to for orderbook delta updates
+     * @param accounts - Account IDs to subscribe to for account updates
+     * @returns A new WebSocket client with the requested subscriptions
+     * @throws {NordError} If invalid subscription options are provided
+     *
+     * @example
+     * // Create a client for trades and deltas from one market and an account
+     * const wsClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC"],
+     *   deltas: ["BTCUSDC"],
+     *   accounts: [123]
+     * });
+     *
+     * @example
+     * // Create a client for trades from multiple markets
+     * const tradesClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC", "ETHUSDC"]
+     * });
+     */
+    createWebSocketClient({ trades, deltas, accounts, }: Readonly<{
+        trades?: string[];
+        deltas?: string[];
+        accounts?: number[];
+    }>): NordWebSocketClient;
+    private GET;
+    /**
+     * Get the current timestamp from the Nord server
+     *
+     * @returns Current timestamp as a bigint
+     * @throws {NordError} If the request fails
+     */
+    getTimestamp(): Promise<bigint>;
+    /**
+     * Get the last event nonce from the Nord server
+     *
+     * @returns Next action nonce
+     * @throws {NordError} If the request fails
+     */
+    getActionNonce(): Promise<number>;
+    /**
+     * Get the admin list from the Nord server
+     *
+     * @returns List of admin registration keys paired with their ACL role mask
+     * @throws {NordError} If the request fails
+     */
+    getAdminList(): Promise<Array<[string, number]>>;
+    /**
+     * Fetch information about Nord markets and tokens
+     *
+     * @throws {NordError} If the request fails
+     */
+    fetchNordInfo(): Promise<void>;
+    /** @deprecated use Nord.new */
+    static initNord(x: Readonly<NordConfig>): Promise<Nord>;
+    /**
+     * Initialize a new Nord client
+     *
+     * @param nordConfig - Configuration options for the Nord client
+     * @param nordConfig.webServerUrl - Base URL for the Nord web server
+     * @param nordConfig.app - App address
+     * @param nordConfig.solanaUrl - Solana cluster URL
+     * @returns Initialized Nord client
+     * @throws {NordError} If initialization fails
+     */
+    static new({ app, solanaConnection, webServerUrl, protonUrl, }: Readonly<NordConfig>): Promise<Nord>;
+    /**
+     * Initialize the Nord client
+     * @private
+     */
+    private init;
+    /**
+     * Query a specific action
+     *
+     * @param actionId - Action identifier to fetch
+     * @returns Action response
+     * @throws {NordError} If the request fails
+     */
+    queryAction({ actionId, }: Readonly<{
+        actionId: number;
+    }>): Promise<ActionResponse | null>;
+    /**
+     * Query recent actions
+     *
+     * @param from - Starting action index (inclusive)
+     * @param to - Ending action index (inclusive)
+     * @returns Actions response
+     * @throws {NordError} If the request fails
+     */
+    queryRecentActions({ from, to, }: Readonly<{
+        from: number;
+        to: number;
+    }>): Promise<ActionResponse[]>;
+    /**
+     * Get the last action ID
+     *
+     * @returns Last action ID
+     * @throws {NordError} If the request fails
+     */
+    getLastActionId(): Promise<number>;
+    /**
+     * Subscribe to orderbook updates for a market
+     *
+     * @param symbol - Market symbol
+     * @returns Orderbook subscription
+     * @throws {NordError} If symbol is invalid
+     */
+    subscribeOrderbook(symbol: string): OrderbookSubscription;
+    /**
+     * Subscribe to trade updates for a market
+     *
+     * @param symbol - Market symbol
+     * @returns Trade subscription
+     * @throws {NordError} If symbol is invalid
+     */
+    subscribeTrades(symbol: string): TradeSubscription;
+    /**
+     * Subscribe to account updates
+     *
+     * @param accountId - Account ID to subscribe to
+     * @returns User subscription
+     * @throws {NordError} If accountId is invalid
+     */
+    subscribeAccount(accountId: number): UserSubscription;
+    /**
+     * Get trades for a market
+     *
+     * @param marketId - Market identifier to filter by
+     * @param takerId - Taker account identifier
+     * @param makerId - Maker account identifier
+     * @param takerSide - Side executed by the taker
+     * @param pageSize - Maximum number of trades to return
+     * @param since - RFC3339 timestamp to start from (inclusive)
+     * @param until - RFC3339 timestamp to end at (exclusive)
+     * @param pageId - Pagination cursor returned from a prior call
+     * @returns Trades response
+     * @throws {NordError} If the request fails
+     */
+    getTrades({ marketId, takerId, makerId, takerSide, pageSize, since, until, startInclusive, }: Readonly<{
+        marketId?: number;
+        takerId?: number;
+        makerId?: number;
+        takerSide?: "bid" | "ask";
+        pageSize?: number;
+        since?: string;
+        until?: string;
+        startInclusive?: string;
+    }>): Promise<TradesResponse>;
+    /**
+     * Get user account IDs
+     *
+     * @param pubkey - User public key to query
+     * @returns User account IDs response
+     * @throws {NordError} If the request fails
+     */
+    getUser({ pubkey, }: Readonly<{
+        pubkey: string | PublicKey;
+    }>): Promise<User | null>;
+    /**
+     * Get orderbook for a market
+     *
+     * @param symbol - Market symbol to resolve into an id
+     * @param marketId - Market identifier
+     * @returns Orderbook response
+     * @throws {NordError} If the request fails or if the market symbol is unknown
+     * @remarks It's recommended to initialize the Nord client using the static `initNord` method
+     * to ensure market information is properly loaded before calling this method.
+     */
+    getOrderbook({ symbol, marketId, }: OrderbookQuery): Promise<OrderbookResponse>;
+    /**
+     * Get information about the Nord server
+     *
+     * @returns Information about markets and tokens
+     * @throws {NordError} If the request fails
+     */
+    getInfo(): Promise<MarketsInfo>;
+    /**
+     * Fetch the current fee tier brackets configured on Nord.
+     *
+     * @returns Array of fee tier identifiers paired with their configuration
+     * @throws {NordError} If the request fails
+     */
+    getFeeBrackets(): Promise<Array<[FeeTierId, FeeTierConfig]>>;
+    /**
+     * Retrieve the fee tier assigned to a specific account.
+     *
+     * @param accountId - Account identifier to query
+     * @returns Fee tier details for the requested account
+     * @throws {NordError} If the request fails
+     */
+    getAccountFeeTier(accountId: number): Promise<FeeTierId>;
+    /**
+     * Get account information
+     *
+     * @param accountId - Account ID to get information for
+     * @returns Account information
+     * @throws {NordError} If the request fails
+     */
+    getAccount(accountId: number): Promise<Account>;
+    /**
+     * Get the public key associated with an account id.
+     *
+     * @param accountId - Account id to query
+     * @returns Base58-encoded account public key
+     * @throws {NordError} If the request fails
+     */
+    getAccountPubkey(accountId: number): Promise<string>;
+    /**
+     * Get the withdrawal fee charged for an account.
+     *
+     * @param accountId - Account id to query
+     * @returns Withdrawal fee quoted in quote token units
+     * @throws {NordError} If the request fails
+     */
+    getAccountWithdrawalFee(accountId: number): Promise<number>;
+    /**
+     * Get open orders for an account.
+     *
+     * @param accountId - Account id to query
+     * @param startInclusive - Pagination cursor (client order id) to resume from
+     * @param pageSize - Maximum number of orders to return
+     * @returns Page of orders keyed by client order id
+     * @throws {NordError} If the request fails
+     */
+    getAccountOrders(accountId: number, { startInclusive, pageSize, }?: Readonly<{
+        startInclusive?: string | null;
+        pageSize?: number | null;
+    }>): Promise<PageResultStringOrderInfo>;
+    /**
+     * List account fee tiers with pagination support.
+     *
+     * @param startInclusive - Account id cursor to resume from
+     * @param pageSize - Maximum number of entries to return
+     */
+    getAccountsFeeTiers({ startInclusive, pageSize, }?: Readonly<{
+        startInclusive?: number | null;
+        pageSize?: number | null;
+    }>): Promise<AccountFeeTierPage>;
+    /**
+     * Get profit and loss history for an account
+     *
+     * @param accountId - Account ID to query
+     * @param since - RFC3339 timestamp to start from (inclusive)
+     * @param until - RFC3339 timestamp to end at (exclusive)
+     * @param startInclusive - Pagination cursor to resume from
+     * @param pageSize - Maximum number of entries to return
+     * @returns Page of PnL entries ordered from latest to oldest
+     * @throws {NordError} If the request fails
+     */
+    getAccountPnl(accountId: number, { since, until, startInclusive, pageSize, }?: Readonly<Partial<AccountPnlQuery>>): Promise<AccountPnlPage>;
+    /**
+     * Get market statistics (alias for marketsStats for backward compatibility)
+     *
+     *
+     * @param marketId - Market identifier
+     *
+     * @returns Market statistics response
+     */
+    getMarketStats({ marketId, }: Readonly<{
+        marketId: number;
+    }>): Promise<MarketStats>;
+    /**
+     * Fetch the per-market fee quote for an account.
+     *
+     * @param marketId - Market identifier
+     * @param feeKind - Fill role (maker/taker) to quote
+     * @param accountId - Account identifier to quote
+     * @returns Fee in quote token units (negative means fee is charged)
+     * @throws {NordError} If the request fails
+     */
+    getMarketFee({ marketId, feeKind, accountId, }: Readonly<{
+        marketId: number;
+        feeKind: FillRole;
+        accountId: number;
+    }>): Promise<number>;
+    /**
+     * Fetch token statistics such as index price and oracle metadata.
+     *
+     * @param tokenId - Token identifier
+     * @returns Token stats
+     * @throws {NordError} If the request fails
+     */
+    getTokenStats(tokenId: number): Promise<TokenStats>;
+    /**
+     * Get order summary by order id.
+     *
+     * @param orderId - Order identifier
+     * @returns Order information
+     * @throws {NordError} If the request fails
+     */
+    getOrder(orderId: string): Promise<OrderInfoFromApi>;
+    /**
+     * Get trade history for a specific order.
+     *
+     * @param orderId - Order identifier
+     * @param startInclusive - Trade pagination cursor
+     * @param pageSize - Maximum number of trades to return
+     * @returns Page of trades associated with the order
+     * @throws {NordError} If the request fails
+     */
+    getOrderTrades(orderId: string, { startInclusive, pageSize, }?: Readonly<{
+        startInclusive?: string | null;
+        pageSize?: number | null;
+    }>): Promise<PageResultStringTrade>;
+    /**
+     * Check if an account exists for the given address
+     *
+     * @param address - The public key address to check
+     * @returns True if the account exists, false otherwise
+     * @deprecated use getUser instead
+     */
+    accountExists(pubkey: string | PublicKey): Promise<boolean>;
+    /**
+     * Fetch active triggers for an account.
+     *
+     * @param accountId - Account identifier owning the triggers
+     * @throws {NordError} If no account can be resolved or the request fails.
+     */
+    getAccountTriggers({ accountId, }?: Readonly<{
+        accountId?: number;
+    }>): Promise<AccountTriggerInfo[]>;
+    /**
+     * Fetch trigger history for an account.
+     *
+     * @param accountId - Account identifier owning the triggers
+     * @param since - RFC3339 timestamp to start from (inclusive)
+     * @param until - RFC3339 timestamp to end at (exclusive)
+     * @param pageSize - Maximum number of entries to return
+     * @param startInclusive - Pagination cursor to resume from
+     * @throws {NordError} If no account can be resolved or the request fails.
+     */
+    getAccountTriggerHistory({ accountId, since, until, pageSize, startInclusive, }: Readonly<HistoryTriggerQuery & {
+        accountId?: number;
+    }>): Promise<TriggerHistoryPage>;
+}