@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/nord/Subscriber.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscriber = void 0;
+const ws_1 = __importDefault(require("ws"));
+const utils_1 = require("../utils");
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+class Subscriber {
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config) {
+        this.streamURL = config.streamURL;
+        this.buffer = [];
+        this.maxBufferLen = config.maxBufferLen ?? utils_1.MAX_BUFFER_LEN;
+    }
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe() {
+        const ws = new ws_1.default(this.streamURL);
+    }
+}
+exports.Subscriber = Subscriber;

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

@@ -0,0 +1,101 @@
+import Decimal from 'decimal.js';
+import { FillMode, Side } from '../../types';
+import { BigIntValue } from '../../utils';
+declare function createSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    userPubkey: Uint8Array;
+    sessionPubkey: Uint8Array;
+    expiryTimestamp?: bigint;
+}): Promise<bigint>;
+export declare function createSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    userPubkey: Uint8Array;
+    sessionPubkey: Uint8Array;
+    expiryTimestamp?: bigint;
+}): Promise<bigint>;
+declare function revokeSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+}): Promise<void>;
+export declare function revokeSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+}): Promise<void>;
+declare function withdrawImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sizeDecimals: number;
+    sessionId: BigIntValue;
+    tokenId: number;
+    amount: Decimal.Value;
+}): Promise<void>;
+export declare function withdraw(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sizeDecimals: number;
+    sessionId: BigIntValue;
+    tokenId: number;
+    amount: number;
+}): Promise<void>;
+declare function placeOrderImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    senderId?: number;
+    liquidateeId?: number;
+    sizeDecimals: number;
+    priceDecimals: number;
+    marketId: number;
+    side: Side;
+    fillMode: FillMode;
+    isReduceOnly: boolean;
+    size?: Decimal.Value;
+    price?: Decimal.Value;
+    quoteSize?: Decimal.Value;
+    clientOrderId?: BigIntValue;
+}): Promise<bigint | undefined>;
+export declare function placeOrder(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    senderId?: number;
+    sizeDecimals: number;
+    priceDecimals: number;
+    marketId: number;
+    side: Side;
+    fillMode: FillMode;
+    isReduceOnly: boolean;
+    size?: Decimal.Value;
+    price?: Decimal.Value;
+    quoteSize?: Decimal.Value;
+    liquidateeId?: number;
+    clientOrderId?: BigIntValue;
+}): Promise<bigint | undefined>;
+declare function cancelOrderImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    senderId?: number;
+    orderId: BigIntValue;
+    liquidateeId?: number;
+}): Promise<bigint>;
+export declare function cancelOrder(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    senderId?: number;
+    orderId: BigIntValue;
+    liquidateeId?: number;
+}): Promise<bigint>;
+declare function transferImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    fromAccountId: number;
+    toAccountId?: number;
+    tokenId: number;
+    tokenDecimals: number;
+    amount: Decimal.Value;
+}): Promise<number | undefined>;
+export declare function transfer(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    fromAccountId: number;
+    toAccountId?: number;
+    tokenId: number;
+    tokenDecimals: number;
+    amount: Decimal.Value;
+}): Promise<number | undefined>;
+/**
+ * For testing purposes
+ */
+export declare const _private: {
+    createSessionImpl: typeof createSessionImpl;
+    revokeSessionImpl: typeof revokeSessionImpl;
+    withdrawImpl: typeof withdrawImpl;
+    placeOrderImpl: typeof placeOrderImpl;
+    cancelOrderImpl: typeof cancelOrderImpl;
+    transferImpl: typeof transferImpl;
+};
+export {};

package/dist/nord/api/actions.js

@@ -0,0 +1,250 @@
+"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._private = void 0;
+exports.createSession = createSession;
+exports.revokeSession = revokeSession;
+exports.withdraw = withdraw;
+exports.placeOrder = placeOrder;
+exports.cancelOrder = cancelOrder;
+exports.transfer = transfer;
+const proto = __importStar(require("../../gen/nord"));
+const types_1 = require("../../types");
+const utils_1 = require("../../utils");
+async function sessionSign(signFn, message) {
+    const signature = await signFn(message);
+    return new Uint8Array([...message, ...signature]);
+}
+async function walletSign(walletSignFn, message) {
+    const signature = await walletSignFn(message);
+    return new Uint8Array([...message, ...signature]);
+}
+function makeSendHttp(serverUrl) {
+    return async (body) => {
+        const response = await (0, utils_1.checkedFetch)(`${serverUrl}/action`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body,
+        });
+        return new Uint8Array(await response.arrayBuffer());
+    };
+}
+async function sendAction(sendFn, makeSignedMessage, action, actionErrorDesc) {
+    const encoded = (0, utils_1.encodeLengthDelimited)(action, proto.Action);
+    const body = await makeSignedMessage(encoded);
+    const rawResp = await sendFn(body);
+    const resp = (0, utils_1.decodeLengthDelimited)(rawResp, proto.Receipt);
+    if (resp.kind?.$case === 'err') {
+        throw new Error(`Could not ${actionErrorDesc}, reason: ${proto.errorToJSON(resp.kind.value)}`);
+    }
+    return resp;
+}
+async function createSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
+    (0, utils_1.checkPubKeyLength)(types_1.KeyType.Ed25519, params.userPubkey.length);
+    (0, utils_1.checkPubKeyLength)(types_1.KeyType.Ed25519, params.sessionPubkey.length);
+    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 = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: 'createSession',
+            value: {
+                userPubkey: params.userPubkey,
+                blstPubkey: params.sessionPubkey,
+                expiryTimestamp: expiry,
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => walletSign(walletSignFn, m), action, 'create a new session');
+    if (resp.kind?.$case === 'createSessionResult') {
+        return resp.kind.value.sessionId;
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
+    return createSessionImpl(makeSendHttp(serverUrl), walletSignFn, currentTimestamp, nonce, params);
+}
+async function revokeSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
+    const action = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: 'revokeSession',
+            value: {
+                sessionId: BigInt(params.sessionId),
+            },
+        },
+    };
+    await sendAction(sendFn, (m) => walletSign(walletSignFn, m), action, 'create a new session');
+}
+async function revokeSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
+    return revokeSessionImpl(makeSendHttp(serverUrl), walletSignFn, currentTimestamp, nonce, params);
+}
+async function withdrawImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+    const amount = (0, utils_1.toScaledU64)(params.amount, params.sizeDecimals);
+    if (amount <= 0) {
+        throw new Error('Withdraw amount must be positive');
+    }
+    const action = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: 'withdraw',
+            value: {
+                sessionId: BigInt(params.sessionId),
+                tokenId: params.tokenId,
+                amount,
+            },
+        },
+    };
+    await sendAction(sendFn, (m) => sessionSign(signFn, m), action, 'withdraw');
+}
+async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return withdrawImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+async function placeOrderImpl(sendFn, 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 quoteSize = (0, utils_1.toScaledU128)(params.quoteSize ?? 0, params.priceDecimals + params.sizeDecimals);
+    // Compose action object
+    const action = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: 'placeOrder',
+            value: {
+                sessionId: BigInt(params.sessionId),
+                senderAccountId: params.senderId,
+                marketId: params.marketId,
+                side: params.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
+                fillMode: (0, types_1.fillModeToProtoFillMode)(params.fillMode),
+                isReduceOnly: params.isReduceOnly,
+                price,
+                size,
+                quoteSize: (0, utils_1.bigIntToProtoU128)(quoteSize),
+                clientOrderId: (0, utils_1.optMap)(params.clientOrderId, (x) => BigInt(x)),
+                delegatorAccountId: params.liquidateeId,
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, 'place the order');
+    if (resp.kind?.$case === 'placeOrderResult') {
+        return resp.kind.value.posted?.orderId;
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return placeOrderImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+async function cancelOrderImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+    const action = {
+        currentTimestamp,
+        nonce: nonce,
+        kind: {
+            $case: 'cancelOrderById',
+            value: {
+                orderId: BigInt(params.orderId),
+                sessionId: BigInt(params.sessionId),
+                senderAccountId: params.senderId,
+                delegatorAccountId: params.liquidateeId,
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, 'cancel the order');
+    if (resp.kind?.$case === 'cancelOrderResult') {
+        return resp.kind.value.orderId;
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+async function cancelOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return cancelOrderImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+async function transferImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+    const action = {
+        currentTimestamp,
+        nonce: nonce,
+        kind: {
+            $case: 'transfer',
+            value: {
+                sessionId: BigInt(params.sessionId),
+                fromAccountId: params.fromAccountId,
+                toAccountId: params.toAccountId,
+                tokenId: params.tokenId,
+                amount: (0, utils_1.toScaledU64)(params.amount ?? 0, params.tokenDecimals),
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, 'transfer asset to other account');
+    if (resp.kind?.$case === 'transferred') {
+        if (resp.kind.value.accountCreated) {
+            return resp.kind.value.toUserAccount;
+        }
+        else {
+            return undefined;
+        }
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return transferImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+/**
+ * For testing purposes
+ */
+exports._private = {
+    createSessionImpl,
+    revokeSessionImpl,
+    withdrawImpl,
+    placeOrderImpl,
+    cancelOrderImpl,
+    transferImpl,
+};

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

@@ -0,0 +1,49 @@
+import { Account, Info } from '../../types';
+import { NordWebSocketClient } from '../../websocket/index';
+/**
+ * Get the current timestamp from the Nord server
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Current timestamp as a bigint
+ * @throws {NordError} If the request fails
+ */
+export declare function getTimestamp(webServerUrl: string): Promise<bigint>;
+/**
+ * Get the next action nonce from the Nord server
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Next action nonce
+ * @throws {NordError} If the request fails
+ */
+export declare function getActionNonce(webServerUrl: string): Promise<number>;
+/**
+ * Get information about the Nord server
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Information about markets and tokens
+ * @throws {NordError} If the request fails
+ */
+export declare function getInfo(webServerUrl: string): Promise<Info>;
+/**
+ * Get account information
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param accountId - Account ID to get information for
+ * @returns Account information
+ * @throws {NordError} If the request fails
+ */
+export declare function getAccount(webServerUrl: string, accountId: number): Promise<Account>;
+/**
+ * Initialize a WebSocket client for Nord
+ *
+ * Connects to one of the specific Nord WebSocket endpoints:
+ * - /ws/trades - For trade updates (default)
+ * - /ws/deltas - For orderbook delta updates
+ * - /ws/user - For user-specific updates
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param endpoint - Specific WebSocket endpoint to connect to (trades, deltas, or user)
+ * @param initialSubscriptions - Optional array of initial subscriptions (e.g., ["trades@BTCUSDC"])
+ * @returns WebSocket client
+ */
+export declare function initWebSocketClient(webServerUrl: string, endpoint?: 'trades' | 'deltas' | 'user', initialSubscriptions?: string[]): NordWebSocketClient;

package/dist/nord/api/core.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimestamp = getTimestamp;
+exports.getActionNonce = getActionNonce;
+exports.getInfo = getInfo;
+exports.getAccount = getAccount;
+exports.initWebSocketClient = initWebSocketClient;
+const utils_1 = require("../../utils");
+const NordError_1 = require("../utils/NordError");
+const index_1 = require("../../websocket/index");
+/**
+ * Get the current timestamp from the Nord server
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Current timestamp as a bigint
+ * @throws {NordError} If the request fails
+ */
+async function getTimestamp(webServerUrl) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/timestamp`);
+        return BigInt(await response.json());
+    }
+    catch (error) {
+        throw new NordError_1.NordError('Failed to get timestamp', { cause: error });
+    }
+}
+/**
+ * Get the next action nonce from the Nord server
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Next action nonce
+ * @throws {NordError} If the request fails
+ */
+async function getActionNonce(webServerUrl) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/action_nonce`);
+        const data = await response.json();
+        return data.nonce;
+    }
+    catch (error) {
+        throw new NordError_1.NordError('Failed to get action nonce', { cause: error });
+    }
+}
+/**
+ * Get information about the Nord server
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Information about markets and tokens
+ * @throws {NordError} If the request fails
+ */
+async function getInfo(webServerUrl) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/info`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError('Failed to get info', { cause: error });
+    }
+}
+/**
+ * Get account information
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param accountId - Account ID to get information for
+ * @returns Account information
+ * @throws {NordError} If the request fails
+ */
+async function getAccount(webServerUrl, accountId) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/account?account_id=${accountId}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to get account ${accountId}`, { cause: error });
+    }
+}
+/**
+ * Initialize a WebSocket client for Nord
+ *
+ * Connects to one of the specific Nord WebSocket endpoints:
+ * - /ws/trades - For trade updates (default)
+ * - /ws/deltas - For orderbook delta updates
+ * - /ws/user - For user-specific updates
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param endpoint - Specific WebSocket endpoint to connect to (trades, deltas, or user)
+ * @param initialSubscriptions - Optional array of initial subscriptions (e.g., ["trades@BTCUSDC"])
+ * @returns WebSocket client
+ */
+function initWebSocketClient(webServerUrl, endpoint, initialSubscriptions) {
+    try {
+        // Convert HTTP URL to WebSocket URL with specific endpoint
+        // If no specific endpoint is provided, we'll connect to trades by default
+        const specificEndpoint = endpoint || 'trades';
+        const wsUrl = webServerUrl.replace(/^http/, 'ws') + `/ws/${specificEndpoint}`;
+        console.log(`Initializing WebSocket client with URL: ${wsUrl}`);
+        // Create and connect the WebSocket client
+        const ws = new index_1.NordWebSocketClient(wsUrl);
+        // Add error handler
+        ws.on('error', (error) => {
+            console.error('Nord WebSocket error:', error);
+        });
+        // Add connected handler for debugging
+        ws.on('connected', () => {
+            console.log('Nord WebSocket connected successfully');
+            // Subscribe to initial subscriptions if provided
+            if (initialSubscriptions && initialSubscriptions.length > 0) {
+                ws.subscribe(initialSubscriptions);
+            }
+        });
+        // Connect the WebSocket
+        ws.connect();
+        return ws;
+    }
+    catch (error) {
+        console.error('Failed to initialize WebSocket client:', error);
+        throw new NordError_1.NordError('Failed to initialize WebSocket client', {
+            cause: error,
+        });
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./orderFunctions";

package/dist/nord/api/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./orderFunctions"), exports);

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

@@ -0,0 +1,36 @@
+import { MarketsStatsResponse, OrderbookQuery, OrderbookResponse, TradesQuery, TradesResponse, UserAccountIdsQuery, UserAccountIdsResponse } from '../../types';
+/**
+ * Get market statistics
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Market statistics response
+ * @throws {NordError} If the request fails
+ */
+export declare function marketsStats(webServerUrl: string): Promise<MarketsStatsResponse>;
+/**
+ * Get trades for a market
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Trades query parameters
+ * @returns Trades response
+ * @throws {NordError} If the request fails
+ */
+export declare function getTrades(webServerUrl: string, query: TradesQuery): Promise<TradesResponse>;
+/**
+ * Get user account IDs
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - User account IDs query parameters
+ * @returns User account IDs response
+ * @throws {NordError} If the request fails
+ */
+export declare function getUserAccountIds(webServerUrl: string, query: UserAccountIdsQuery): Promise<UserAccountIdsResponse>;
+/**
+ * Get orderbook for a market
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Orderbook query parameters
+ * @returns Orderbook response
+ * @throws {NordError} If the request fails
+ */
+export declare function getOrderbook(webServerUrl: string, query: OrderbookQuery): Promise<OrderbookResponse>;