@n1xyz/nord-ts 0.0.19 → 0.0.21

package/dist/nord/api/metrics.js

@@ -0,0 +1,229 @@
+"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}`);
+        // Get the raw text response (Prometheus format)
+        const text = await response.text();
+        // Parse the Prometheus-formatted metrics text into an AggregateMetrics object
+        const metrics = {
+            blocks_total: 0,
+            tx_total: extractMetricValue(text, "nord_requests_ok_count"),
+            tx_tps: calculateTps(text),
+            tx_tps_peak: calculatePeakTps(text),
+            request_latency_average: extractLatency(text),
+        };
+        return metrics;
+    }
+    catch (error) {
+        throw new NordError_1.NordError("Failed to fetch aggregate metrics", { cause: error });
+    }
+}
+/**
+ * Extract a metric value from Prometheus-formatted text
+ *
+ * @param text - Prometheus-formatted metrics text
+ * @param metricName - Name of the metric to extract
+ * @returns The metric value as a number, or 0 if not found
+ */
+function extractMetricValue(text, metricName) {
+    const regex = new RegExp(`^${metricName}\\s+([\\d.]+)`, "m");
+    const match = text.match(regex);
+    return match ? parseFloat(match[1]) : 0;
+}
+/**
+ * Calculate TPS from Prometheus metrics
+ *
+ * @param text - Prometheus-formatted metrics text
+ * @returns Calculated TPS value
+ */
+function calculateTps(text) {
+    // Use the request count and latency to estimate TPS
+    const requestCount = extractMetricValue(text, "nord_requests_ok_count");
+    const latencySum = extractSummaryValue(text, "nord_requests_ok_latency_sum");
+    const latencyCount = extractSummaryValue(text, "nord_requests_ok_latency_count");
+    if (latencySum > 0 && latencyCount > 0) {
+        // Average latency in seconds
+        const avgLatency = latencySum / latencyCount;
+        // If we have valid latency data, estimate TPS as requests per second
+        return avgLatency > 0 ? requestCount / (latencyCount * avgLatency) : 0;
+    }
+    // Fallback: just return a small fraction of the total request count
+    return requestCount > 0 ? requestCount / 100 : 0;
+}
+/**
+ * Calculate peak TPS from Prometheus metrics
+ *
+ * @param text - Prometheus-formatted metrics text
+ * @returns Calculated peak TPS value
+ */
+function calculatePeakTps(text) {
+    // For peak TPS, we'll use a simple heuristic: 2x the current TPS estimate
+    // TODO: fix this
+    return calculateTps(text) * 2;
+}
+/**
+ * Extract latency from Prometheus metrics
+ *
+ * @param text - Prometheus-formatted metrics text
+ * @returns Average latency in seconds
+ */
+function extractLatency(text) {
+    // TODO: fix - using average for latency is kinda wack. ok to merge for now but should change.
+    const latencySum = extractSummaryValue(text, "nord_requests_ok_latency_sum");
+    const latencyCount = extractSummaryValue(text, "nord_requests_ok_latency_count");
+    return latencyCount > 0 ? latencySum / latencyCount : 0;
+}
+/**
+ * Extract a summary value from Prometheus-formatted text
+ *
+ * @param text - Prometheus-formatted metrics text
+ * @param metricName - Name of the metric to extract
+ * @returns The metric value as a number, or 0 if not found
+ */
+function extractSummaryValue(text, metricName) {
+    const regex = new RegExp(`^${metricName}\\s+([\\d.]+)`, "m");
+    const match = text.match(regex);
+    return match ? parseFloat(match[1]) : 0;
+}
+/**
+ * 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 {
+        // nord_tx_count doesn't exist in the metrics, use nord_requests_ok_count instead
+        return await queryPrometheus(webServerUrl, `sum(rate(nord_requests_ok_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 {
+        // nord_tx_count doesn't exist in the metrics, use nord_requests_ok_count instead
+        return await queryPrometheus(webServerUrl, `max_over_time(sum(rate(nord_requests_ok_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 {
+        // nord_tx_latency_ms doesn't exist, use nord_requests_ok_latency instead
+        // which contains the latency data in the summary metric
+        return await queryPrometheus(webServerUrl, `quantile_over_time(0.5, nord_requests_ok_latency[${period}]) * 1000`);
+    }
+    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 {
+        // nord_tx_count doesn't exist, use nord_requests_ok_count instead
+        return await queryPrometheus(webServerUrl, "sum(nord_requests_ok_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)}`);
+        // Handle raw text response
+        const text = await response.text();
+        try {
+            // Try to parse as JSON first
+            const data = JSON.parse(text);
+            return data.data.result[0]?.value[1] || 0;
+        }
+        catch (error) {
+            console.log("Prometheus query failed:", error);
+            // Try to find a number in the response
+            const numberMatch = text.match(/[\d.]+/);
+            if (numberMatch) {
+                return parseFloat(numberMatch[0]);
+            }
+            // Return 0 if no number is found
+            return 0;
+        }
+    }
+    catch (error) {
+        throw new NordError_1.NordError(`Failed to query Prometheus: ${params}`, {
+            cause: error,
+        });
+    }
+}

package/dist/nord/client/Nord.d.ts

@@ -0,0 +1,282 @@
+import { ProtonClient } from "@n1xyz/proton";
+import { PublicKey } from "@solana/web3.js";
+import { EventEmitter } from "events";
+import { Account, ActionResponse, AggregateMetrics, Info, Market, MarketStats, NordConfig, OrderbookQuery, OrderbookResponse, PeakTpsPeriodUnit, Token, TradesResponse, User } from "../../types";
+import { NordWebSocketClient } from "../../websocket/index";
+import { OrderbookSubscription, TradeSubscription } from "../models/Subscriber";
+/**
+ * User subscription interface
+ */
+export interface UserSubscription extends EventEmitter {
+    close: () => void;
+}
+/**
+ * WebSocket subscription options interface
+ */
+export interface WebSocketSubscriptionOptions {
+    /** Market symbols to subscribe to for trade updates */
+    trades?: string[];
+    /** Market symbols to subscribe to for orderbook delta updates */
+    deltas?: string[];
+    /** Account IDs to subscribe to for account updates */
+    accounts?: number[];
+}
+/**
+ * Main Nord client class for interacting with the Nord API
+ */
+export declare class Nord {
+    /** Base URL for the Nord web server */
+    readonly webServerUrl: string;
+    /** Bridge verification key */
+    readonly bridgeVk: PublicKey;
+    /** Solana RPC URL */
+    readonly solanaUrl: string;
+    /** Available markets */
+    markets: Market[];
+    /** Available tokens */
+    tokens: Token[];
+    /** Map of symbol to market_id */
+    private symbolToMarketId;
+    /** Proton client for bridge and hansel operations */
+    protonClient: ProtonClient;
+    /** HTTP client for Nord operations */
+    private httpClient;
+    /**
+     * 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.bridgeVk - Bridge verification key
+     * @param config.solanaUrl - Solana cluster URL
+     * @throws {Error} If required configuration is missing
+     */
+    private constructor();
+    /**
+     * Create a WebSocket client with specific subscriptions
+     *
+     * @param options - Subscription options that specify which data streams to subscribe to
+     * @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(options: WebSocketSubscriptionOptions): 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>;
+    /**
+     * Fetch information about Nord markets and tokens
+     *
+     * @throws {NordError} If the request fails
+     */
+    fetchNordInfo(): Promise<void>;
+    /**
+     * 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.bridgeVk - Bridge verification key
+     * @param nordConfig.solanaUrl - Solana cluster URL
+     * @returns Initialized Nord client
+     * @throws {NordError} If initialization fails
+     */
+    static initNord({ bridgeVk: bridgeVk_, solanaUrl, webServerUrl, }: Readonly<NordConfig>): Promise<Nord>;
+    /**
+     * Initialize the Nord client
+     * @private
+     */
+    private init;
+    /**
+     * Query a specific action
+     *
+     * @param query - Action query parameters
+     * @returns Action response
+     * @throws {NordError} If the request fails
+     */
+    queryAction({ action_id, }: {
+        action_id: number;
+    }): Promise<ActionResponse | null>;
+    /**
+     * Query recent actions
+     *
+     * @param from - Starting action index
+     * @param to - Ending action index
+     * @returns Actions response
+     * @throws {NordError} If the request fails
+     */
+    queryRecentActions(query: {
+        from: number;
+        to: number;
+    }): Promise<ActionResponse[]>;
+    /**
+     * Get the last action ID
+     *
+     * @returns Last action ID
+     * @throws {NordError} If the request fails
+     */
+    getLastActionId(): Promise<number>;
+    /**
+     * Fetch aggregate metrics from the Nord API
+     *
+     * @param txPeakTpsPeriod - Period for peak TPS calculation
+     * @param txPeakTpsPeriodUnit - Unit for peak TPS period
+     * @returns Aggregate metrics
+     * @throws {NordError} If the request fails
+     */
+    aggregateMetrics(txPeakTpsPeriod?: number, txPeakTpsPeriodUnit?: PeakTpsPeriodUnit): Promise<AggregateMetrics>;
+    /**
+     * Get current transactions per second
+     *
+     * @param period - Time period for the query
+     * @returns Current TPS value
+     * @throws {NordError} If the request fails
+     */
+    getCurrentTps(period?: string): Promise<number>;
+    /**
+     * Get peak transactions per second
+     *
+     * @param period - Time period for the query
+     * @returns Peak TPS value
+     * @throws {NordError} If the request fails
+     */
+    getPeakTps(period?: string): Promise<number>;
+    /**
+     * Get median transaction latency
+     *
+     * @param period - Time period for the query
+     * @returns Median latency in milliseconds
+     * @throws {NordError} If the request fails
+     */
+    getMedianLatency(period?: string): Promise<number>;
+    /**
+     * Get total transaction count
+     *
+     * @returns Total transaction count
+     * @throws {NordError} If the request fails
+     */
+    getTotalTransactions(): Promise<number>;
+    /**
+     * Query Prometheus metrics
+     *
+     * @param params - Prometheus query parameters
+     * @returns Query result as a number
+     * @throws {NordError} If the request fails
+     */
+    queryPrometheus(params: string): 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 query - Trades query parameters
+     * @returns Trades response
+     * @throws {NordError} If the request fails
+     */
+    getTrades(query: Readonly<{
+        marketId?: number;
+        takerId?: number;
+        makerId?: number;
+        takerSide?: "bid" | "ask";
+        pageSize?: number;
+        sinceRcf3339?: string;
+        untilRfc3339?: string;
+        pageId?: string;
+    }>): Promise<TradesResponse>;
+    /**
+     * Get user account IDs
+     *
+     * @param query - User account IDs query parameters
+     * @returns User account IDs response
+     * @throws {NordError} If the request fails
+     */
+    getUser(query: {
+        pubkey: string | PublicKey;
+    }): Promise<User | null>;
+    /**
+     * Get orderbook for a market
+     *
+     * @param query - Orderbook query parameters (either market_id or symbol must be provided)
+     * @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(query: OrderbookQuery): Promise<OrderbookResponse>;
+    /**
+     * Get information about the Nord server
+     *
+     * @returns Information about markets and tokens
+     * @throws {NordError} If the request fails
+     */
+    getInfo(): Promise<Info>;
+    /**
+     * 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 market statistics (alias for marketsStats for backward compatibility)
+     *
+     * @returns Market statistics response
+     */
+    getMarketStats({ marketId, }: {
+        marketId: number;
+    }): Promise<MarketStats>;
+    /**
+     * 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>;
+}