@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/nord/core.d.ts

@@ -0,0 +1,48 @@
+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)
+ * @returns WebSocket client
+ */
+export declare function initWebSocketClient(webServerUrl: string, endpoint?: 'trades' | 'deltas' | 'user'): NordWebSocketClient;

package/dist/nord/core.js

@@ -0,0 +1,97 @@
+"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 NordError_1 = require("./utils/NordError");
+const index_1 = require("../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
+ */
+async function getTimestamp(webServerUrl) {
+    try {
+        const response = await (0, utils_1.checkedFetch)(`${webServerUrl}/timestamp`);
+        const data = await response.json();
+        return BigInt(data.timestamp);
+    }
+    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)
+ * @returns WebSocket client
+ */
+function initWebSocketClient(webServerUrl, 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}`;
+    const ws = new index_1.NordWebSocketClient(wsUrl);
+    ws.connect();
+    return ws;
+}

package/dist/nord/index.d.ts

@@ -1,2 +1,9 @@
-export { NordUser } from "./NordUser";
-export { Nord, createWebSocketSubscription, Subscriber } from "./Nord";
+export { Nord } from './client/Nord';
+export { NordUser } from './client/NordUser';
+export { NordError } from './utils/NordError';
+export * from './api/core';
+export * from './api/metrics';
+export * from './api/queries';
+export * from './api/market';
+export * from './api/actions';
+export * from './models/Subscriber';

package/dist/nord/index.js

@@ -1,9 +1,33 @@
 "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 __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.Subscriber = exports.createWebSocketSubscription = exports.Nord = exports.NordUser = void 0;
-var NordUser_1 = require("./NordUser");
-Object.defineProperty(exports, "NordUser", { enumerable: true, get: function () { return NordUser_1.NordUser; } });
-var Nord_1 = require("./Nord");
+exports.NordError = exports.NordUser = exports.Nord = void 0;
+// Export main client classes
+var Nord_1 = require("./client/Nord");
 Object.defineProperty(exports, "Nord", { enumerable: true, get: function () { return Nord_1.Nord; } });
-Object.defineProperty(exports, "createWebSocketSubscription", { enumerable: true, get: function () { return Nord_1.createWebSocketSubscription; } });
-Object.defineProperty(exports, "Subscriber", { enumerable: true, get: function () { return Nord_1.Subscriber; } });
+var NordUser_1 = require("./client/NordUser");
+Object.defineProperty(exports, "NordUser", { enumerable: true, get: function () { return NordUser_1.NordUser; } });
+// Export utility classes
+var NordError_1 = require("./utils/NordError");
+Object.defineProperty(exports, "NordError", { enumerable: true, get: function () { return NordError_1.NordError; } });
+// Export API modules
+__exportStar(require("./api/core"), exports);
+__exportStar(require("./api/metrics"), exports);
+__exportStar(require("./api/queries"), exports);
+__exportStar(require("./api/market"), exports);
+__exportStar(require("./api/actions"), exports);
+// Export models
+__exportStar(require("./models/Subscriber"), exports);

package/dist/nord/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/market.js

@@ -0,0 +1,90 @@
+"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("./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}/markets_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_account_ids?${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();
+        params.append("symbol", query.symbol);
+        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/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/metrics.js

@@ -0,0 +1,124 @@
+"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("./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/models/Subscriber.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from 'events';
+import { DeltaEvent, Trades, Account, SubscriberConfig, OrderbookResponse, Trade } from '../../types';
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+export declare class Subscriber {
+    streamURL: string;
+    buffer: (DeltaEvent | Trades | Account)[];
+    maxBufferLen: number;
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config: SubscriberConfig);
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe(): void;
+}
+/**
+ * Interface for orderbook subscription
+ */
+export interface OrderbookSubscription extends EventEmitter {
+    on(event: 'message', listener: (data: OrderbookResponse) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}
+/**
+ * Interface for trade subscription
+ */
+export interface TradeSubscription extends EventEmitter {
+    on(event: 'message', listener: (data: Trade[]) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}

package/dist/nord/models/Subscriber.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscriber = void 0;
+const ws_1 = __importDefault(require("ws"));
+const utils_1 = require("../../utils");
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+class Subscriber {
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config) {
+        this.streamURL = config.streamURL;
+        this.buffer = [];
+        this.maxBufferLen = config.maxBufferLen ?? utils_1.MAX_BUFFER_LEN;
+    }
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe() {
+        const ws = new ws_1.default(this.streamURL);
+    }
+}
+exports.Subscriber = Subscriber;

package/dist/nord/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>;