@n1xyz/nord-ts 0.0.19 → 0.0.20

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

@@ -0,0 +1,135 @@
+import Decimal from "decimal.js";
+import * as proto from "../../gen/nord";
+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<{
+    actionId: bigint;
+} & proto.Receipt_WithdrawResult>;
+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<{
+    actionId: bigint;
+} & proto.Receipt_WithdrawResult>;
+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;
+    quoteSizeSize?: Decimal.Value;
+    quoteSizePrice?: 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>;
+export type AtomicSubaction = {
+    kind: "place";
+    marketId: number;
+    side: Side;
+    fillMode: FillMode;
+    isReduceOnly: boolean;
+    sizeDecimals: number;
+    priceDecimals: number;
+    size?: Decimal.Value;
+    price?: Decimal.Value;
+    quoteSizeSize?: Decimal.Value;
+    quoteSizePrice?: Decimal.Value;
+    clientOrderId?: BigIntValue;
+} | {
+    kind: "cancel";
+    orderId: BigIntValue;
+};
+declare function atomicImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    accountId?: number;
+    actions: AtomicSubaction[];
+}): Promise<proto.Receipt_AtomicResult>;
+export declare function atomic(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    accountId?: number;
+    actions: AtomicSubaction[];
+}): Promise<proto.Receipt_AtomicResult>;
+/**
+ * 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;
+    atomicImpl: typeof atomicImpl;
+};
+export {};

package/dist/nord/api/actions.js

@@ -0,0 +1,313 @@
+"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;
+exports.atomic = atomic;
+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) => {
+        // TODO: this should be changed to use openapi
+        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,
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "withdraw");
+    if (resp.kind?.$case === "withdrawResult") {
+        return { actionId: resp.actionId, ...resp.kind.value };
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+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.toScaledU64)(params.quoteSizeSize ?? 0, params.sizeDecimals);
+    const quotePrice = (0, utils_1.toScaledU64)(params.quoteSizePrice ?? 0, params.priceDecimals);
+    // 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: { size: quoteSize, price: quotePrice },
+                clientOrderId: params.clientOrderId === undefined
+                    ? undefined
+                    : BigInt(params.clientOrderId),
+                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);
+}
+async function atomicImpl(sendFn, 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 quoteSizeSize = (0, utils_1.toScaledU64)(a.quoteSizeSize ?? 0, a.sizeDecimals);
+            const quoteSizePrice = (0, utils_1.toScaledU64)(a.quoteSizePrice ?? 0, a.priceDecimals);
+            const tradeOrPlace = {
+                marketId: a.marketId,
+                orderType: {
+                    side: a.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
+                    fillMode: (0, types_1.fillModeToProtoFillMode)(a.fillMode),
+                    isReduceOnly: a.isReduceOnly,
+                },
+                limit: {
+                    price,
+                    size,
+                    quoteSize: { size: quoteSizeSize, price: quoteSizePrice },
+                },
+                clientOrderId: a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
+            };
+            return {
+                inner: { $case: "tradeOrPlace", value: tradeOrPlace },
+            };
+        }
+        return {
+            inner: { $case: "cancelOrder", value: { orderId: BigInt(a.orderId) } },
+        };
+    });
+    const action = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: "atomic",
+            value: {
+                sessionId: BigInt(params.sessionId),
+                accountId: params.accountId, // optional
+                actions: subactions,
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "execute atomic action");
+    if (resp.kind?.$case === "atomic") {
+        return resp.kind.value;
+    }
+    throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+}
+async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return atomicImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+/**
+ * For testing purposes
+ */
+exports._private = {
+    createSessionImpl,
+    revokeSessionImpl,
+    withdrawImpl,
+    placeOrderImpl,
+    cancelOrderImpl,
+    transferImpl,
+    atomicImpl,
+};

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

@@ -0,0 +1,16 @@
+import { SubscriptionPattern } from "../../types";
+import { NordWebSocketClient } from "../../websocket/index";
+/**
+ * Initialize a WebSocket client for Nord
+ *
+ * Connects to the Nord WebSocket endpoint with support for multiple subscription types:
+ * - trades@SYMBOL - For trade updates
+ * - deltas@SYMBOL - For orderbook delta updates
+ * - account@ACCOUNT_ID - For user-specific updates
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param subscriptions - Array of subscriptions (e.g., ["trades@BTCUSDC", "deltas@BTCUSDC", "account@42"])
+ * @returns WebSocket client
+ * @throws {NordError} If initialization fails or invalid subscription is provided
+ */
+export declare function initWebSocketClient(webServerUrl: string, subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account", initialSubscriptions?: SubscriptionPattern[]): NordWebSocketClient;

package/dist/nord/api/core.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWebSocketClient = initWebSocketClient;
+const index_1 = require("../../websocket/index");
+const NordError_1 = require("../utils/NordError");
+/**
+ * Initialize a WebSocket client for Nord
+ *
+ * Connects to the Nord WebSocket endpoint with support for multiple subscription types:
+ * - trades@SYMBOL - For trade updates
+ * - deltas@SYMBOL - For orderbook delta updates
+ * - account@ACCOUNT_ID - For user-specific updates
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param subscriptions - Array of subscriptions (e.g., ["trades@BTCUSDC", "deltas@BTCUSDC", "account@42"])
+ * @returns WebSocket client
+ * @throws {NordError} If initialization fails or invalid subscription is provided
+ */
+function initWebSocketClient(webServerUrl, subscriptions, initialSubscriptions) {
+    try {
+        // Determine URL and subscriptions based on parameters
+        let wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws`;
+        let wsSubscriptions = [];
+        // Validate subscriptions parameter
+        if (typeof subscriptions === "string") {
+            // Legacy mode - handle endpoint string
+            if (subscriptions === "trades" ||
+                subscriptions === "delta" ||
+                subscriptions === "account") {
+                wsUrl += `/${subscriptions}`;
+                // If initialSubscriptions provided, use them
+                if (initialSubscriptions && initialSubscriptions.length > 0) {
+                    // Validate initialSubscriptions
+                    initialSubscriptions.forEach(validateSubscription);
+                    wsSubscriptions = initialSubscriptions;
+                }
+            }
+            else {
+                throw new NordError_1.NordError(`Invalid endpoint: ${subscriptions}. Must be "trades", "deltas", or "account".`);
+            }
+        }
+        else if (Array.isArray(subscriptions) && subscriptions.length > 0) {
+            // New mode - validate and combine subscriptions in URL
+            subscriptions.forEach(validateSubscription);
+            wsUrl += `/${subscriptions.join("&")}`;
+        }
+        else {
+            // Default to trades endpoint if no subscriptions specified
+            wsUrl += `/trades`;
+        }
+        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 additional subscriptions if provided
+            // For new format, these are already part of the URL
+            if (wsSubscriptions.length > 0) {
+                ws.subscribe(wsSubscriptions);
+            }
+        });
+        // 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,
+        });
+    }
+}
+/**
+ * Validates a subscription string follows the correct format
+ *
+ * @param subscription - The subscription to validate
+ * @throws {NordError} If the subscription format is invalid
+ */
+function validateSubscription(subscription) {
+    const [type, param] = subscription.split("@");
+    if (!type || !param || !["trades", "deltas", "account"].includes(type)) {
+        throw new NordError_1.NordError(`Invalid subscription format: ${subscription}. Expected format: "trades@SYMBOL", "deltas@SYMBOL", or "account@ID"`);
+    }
+    // Additional validation for account subscriptions
+    if (type === "account" && isNaN(Number(param))) {
+        throw new NordError_1.NordError(`Invalid account ID in subscription: ${subscription}. Account ID must be a number.`);
+    }
+}

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>;

package/dist/nord/api/market.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketsStats = marketsStats;
+exports.getTrades = getTrades;
+exports.getUserAccountIds = getUserAccountIds;
+exports.getOrderbook = getOrderbook;
+const utils_1 = require("../../utils");
+const NordError_1 = require("../utils/NordError");
+/**
+ * Get market statistics
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Market statistics response
+ * @throws {NordError} If the request fails
+ */
+async function marketsStats(webServerUrl) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/stats`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to fetch markets stats", { cause: error });
+    }
+}
+/**
+ * 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
+ */
+async function getTrades(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        params.append("accountId", query.accountId.toString());
+        if (query.since) {
+            params.append("since", query.since);
+        }
+        if (query.until) {
+            params.append("until", query.until);
+        }
+        if (query.pageId) {
+            params.append("pageId", query.pageId);
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/trades?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to get trades", { cause: error });
+    }
+}
+/**
+ * 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
+ */
+async function getUserAccountIds(webServerUrl, query) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/user/${query.pubkey.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to get user account IDs", { cause: error });
+    }
+}
+/**
+ * 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
+ */
+async function getOrderbook(webServerUrl, query) {
+    try {
+        const params = new URLSearchParams();
+        if (query.symbol) {
+            params.append("symbol", query.symbol);
+        }
+        else if (query.market_id !== undefined) {
+            params.append("market_id", query.market_id.toString());
+        }
+        else {
+            throw new NordError_1.NordError("Either symbol or market_id must be provided for orderbook query");
+        }
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/orderbook?${params.toString()}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to get orderbook", { cause: error });
+    }
+}