@n1xyz/nord-ts 0.0.8 → 0.0.10

package/src/nord/api/queries.ts

@@ -12,74 +12,6 @@ import {
 import { checkedFetch } from "../../utils";
 import { NordError } from "../utils/NordError";
 
-/**
- * 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 async function queryBlock(
-  webServerUrl: string,
-  query: BlockQuery,
-): Promise<BlockResponse> {
-  try {
-    const params = new URLSearchParams();
-    if (query.block_number !== undefined) {
-      params.append("block_height", query.block_number.toString());
-    }
-
-    const response = await checkedFetch(
-      `${webServerUrl}/block?${params.toString()}`,
-    );
-    return await response.json();
-  } catch (error) {
-    throw new NordError("Failed to query block", { cause: error });
-  }
-}
-
-/**
- * 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 async function queryLastNBlocks(
-  webServerUrl: string,
-): Promise<BlockResponse> {
-  try {
-    const response = await checkedFetch(`${webServerUrl}/blocks`);
-    return await response.json();
-  } catch (error) {
-    throw new NordError("Failed to query last N blocks", { cause: error });
-  }
-}
-
-/**
- * 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 async function queryRecentBlocks(
-  webServerUrl: string,
-  last_n: number,
-): Promise<BlockSummaryResponse> {
-  try {
-    const response = await checkedFetch(
-      `${webServerUrl}/blocks_summary?last_n=${last_n}`,
-    );
-    return await response.json();
-  } catch (error) {
-    throw new NordError(`Failed to query recent blocks (last ${last_n})`, {
-      cause: error,
-    });
-  }
-}
 
 /**
  * Query a specific action
@@ -112,75 +44,46 @@ export async function queryAction(
  * Query recent actions
  *
  * @param webServerUrl - Base URL for the Nord web server
- * @param last_n - Number of recent actions to query
+ * @param from - Starting action index
+ * @param to - Ending action index
  * @returns Actions response
  * @throws {NordError} If the request fails
  */
 export async function queryRecentActions(
   webServerUrl: string,
-  last_n: number,
+  from: number,
+  to: number,
 ): Promise<ActionsResponse> {
   try {
     const response = await checkedFetch(
-      `${webServerUrl}/actions?last_n=${last_n}`,
+      `${webServerUrl}/actions?from=${from}&to=${to}`,
     );
     return await response.json();
   } catch (error) {
-    throw new NordError(`Failed to query recent actions (last ${last_n})`, {
+    throw new NordError(`Failed to query recent actions (from ${from} to ${to})`, {
       cause: error,
     });
   }
 }
 
 /**
- * Query a block from Rollman
+ * Get the last action ID
  *
  * @param webServerUrl - Base URL for the Nord web server
- * @param query - Block query parameters
- * @returns Rollman block response
+ * @returns Last action ID
  * @throws {NordError} If the request fails
  */
-export async function blockQueryRollman(
+export async function getLastActionId(
   webServerUrl: string,
-  query: BlockQuery,
-): Promise<RollmanBlockResponse> {
+): Promise<number> {
   try {
-    const params = new URLSearchParams();
-    if (query.block_number !== undefined) {
-      params.append("block_height", query.block_number.toString());
-    }
-
-    const response = await checkedFetch(
-      `${webServerUrl}/rollman/block?${params.toString()}`,
-    );
-    return await response.json();
+    const response = await checkedFetch(`${webServerUrl}/last_actionid`);
+    const data = await response.json();
+    return data.last_actionid;
   } catch (error) {
-    throw new NordError("Failed to query Rollman block", { cause: error });
-  }
-}
-
-/**
- * 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 async function blockSummaryQueryRollman(
-  webServerUrl: string,
-  last_n: number,
-): Promise<BlockSummaryResponse> {
-  try {
-    const response = await checkedFetch(
-      `${webServerUrl}/rollman/blocks_summary?last_n=${last_n}`,
-    );
-    return await response.json();
-  } catch (error) {
-    throw new NordError(
-      `Failed to query Rollman block summaries (last ${last_n})`,
-      { cause: error },
-    );
+    throw new NordError("Failed to get last action ID", {
+      cause: error,
+    });
   }
 }
 

package/src/nord/client/Nord.ts

@@ -5,9 +5,6 @@ import {
   ActionResponse,
   ActionsResponse,
   AggregateMetrics,
-  BlockQuery,
-  BlockResponse,
-  BlockSummaryResponse,
   Info,
   Market,
   MarketsStatsResponse,
@@ -17,12 +14,11 @@ import {
   PeakTpsPeriodUnit,
   RollmanActionResponse,
   RollmanActionsResponse,
-  RollmanBlockResponse,
   Token,
   TradesQuery,
   TradesResponse,
   UserAccountIdsQuery,
-  UserAccountIdsResponse,
+  UserAccountIdsResponse
 } from "../../types";
 import { NordWebSocketClient } from "../../websocket/index";
 import * as core from "../api/core";
@@ -240,38 +236,6 @@ export class Nord {
     return market.marketsStats(this.webServerUrl);
   }
 
-  /**
-   * Query a specific block
-   *
-   * @param query - Block query parameters
-   * @returns Block response
-   * @throws {NordError} If the request fails
-   */
-  async queryBlock(query: BlockQuery): Promise<BlockResponse> {
-    return queries.queryBlock(this.webServerUrl, query);
-  }
-
-  /**
-   * Query the last N blocks
-   *
-   * @returns Block response for the last N blocks
-   * @throws {NordError} If the request fails
-   */
-  async queryLastNBlocks(): Promise<BlockResponse> {
-    return queries.queryLastNBlocks(this.webServerUrl);
-  }
-
-  /**
-   * Query recent blocks
-   *
-   * @param last_n - Number of recent blocks to query
-   * @returns Block summary response
-   * @throws {NordError} If the request fails
-   */
-  async queryRecentBlocks(last_n: number): Promise<BlockSummaryResponse> {
-    return queries.queryRecentBlocks(this.webServerUrl, last_n);
-  }
-
   /**
    * Query a specific action
    *
@@ -286,14 +250,25 @@ export class Nord {
   /**
    * Query recent actions
    *
-   * @param last_n - Number of recent actions to query
+   * @param from - Starting action index
+   * @param to - Ending action index
    * @returns Actions response
    * @throws {NordError} If the request fails
    */
-  async queryRecentActions(last_n: number): Promise<ActionsResponse> {
-    return queries.queryRecentActions(this.webServerUrl, last_n);
+  async queryRecentActions(from: number, to: number): Promise<ActionsResponse> {
+    return queries.queryRecentActions(this.webServerUrl, from, to);
   }
 
+  /**
+   * Get the last action ID
+   *
+   * @returns Last action ID
+   * @throws {NordError} If the request fails
+   */
+  async getLastActionId(): Promise<number> {
+    return queries.getLastActionId(this.webServerUrl);
+  }
+  
   /**
    * Fetch aggregate metrics from the Nord API
    *
@@ -356,30 +331,6 @@ export class Nord {
     return metrics.getTotalTransactions(this.webServerUrl);
   }
 
-  /**
-   * Query a block from Rollman
-   *
-   * @param query - Block query parameters
-   * @returns Rollman block response
-   * @throws {NordError} If the request fails
-   */
-  async blockQueryRollman(query: BlockQuery): Promise<RollmanBlockResponse> {
-    return queries.blockQueryRollman(this.webServerUrl, query);
-  }
-
-  /**
-   * Query block summaries from Rollman
-   *
-   * @param last_n - Number of recent blocks to query
-   * @returns Block summary response
-   * @throws {NordError} If the request fails
-   */
-  async blockSummaryQueryRollman(
-    last_n: number,
-  ): Promise<BlockSummaryResponse> {
-    return queries.blockSummaryQueryRollman(this.webServerUrl, last_n);
-  }
-
   /**
    * Query an action from Rollman
    *

package/test.ts

@@ -1,32 +1,34 @@
-import { 
-  aggregateMetrics, 
-  getCurrentTps, 
-  getPeakTps, 
-  getMedianLatency, 
-  getTotalTransactions, 
-  queryPrometheus,
-  MetricPeriod 
-} from './src/nord/api/metrics';
+import { Nord } from './src/nord/client/Nord';
+import { MetricPeriod } from './src/nord/api/metrics';
 import { PeakTpsPeriodUnit } from './src/types';
 
-// Nord URL to use for testing
-const NORD_URL = 'https://zo-devnet.n1.xyz';
+// Configuration for Nord client
+const NORD_CONFIG = {
+  webServerUrl: 'https://zo-devnet.n1.xyz',
+  solanaProgramId: 'nord1111111111111111111111111111111111111',
+  solanaUrl: 'https://api.devnet.solana.com',
+  initWebSockets: false // We don't need WebSockets for these tests
+};
 
 // Function to run all tests
 async function runTests() {
-  console.log('Testing Nord metrics API with URL:', NORD_URL);
+  console.log('Testing Nord API with URL:', NORD_CONFIG.webServerUrl);
   console.log('----------------------------------------');
 
   try {
+    // Initialize Nord client
+    console.log('\nInitializing Nord client...');
+    const nord = await Nord.initNord(NORD_CONFIG);
+    console.log('Nord client initialized successfully');
+
     // Test aggregateMetrics
     console.log('\n1. Testing aggregateMetrics:');
-    const metrics = await aggregateMetrics(NORD_URL);
+    const metrics = await nord.aggregateMetrics();
     console.log('Aggregate Metrics:', JSON.stringify(metrics, null, 2));
 
     // Test with custom parameters
     console.log('\nTesting aggregateMetrics with custom parameters:');
-    const customMetrics = await aggregateMetrics(
-      NORD_URL, 
+    const customMetrics = await nord.aggregateMetrics(
       3, 
       PeakTpsPeriodUnit.Hour
     );
@@ -34,39 +36,64 @@ async function runTests() {
 
     // Test getCurrentTps
     console.log('\n2. Testing getCurrentTps:');
-    const tps1m = await getCurrentTps(NORD_URL, MetricPeriod.ONE_MINUTE);
+    const tps1m = await nord.getCurrentTps(MetricPeriod.ONE_MINUTE);
     console.log(`Current TPS (1m): ${tps1m}`);
     
-    const tps5m = await getCurrentTps(NORD_URL, MetricPeriod.FIVE_MINUTES);
+    const tps5m = await nord.getCurrentTps(MetricPeriod.FIVE_MINUTES);
     console.log(`Current TPS (5m): ${tps5m}`);
 
     // Test getPeakTps
     console.log('\n3. Testing getPeakTps:');
-    const peakTps24h = await getPeakTps(NORD_URL, MetricPeriod.ONE_DAY);
+    const peakTps24h = await nord.getPeakTps(MetricPeriod.ONE_DAY);
     console.log(`Peak TPS (24h): ${peakTps24h}`);
     
-    const peakTps1w = await getPeakTps(NORD_URL, MetricPeriod.ONE_WEEK);
+    const peakTps1w = await nord.getPeakTps(MetricPeriod.ONE_WEEK);
     console.log(`Peak TPS (1w): ${peakTps1w}`);
 
     // Test getMedianLatency
     console.log('\n4. Testing getMedianLatency:');
-    const medianLatency1m = await getMedianLatency(NORD_URL, MetricPeriod.ONE_MINUTE);
+    const medianLatency1m = await nord.getMedianLatency(MetricPeriod.ONE_MINUTE);
     console.log(`Median Latency (1m): ${medianLatency1m} ms`);
     
-    const medianLatency1h = await getMedianLatency(NORD_URL, MetricPeriod.ONE_HOUR);
+    const medianLatency1h = await nord.getMedianLatency(MetricPeriod.ONE_HOUR);
     console.log(`Median Latency (1h): ${medianLatency1h} ms`);
 
     // Test getTotalTransactions
     console.log('\n5. Testing getTotalTransactions:');
-    const totalTx = await getTotalTransactions(NORD_URL);
+    const totalTx = await nord.getTotalTransactions();
     console.log(`Total Transactions: ${totalTx}`);
 
     // Test queryPrometheus with a custom query
     console.log('\n6. Testing queryPrometheus with custom query:');
     const customQuery = 'sum(rate(nord_requests_ok_count[15m]))';
-    const customQueryResult = await queryPrometheus(NORD_URL, customQuery);
+    const customQueryResult = await nord.queryPrometheus(customQuery);
     console.log(`Custom Query Result (${customQuery}): ${customQueryResult}`);
 
+    // Test getLastActionId
+    console.log('\n7. Testing getLastActionId:');
+    const lastActionId = await nord.getLastActionId();
+    console.log(`Last Action ID: ${lastActionId}`);
+
+    // Test queryRecentActions
+    console.log('\n8. Testing queryRecentActions:');
+    // Get 10 recent actions starting from 0
+    const recentActions = await nord.queryRecentActions(0, 10);
+    console.log(`Recent Actions (from 0 to 10):`);
+    console.log(JSON.stringify(recentActions, null, 2));
+
+    // Test queryActionsRange
+    console.log('\n9. Testing queryActionsRange:');
+    // If lastActionId is available, use it to get a range of actions
+    if (lastActionId > 10) {
+      const fromId = Math.max(0, lastActionId - 10);
+      const toId = lastActionId;
+      const actionsRange = await nord.queryRecentActions(fromId, toId);
+      console.log(`Actions Range (from ${fromId} to ${toId}):`);
+      console.log(JSON.stringify(actionsRange, null, 2));
+    } else {
+      console.log('Not enough actions to demonstrate range query');
+    }
+
   } catch (error) {
     console.error('Error running tests:', error);
   }