@n1xyz/nord-ts 0.3.2 → 0.3.4

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,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/api/triggers.d.ts

@@ -0,0 +1,7 @@
+import { components } from "../../gen/openapi";
+type AccountTriggerInfo = components["schemas"]["AccountTriggerInfo"];
+type TriggerHistoryPage = components["schemas"]["PageResult_for_uint64_and_HistoryTriggerInfo"];
+type HistoryTriggerQuery = components["schemas"]["AccountTriggersQuery"];
+export type { AccountTriggerInfo, TriggerHistoryPage, HistoryTriggerQuery };
+export declare function fetchAccountTriggers(serverUrl: string, accountId: number): Promise<AccountTriggerInfo[]>;
+export declare function fetchAccountTriggerHistory(serverUrl: string, accountId: number, options: HistoryTriggerQuery): Promise<TriggerHistoryPage>;

package/dist/nord/api/triggers.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAccountTriggers = fetchAccountTriggers;
+exports.fetchAccountTriggerHistory = fetchAccountTriggerHistory;
+const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
+async function fetchAccountTriggers(serverUrl, accountId) {
+    const client = (0, openapi_fetch_1.default)({ baseUrl: serverUrl });
+    const response = await client.GET("/account/{account_id}/triggers", {
+        params: {
+            path: { account_id: accountId },
+        },
+    });
+    if (response.data === undefined) {
+        throw new Error(`Failed to fetch triggers for account ${accountId}: HTTP ${response.response.status}`);
+    }
+    return response.data ?? [];
+}
+async function fetchAccountTriggerHistory(serverUrl, accountId, options) {
+    const client = (0, openapi_fetch_1.default)({ baseUrl: serverUrl });
+    const response = await client.GET("/account/{account_id}/triggers/history", {
+        params: {
+            path: { account_id: accountId },
+            query: {
+                since: options.since,
+                until: options.until,
+                pageSize: options.pageSize,
+                startInclusive: options.startInclusive,
+            },
+        },
+    });
+    if (!response.data) {
+        throw new Error(`Failed to fetch trigger history for account ${accountId}: HTTP ${response.response.status}`);
+    }
+    return response.data;
+}