@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/nord/api/market.js

@@ -0,0 +1,98 @@
+"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 params = new URLSearchParams();
+        params.append('pubkey', query.pubkey);
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/user?${params.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 });
+    }
+}

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

@@ -0,0 +1,67 @@
+import { AggregateMetrics, PeakTpsPeriodUnit } from '../../types';
+/**
+ * Time periods for metrics queries
+ */
+export declare enum MetricPeriod {
+    ONE_MINUTE = "1m",
+    FIVE_MINUTES = "5m",
+    FIFTEEN_MINUTES = "15m",
+    ONE_HOUR = "1h",
+    FOUR_HOURS = "4h",
+    ONE_DAY = "24h",
+    ONE_WEEK = "7d"
+}
+/**
+ * Fetch aggregate metrics from the Nord API
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param txPeakTpsPeriod - Period for peak TPS calculation
+ * @param txPeakTpsPeriodUnit - Unit for peak TPS period
+ * @returns Aggregate metrics
+ * @throws {NordError} If the request fails
+ */
+export declare function aggregateMetrics(webServerUrl: string, txPeakTpsPeriod?: number, txPeakTpsPeriodUnit?: PeakTpsPeriodUnit): Promise<AggregateMetrics>;
+/**
+ * Get current transactions per second
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param period - Time period for the query
+ * @returns Current TPS value
+ * @throws {NordError} If the request fails
+ */
+export declare function getCurrentTps(webServerUrl: string, period?: string): Promise<number>;
+/**
+ * Get peak transactions per second
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param period - Time period for the query
+ * @returns Peak TPS value
+ * @throws {NordError} If the request fails
+ */
+export declare function getPeakTps(webServerUrl: string, period?: string): Promise<number>;
+/**
+ * Get median transaction latency
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param period - Time period for the query
+ * @returns Median latency in milliseconds
+ * @throws {NordError} If the request fails
+ */
+export declare function getMedianLatency(webServerUrl: string, period?: string): Promise<number>;
+/**
+ * Get total transaction count
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Total transaction count
+ * @throws {NordError} If the request fails
+ */
+export declare function getTotalTransactions(webServerUrl: string): Promise<number>;
+/**
+ * Query Prometheus metrics
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param params - Prometheus query parameters
+ * @returns Query result as a number
+ * @throws {NordError} If the request fails
+ */
+export declare function queryPrometheus(webServerUrl: string, params: string): Promise<number>;

package/dist/nord/api/metrics.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricPeriod = void 0;
+exports.aggregateMetrics = aggregateMetrics;
+exports.getCurrentTps = getCurrentTps;
+exports.getPeakTps = getPeakTps;
+exports.getMedianLatency = getMedianLatency;
+exports.getTotalTransactions = getTotalTransactions;
+exports.queryPrometheus = queryPrometheus;
+const types_1 = require("../../types");
+const utils_1 = require("../../utils");
+const NordError_1 = require("../utils/NordError");
+/**
+ * Time periods for metrics queries
+ */
+var MetricPeriod;
+(function (MetricPeriod) {
+    MetricPeriod["ONE_MINUTE"] = "1m";
+    MetricPeriod["FIVE_MINUTES"] = "5m";
+    MetricPeriod["FIFTEEN_MINUTES"] = "15m";
+    MetricPeriod["ONE_HOUR"] = "1h";
+    MetricPeriod["FOUR_HOURS"] = "4h";
+    MetricPeriod["ONE_DAY"] = "24h";
+    MetricPeriod["ONE_WEEK"] = "7d";
+})(MetricPeriod || (exports.MetricPeriod = MetricPeriod = {}));
+/**
+ * Fetch aggregate metrics from the Nord API
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param txPeakTpsPeriod - Period for peak TPS calculation
+ * @param txPeakTpsPeriodUnit - Unit for peak TPS period
+ * @returns Aggregate metrics
+ * @throws {NordError} If the request fails
+ */
+async function aggregateMetrics(webServerUrl, txPeakTpsPeriod = 1, txPeakTpsPeriodUnit = types_1.PeakTpsPeriodUnit.Day) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/metrics?tx_peak_tps_period=${txPeakTpsPeriod}&tx_peak_tps_period_unit=${txPeakTpsPeriodUnit}`);
+        return await response.json();
+    }
+    catch (error) {
+        throw new NordError_1.NordError('Failed to fetch aggregate metrics', { cause: error });
+    }
+}
+/**
+ * Get current transactions per second
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param period - Time period for the query
+ * @returns Current TPS value
+ * @throws {NordError} If the request fails
+ */
+async function getCurrentTps(webServerUrl, period = '1m') {
+    try {
+        return await queryPrometheus(webServerUrl, `sum(rate(nord_tx_count[${period}]))`);
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to get current TPS for period ${period}`, {
+            cause: error,
+        });
+    }
+}
+/**
+ * Get peak transactions per second
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param period - Time period for the query
+ * @returns Peak TPS value
+ * @throws {NordError} If the request fails
+ */
+async function getPeakTps(webServerUrl, period = '24h') {
+    try {
+        return await queryPrometheus(webServerUrl, `max_over_time(sum(rate(nord_tx_count[1m]))[${period}:])`);
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to get peak TPS for period ${period}`, {
+            cause: error,
+        });
+    }
+}
+/**
+ * Get median transaction latency
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param period - Time period for the query
+ * @returns Median latency in milliseconds
+ * @throws {NordError} If the request fails
+ */
+async function getMedianLatency(webServerUrl, period = '1m') {
+    try {
+        return await queryPrometheus(webServerUrl, `quantile_over_time(0.5, nord_tx_latency_ms[${period}])`);
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to get median latency for period ${period}`, {
+            cause: error,
+        });
+    }
+}
+/**
+ * Get total transaction count
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Total transaction count
+ * @throws {NordError} If the request fails
+ */
+async function getTotalTransactions(webServerUrl) {
+    try {
+        return await queryPrometheus(webServerUrl, 'sum(nord_tx_count)');
+    }
+    catch (error) {
+        throw new NordError_1.NordError('Failed to get total transactions', { cause: error });
+    }
+}
+/**
+ * Query Prometheus metrics
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param params - Prometheus query parameters
+ * @returns Query result as a number
+ * @throws {NordError} If the request fails
+ */
+async function queryPrometheus(webServerUrl, params) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/prometheus?query=${encodeURIComponent(params)}`);
+        const data = await response.json();
+        return data.data.result[0]?.value[1] || 0;
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to query Prometheus: ${params}`, {
+            cause: error,
+        });
+    }
+}

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

@@ -0,0 +1,168 @@
+import { FillMode, Side } from "../../types";
+import { BigIntValue } from "../../utils";
+/**
+ * Interface for placing a new order
+ */
+export interface PlaceOrderParams {
+    /**
+     * Server URL for the Nord API
+     */
+    serverUrl: string;
+    /**
+     * Function to sign messages
+     */
+    signFn: (message: Uint8Array) => Promise<Uint8Array>;
+    /**
+     * Current timestamp as bigint
+     */
+    currentTimestamp: bigint;
+    /**
+     * Nonce for the transaction
+     */
+    nonce: number;
+    /**
+     * Session ID
+     */
+    sessionId: BigIntValue;
+    /**
+     * Sender account ID (optional)
+     */
+    senderId?: number;
+    /**
+     * Market ID
+     */
+    marketId: number;
+    /**
+     * Number of decimals for size
+     */
+    sizeDecimals: number;
+    /**
+     * Number of decimals for price
+     */
+    priceDecimals: number;
+    /**
+     * Order side (Bid = buy, Ask = sell)
+     */
+    side: Side;
+    /**
+     * Order size
+     */
+    size: number | string;
+    /**
+     * Order price
+     */
+    price: number | string;
+    /**
+     * Fill mode for the order
+     */
+    fillMode?: FillMode;
+    /**
+     * Whether the order is reduce-only
+     */
+    isReduceOnly?: boolean;
+    /**
+     * Quote size (optional)
+     */
+    quoteSize?: number | string;
+    /**
+     * Liquidatee ID (optional)
+     */
+    liquidateeId?: number;
+    /**
+     * Client order ID (optional)
+     */
+    clientOrderId?: BigIntValue;
+}
+/**
+ * Interface for canceling an existing order
+ */
+export interface CancelOrderParams {
+    /**
+     * Server URL for the Nord API
+     */
+    serverUrl: string;
+    /**
+     * Function to sign messages
+     */
+    signFn: (message: Uint8Array) => Promise<Uint8Array>;
+    /**
+     * Current timestamp as bigint
+     */
+    currentTimestamp: bigint;
+    /**
+     * Nonce for the transaction
+     */
+    nonce: number;
+    /**
+     * Session ID
+     */
+    sessionId: BigIntValue;
+    /**
+     * Sender account ID (optional)
+     */
+    senderId?: number;
+    /**
+     * Order ID to cancel
+     */
+    orderId: BigIntValue;
+    /**
+     * Liquidatee ID (optional)
+     */
+    liquidateeId?: number;
+}
+/**
+ * Places a new order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+export declare function placeNewOrder(params: PlaceOrderParams): Promise<bigint | undefined>;
+/**
+ * Cancels an existing order
+ *
+ * @param params - Parameters for canceling an order
+ * @returns The canceled order ID if successful
+ */
+export declare function cancelExistingOrder(params: CancelOrderParams): Promise<bigint>;
+/**
+ * Places a market buy order
+ *
+ * @param params - Parameters for placing an order (without price)
+ * @returns The order ID if successful, undefined otherwise
+ */
+export declare function placeMarketBuyOrder(params: Omit<PlaceOrderParams, 'side' | 'fillMode' | 'price'>): Promise<bigint | undefined>;
+/**
+ * Places a market sell order
+ *
+ * @param params - Parameters for placing an order (without price)
+ * @returns The order ID if successful, undefined otherwise
+ */
+export declare function placeMarketSellOrder(params: Omit<PlaceOrderParams, 'side' | 'fillMode' | 'price'>): Promise<bigint | undefined>;
+/**
+ * Places a limit buy order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+export declare function placeLimitBuyOrder(params: Omit<PlaceOrderParams, 'side' | 'fillMode'>): Promise<bigint | undefined>;
+/**
+ * Places a limit sell order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+export declare function placeLimitSellOrder(params: Omit<PlaceOrderParams, 'side' | 'fillMode'>): Promise<bigint | undefined>;
+/**
+ * Places a post-only buy order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+export declare function placePostOnlyBuyOrder(params: Omit<PlaceOrderParams, 'side' | 'fillMode'>): Promise<bigint | undefined>;
+/**
+ * Places a post-only sell order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+export declare function placePostOnlySellOrder(params: Omit<PlaceOrderParams, 'side' | 'fillMode'>): Promise<bigint | undefined>;

package/dist/nord/api/orderFunctions.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.placeNewOrder = placeNewOrder;
+exports.cancelExistingOrder = cancelExistingOrder;
+exports.placeMarketBuyOrder = placeMarketBuyOrder;
+exports.placeMarketSellOrder = placeMarketSellOrder;
+exports.placeLimitBuyOrder = placeLimitBuyOrder;
+exports.placeLimitSellOrder = placeLimitSellOrder;
+exports.placePostOnlyBuyOrder = placePostOnlyBuyOrder;
+exports.placePostOnlySellOrder = placePostOnlySellOrder;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const actions_1 = require("./actions");
+const types_1 = require("../../types");
+/**
+ * Places a new order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+async function placeNewOrder(params) {
+    return (0, actions_1.placeOrder)(params.serverUrl, params.signFn, params.currentTimestamp, params.nonce, {
+        sessionId: params.sessionId,
+        senderId: params.senderId,
+        sizeDecimals: params.sizeDecimals,
+        priceDecimals: params.priceDecimals,
+        marketId: params.marketId,
+        side: params.side,
+        fillMode: params.fillMode || types_1.FillMode.Limit,
+        isReduceOnly: params.isReduceOnly || false,
+        size: new decimal_js_1.default(params.size),
+        price: new decimal_js_1.default(params.price),
+        quoteSize: params.quoteSize ? new decimal_js_1.default(params.quoteSize) : undefined,
+        liquidateeId: params.liquidateeId,
+        clientOrderId: params.clientOrderId,
+    });
+}
+/**
+ * Cancels an existing order
+ *
+ * @param params - Parameters for canceling an order
+ * @returns The canceled order ID if successful
+ */
+async function cancelExistingOrder(params) {
+    return (0, actions_1.cancelOrder)(params.serverUrl, params.signFn, params.currentTimestamp, params.nonce, {
+        sessionId: params.sessionId,
+        senderId: params.senderId,
+        orderId: params.orderId,
+        liquidateeId: params.liquidateeId,
+    });
+}
+/**
+ * Places a market buy order
+ *
+ * @param params - Parameters for placing an order (without price)
+ * @returns The order ID if successful, undefined otherwise
+ */
+async function placeMarketBuyOrder(params) {
+    return placeNewOrder({
+        ...params,
+        side: types_1.Side.Bid,
+        fillMode: types_1.FillMode.ImmediateOrCancel,
+        price: '999999999', // Use a very high price to ensure it executes as a market order
+    });
+}
+/**
+ * Places a market sell order
+ *
+ * @param params - Parameters for placing an order (without price)
+ * @returns The order ID if successful, undefined otherwise
+ */
+async function placeMarketSellOrder(params) {
+    return placeNewOrder({
+        ...params,
+        side: types_1.Side.Ask,
+        fillMode: types_1.FillMode.ImmediateOrCancel,
+        price: '0.000001', // Use a very low price to ensure it executes as a market order
+    });
+}
+/**
+ * Places a limit buy order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+async function placeLimitBuyOrder(params) {
+    return placeNewOrder({
+        ...params,
+        side: types_1.Side.Bid,
+        fillMode: types_1.FillMode.Limit,
+    });
+}
+/**
+ * Places a limit sell order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+async function placeLimitSellOrder(params) {
+    return placeNewOrder({
+        ...params,
+        side: types_1.Side.Ask,
+        fillMode: types_1.FillMode.Limit,
+    });
+}
+/**
+ * Places a post-only buy order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+async function placePostOnlyBuyOrder(params) {
+    return placeNewOrder({
+        ...params,
+        side: types_1.Side.Bid,
+        fillMode: types_1.FillMode.PostOnly,
+    });
+}
+/**
+ * Places a post-only sell order
+ *
+ * @param params - Parameters for placing an order
+ * @returns The order ID if successful, undefined otherwise
+ */
+async function placePostOnlySellOrder(params) {
+    return placeNewOrder({
+        ...params,
+        side: types_1.Side.Ask,
+        fillMode: types_1.FillMode.PostOnly,
+    });
+}

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

@@ -0,0 +1,81 @@
+import { ActionQuery, ActionResponse, ActionsResponse, BlockQuery, BlockResponse, BlockSummaryResponse, RollmanActionResponse, RollmanActionsResponse, RollmanBlockResponse } from '../../types';
+/**
+ * Query a specific block
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Block query parameters
+ * @returns Block response
+ * @throws {NordError} If the request fails
+ */
+export declare function queryBlock(webServerUrl: string, query: BlockQuery): Promise<BlockResponse>;
+/**
+ * Query the last N blocks
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Block response for the last N blocks
+ * @throws {NordError} If the request fails
+ */
+export declare function queryLastNBlocks(webServerUrl: string): Promise<BlockResponse>;
+/**
+ * Query recent blocks
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent blocks to query
+ * @returns Block summary response
+ * @throws {NordError} If the request fails
+ */
+export declare function queryRecentBlocks(webServerUrl: string, last_n: number): Promise<BlockSummaryResponse>;
+/**
+ * Query a specific action
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Action query parameters
+ * @returns Action response
+ * @throws {NordError} If the request fails
+ */
+export declare function queryAction(webServerUrl: string, query: ActionQuery): Promise<ActionResponse>;
+/**
+ * Query recent actions
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent actions to query
+ * @returns Actions response
+ * @throws {NordError} If the request fails
+ */
+export declare function queryRecentActions(webServerUrl: string, last_n: number): Promise<ActionsResponse>;
+/**
+ * Query a block from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Block query parameters
+ * @returns Rollman block response
+ * @throws {NordError} If the request fails
+ */
+export declare function blockQueryRollman(webServerUrl: string, query: BlockQuery): Promise<RollmanBlockResponse>;
+/**
+ * Query block summaries from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent blocks to query
+ * @returns Block summary response
+ * @throws {NordError} If the request fails
+ */
+export declare function blockSummaryQueryRollman(webServerUrl: string, last_n: number): Promise<BlockSummaryResponse>;
+/**
+ * Query an action from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param query - Action query parameters
+ * @returns Rollman action response
+ * @throws {NordError} If the request fails
+ */
+export declare function actionQueryRollman(webServerUrl: string, query: ActionQuery): Promise<RollmanActionResponse>;
+/**
+ * Query actions from Rollman
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param last_n - Number of recent actions to query
+ * @returns Rollman actions response
+ * @throws {NordError} If the request fails
+ */
+export declare function actionsQueryRollman(webServerUrl: string, last_n: number): Promise<RollmanActionsResponse>;