@n1xyz/nord-ts 0.0.1 → 0.0.5

package/dist/index.js

@@ -14,8 +14,24 @@ 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 });
+exports.shortenPublicKey = exports.hexToBuffer = exports.bufferToHex = exports.findPda = exports.makeSigningFunction = exports.keypairFromPrivateKey = exports.fromBN = exports.bridgeToBN = void 0;
+// Export types
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
-__exportStar(require("./abis"), exports);
-__exportStar(require("./nord"), exports);
 __exportStar(require("./const"), exports);
+// Export Nord modules
+__exportStar(require("./nord"), exports);
+// Export WebSocket modules
+__exportStar(require("./websocket/index"), exports);
+// Export bridge modules
+__exportStar(require("./bridge/client"), exports);
+__exportStar(require("./bridge/types"), exports);
+var utils_1 = require("./bridge/utils");
+Object.defineProperty(exports, "bridgeToBN", { enumerable: true, get: function () { return utils_1.bridgeToBN; } });
+Object.defineProperty(exports, "fromBN", { enumerable: true, get: function () { return utils_1.fromBN; } });
+Object.defineProperty(exports, "keypairFromPrivateKey", { enumerable: true, get: function () { return utils_1.keypairFromPrivateKey; } });
+Object.defineProperty(exports, "makeSigningFunction", { enumerable: true, get: function () { return utils_1.makeSigningFunction; } });
+Object.defineProperty(exports, "findPda", { enumerable: true, get: function () { return utils_1.findPda; } });
+Object.defineProperty(exports, "bufferToHex", { enumerable: true, get: function () { return utils_1.bufferToHex; } });
+Object.defineProperty(exports, "hexToBuffer", { enumerable: true, get: function () { return utils_1.hexToBuffer; } });
+Object.defineProperty(exports, "shortenPublicKey", { enumerable: true, get: function () { return utils_1.shortenPublicKey; } });

package/dist/nord/{actions.d.ts → api/actions.d.ts}

@@ -1,20 +1,20 @@
-import { FillMode, Side } from "../types";
-import { BigIntValue } from "../utils";
 import Decimal from "decimal.js";
-declare function createSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
+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<string>, currentTimestamp: bigint, nonce: number, params: {
+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<string>, currentTimestamp: bigint, nonce: number, params: {
+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<string>, currentTimestamp: bigint, nonce: number, params: {
+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: {

package/dist/nord/{actions.js → api/actions.js}

@@ -40,20 +40,16 @@ exports.withdraw = withdraw;
 exports.placeOrder = placeOrder;
 exports.cancelOrder = cancelOrder;
 exports.transfer = transfer;
-const ethers_1 = require("ethers");
-const types_1 = require("../types");
-const utils_1 = require("../utils");
-const proto = __importStar(require("../gen/nord"));
+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,
-        ...ethers_1.ethers.getBytes(signature.slice(0, -2)),
-    ]);
+    return new Uint8Array([...message, ...signature]);
 }
 function makeSendHttp(serverUrl) {
     return async (body) => {
@@ -78,7 +74,7 @@ async function sendAction(sendFn, makeSignedMessage, action, actionErrorDesc) {
     return resp;
 }
 async function createSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
-    (0, utils_1.checkPubKeyLength)(types_1.KeyType.Secp256k1, params.userPubkey.length);
+    (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) {
@@ -228,7 +224,7 @@ async function transferImpl(sendFn, signFn, currentTimestamp, nonce, params) {
     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.toAccountId;
+            return resp.kind.value.toUserAccount;
         }
         else {
             return undefined;

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 index_1 = require("../../websocket/index");
+const NordError_1 = require("../utils/NordError");
+/**
+ * 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/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,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,
+        });
+    }
+}