@n1xyz/nord-ts 0.0.4 → 0.0.7

package/src/index.ts

@@ -1,17 +1,17 @@
 // Export types
-export * from './types';
-export * from './utils';
-export * from './const';
+export * from "./types";
+export * from "./utils";
+export * from "./const";
 
 // Export Nord modules
-export * from './nord';
+export * from "./nord";
 
 // Export WebSocket modules
-export * from './websocket/index';
+export * from "./websocket/index";
 
 // Export bridge modules
-export * from './bridge/client';
-export * from './bridge/types';
+export * from "./bridge/client";
+export * from "./bridge/types";
 export {
   bridgeToBN,
   fromBN,
@@ -21,4 +21,4 @@ export {
   bufferToHex,
   hexToBuffer,
   shortenPublicKey,
-} from './bridge/utils';
+} from "./bridge/utils";

package/src/nord/api/actions.ts

@@ -1,6 +1,6 @@
-import Decimal from 'decimal.js';
-import * as proto from '../../gen/nord';
-import { FillMode, fillModeToProtoFillMode, KeyType, Side } from '../../types';
+import Decimal from "decimal.js";
+import * as proto from "../../gen/nord";
+import { FillMode, fillModeToProtoFillMode, KeyType, Side } from "../../types";
 import {
   assert,
   bigIntToProtoU128,
@@ -13,7 +13,7 @@ import {
   SESSION_TTL,
   toScaledU128,
   toScaledU64,
-} from '../../utils';
+} from "../../utils";
 
 async function sessionSign(
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
@@ -36,9 +36,9 @@ function makeSendHttp(
 ): (encoded: Uint8Array) => Promise<Uint8Array> {
   return async (body) => {
     const response = await checkedFetch(`${serverUrl}/action`, {
-      method: 'POST',
+      method: "POST",
       headers: {
-        'Content-Type': 'application/json',
+        "Content-Type": "application/json",
       },
       body,
     });
@@ -57,7 +57,7 @@ async function sendAction(
   const rawResp = await sendFn(body);
   const resp: proto.Receipt = decodeLengthDelimited(rawResp, proto.Receipt);
 
-  if (resp.kind?.$case === 'err') {
+  if (resp.kind?.$case === "err") {
     throw new Error(
       `Could not ${actionErrorDesc}, reason: ${proto.errorToJSON(resp.kind.value)}`,
     );
@@ -87,7 +87,7 @@ async function createSessionImpl(
     expiry = params.expiryTimestamp;
     assert(
       expiry > currentTimestamp,
-      'Cannot set expiry timestamp in the past',
+      "Cannot set expiry timestamp in the past",
     );
   } else {
     expiry = currentTimestamp + SESSION_TTL;
@@ -97,7 +97,7 @@ async function createSessionImpl(
     currentTimestamp,
     nonce,
     kind: {
-      $case: 'createSession',
+      $case: "createSession",
       value: {
         userPubkey: params.userPubkey,
         blstPubkey: params.sessionPubkey,
@@ -110,10 +110,10 @@ async function createSessionImpl(
     sendFn,
     (m) => walletSign(walletSignFn, m),
     action,
-    'create a new session',
+    "create a new session",
   );
 
-  if (resp.kind?.$case === 'createSessionResult') {
+  if (resp.kind?.$case === "createSessionResult") {
     return resp.kind.value.sessionId;
   } else {
     throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
@@ -154,7 +154,7 @@ async function revokeSessionImpl(
     currentTimestamp,
     nonce,
     kind: {
-      $case: 'revokeSession',
+      $case: "revokeSession",
       value: {
         sessionId: BigInt(params.sessionId),
       },
@@ -165,7 +165,7 @@ async function revokeSessionImpl(
     sendFn,
     (m) => walletSign(walletSignFn, m),
     action,
-    'create a new session',
+    "create a new session",
   );
 }
 
@@ -202,14 +202,14 @@ async function withdrawImpl(
   const amount = toScaledU64(params.amount, params.sizeDecimals);
 
   if (amount <= 0) {
-    throw new Error('Withdraw amount must be positive');
+    throw new Error("Withdraw amount must be positive");
   }
 
   const action: proto.Action = {
     currentTimestamp,
     nonce,
     kind: {
-      $case: 'withdraw',
+      $case: "withdraw",
       value: {
         sessionId: BigInt(params.sessionId),
         tokenId: params.tokenId,
@@ -218,7 +218,7 @@ async function withdrawImpl(
     },
   };
 
-  await sendAction(sendFn, (m) => sessionSign(signFn, m), action, 'withdraw');
+  await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "withdraw");
 }
 
 export async function withdraw(
@@ -276,7 +276,7 @@ async function placeOrderImpl(
     currentTimestamp,
     nonce,
     kind: {
-      $case: 'placeOrder',
+      $case: "placeOrder",
       value: {
         sessionId: BigInt(params.sessionId),
         senderAccountId: params.senderId,
@@ -297,10 +297,10 @@ async function placeOrderImpl(
     sendFn,
     (m) => sessionSign(signFn, m),
     action,
-    'place the order',
+    "place the order",
   );
 
-  if (resp.kind?.$case === 'placeOrderResult') {
+  if (resp.kind?.$case === "placeOrderResult") {
     return resp.kind.value.posted?.orderId;
   } else {
     throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
@@ -353,7 +353,7 @@ async function cancelOrderImpl(
     currentTimestamp,
     nonce: nonce,
     kind: {
-      $case: 'cancelOrderById',
+      $case: "cancelOrderById",
       value: {
         orderId: BigInt(params.orderId),
         sessionId: BigInt(params.sessionId),
@@ -367,10 +367,10 @@ async function cancelOrderImpl(
     sendFn,
     (m) => sessionSign(signFn, m),
     action,
-    'cancel the order',
+    "cancel the order",
   );
 
-  if (resp.kind?.$case === 'cancelOrderResult') {
+  if (resp.kind?.$case === "cancelOrderResult") {
     return resp.kind.value.orderId;
   } else {
     throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
@@ -416,7 +416,7 @@ async function transferImpl(
     currentTimestamp,
     nonce: nonce,
     kind: {
-      $case: 'transfer',
+      $case: "transfer",
       value: {
         sessionId: BigInt(params.sessionId),
         fromAccountId: params.fromAccountId,
@@ -431,10 +431,10 @@ async function transferImpl(
     sendFn,
     (m) => sessionSign(signFn, m),
     action,
-    'transfer asset to other account',
+    "transfer asset to other account",
   );
 
-  if (resp.kind?.$case === 'transferred') {
+  if (resp.kind?.$case === "transferred") {
     if (resp.kind.value.accountCreated) {
       return resp.kind.value.toUserAccount;
     } else {

package/src/nord/api/core.ts

@@ -1,7 +1,7 @@
-import { Account, Info, NordConfig, TokenInfo } from '../../types';
-import { checkedFetch } from '../../utils';
-import { NordError } from '../utils/NordError';
-import { NordWebSocketClient } from '../../websocket/index';
+import { Account, Info } from "../../types";
+import { checkedFetch } from "../../utils";
+import { NordWebSocketClient } from "../../websocket/index";
+import { NordError } from "../utils/NordError";
 
 /**
  * Get the current timestamp from the Nord server
@@ -15,7 +15,7 @@ export async function getTimestamp(webServerUrl: string): Promise<bigint> {
     const response = await checkedFetch(`${webServerUrl}/timestamp`);
     return BigInt(await response.json());
   } catch (error) {
-    throw new NordError('Failed to get timestamp', { cause: error });
+    throw new NordError("Failed to get timestamp", { cause: error });
   }
 }
 
@@ -32,7 +32,7 @@ export async function getActionNonce(webServerUrl: string): Promise<number> {
     const data = await response.json();
     return data.nonce;
   } catch (error) {
-    throw new NordError('Failed to get action nonce', { cause: error });
+    throw new NordError("Failed to get action nonce", { cause: error });
   }
 }
 
@@ -48,7 +48,7 @@ export async function getInfo(webServerUrl: string): Promise<Info> {
     const response = await checkedFetch(`${webServerUrl}/info`);
     return await response.json();
   } catch (error) {
-    throw new NordError('Failed to get info', { cause: error });
+    throw new NordError("Failed to get info", { cause: error });
   }
 }
 
@@ -89,28 +89,28 @@ export async function getAccount(
  */
 export function initWebSocketClient(
   webServerUrl: string,
-  endpoint?: 'trades' | 'deltas' | 'user',
+  endpoint?: "trades" | "deltas" | "user",
   initialSubscriptions?: string[],
 ): NordWebSocketClient {
   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 specificEndpoint = endpoint || "trades";
     const wsUrl =
-      webServerUrl.replace(/^http/, 'ws') + `/ws/${specificEndpoint}`;
+      webServerUrl.replace(/^http/, "ws") + `/ws/${specificEndpoint}`;
     console.log(`Initializing WebSocket client with URL: ${wsUrl}`);
 
     // Create and connect the WebSocket client
     const ws = new NordWebSocketClient(wsUrl);
 
     // Add error handler
-    ws.on('error', (error) => {
-      console.error('Nord WebSocket error:', error);
+    ws.on("error", (error) => {
+      console.error("Nord WebSocket error:", error);
     });
 
     // Add connected handler for debugging
-    ws.on('connected', () => {
-      console.log('Nord WebSocket connected successfully');
+    ws.on("connected", () => {
+      console.log("Nord WebSocket connected successfully");
 
       // Subscribe to initial subscriptions if provided
       if (initialSubscriptions && initialSubscriptions.length > 0) {
@@ -122,8 +122,8 @@ export function initWebSocketClient(
     ws.connect();
     return ws;
   } catch (error) {
-    console.error('Failed to initialize WebSocket client:', error);
-    throw new NordError('Failed to initialize WebSocket client', {
+    console.error("Failed to initialize WebSocket client:", error);
+    throw new NordError("Failed to initialize WebSocket client", {
       cause: error,
     });
   }

package/src/nord/api/market.ts

@@ -6,9 +6,9 @@ import {
   TradesResponse,
   UserAccountIdsQuery,
   UserAccountIdsResponse,
-} from '../../types';
-import { checkedFetch } from '../../utils';
-import { NordError } from '../utils/NordError';
+} from "../../types";
+import { checkedFetch } from "../../utils";
+import { NordError } from "../utils/NordError";
 
 /**
  * Get market statistics
@@ -24,7 +24,7 @@ export async function marketsStats(
     const response = await checkedFetch(`${webServerUrl}/stats`);
     return await response.json();
   } catch (error) {
-    throw new NordError('Failed to fetch markets stats', { cause: error });
+    throw new NordError("Failed to fetch markets stats", { cause: error });
   }
 }
 
@@ -42,18 +42,18 @@ export async function getTrades(
 ): Promise<TradesResponse> {
   try {
     const params = new URLSearchParams();
-    params.append('accountId', query.accountId.toString());
+    params.append("accountId", query.accountId.toString());
 
     if (query.since) {
-      params.append('since', query.since);
+      params.append("since", query.since);
     }
 
     if (query.until) {
-      params.append('until', query.until);
+      params.append("until", query.until);
     }
 
     if (query.pageId) {
-      params.append('pageId', query.pageId);
+      params.append("pageId", query.pageId);
     }
 
     const response = await checkedFetch(
@@ -61,7 +61,7 @@ export async function getTrades(
     );
     return await response.json();
   } catch (error) {
-    throw new NordError('Failed to get trades', { cause: error });
+    throw new NordError("Failed to get trades", { cause: error });
   }
 }
 
@@ -79,14 +79,14 @@ export async function getUserAccountIds(
 ): Promise<UserAccountIdsResponse> {
   try {
     const params = new URLSearchParams();
-    params.append('pubkey', query.pubkey);
+    params.append("pubkey", query.pubkey);
 
     const response = await checkedFetch(
       `${webServerUrl}/user?${params.toString()}`,
     );
     return await response.json();
   } catch (error) {
-    throw new NordError('Failed to get user account IDs', { cause: error });
+    throw new NordError("Failed to get user account IDs", { cause: error });
   }
 }
 
@@ -106,12 +106,12 @@ export async function getOrderbook(
     const params = new URLSearchParams();
 
     if (query.symbol) {
-      params.append('symbol', query.symbol);
+      params.append("symbol", query.symbol);
     } else if (query.market_id !== undefined) {
-      params.append('market_id', query.market_id.toString());
+      params.append("market_id", query.market_id.toString());
     } else {
       throw new NordError(
-        'Either symbol or market_id must be provided for orderbook query',
+        "Either symbol or market_id must be provided for orderbook query",
       );
     }
 
@@ -120,6 +120,6 @@ export async function getOrderbook(
     );
     return await response.json();
   } catch (error) {
-    throw new NordError('Failed to get orderbook', { cause: error });
+    throw new NordError("Failed to get orderbook", { cause: error });
   }
 }

package/src/nord/api/metrics.ts

@@ -1,18 +1,18 @@
-import { AggregateMetrics, PeakTpsPeriodUnit } from '../../types';
-import { checkedFetch } from '../../utils';
-import { NordError } from '../utils/NordError';
+import { AggregateMetrics, PeakTpsPeriodUnit } from "../../types";
+import { checkedFetch } from "../../utils";
+import { NordError } from "../utils/NordError";
 
 /**
  * Time periods for metrics queries
  */
 export enum MetricPeriod {
-  ONE_MINUTE = '1m',
-  FIVE_MINUTES = '5m',
-  FIFTEEN_MINUTES = '15m',
-  ONE_HOUR = '1h',
-  FOUR_HOURS = '4h',
-  ONE_DAY = '24h',
-  ONE_WEEK = '7d',
+  ONE_MINUTE = "1m",
+  FIVE_MINUTES = "5m",
+  FIFTEEN_MINUTES = "15m",
+  ONE_HOUR = "1h",
+  FOUR_HOURS = "4h",
+  ONE_DAY = "24h",
+  ONE_WEEK = "7d",
 }
 
 /**
@@ -33,12 +33,98 @@ export async function aggregateMetrics(
     const response = await checkedFetch(
       `${webServerUrl}/metrics?tx_peak_tps_period=${txPeakTpsPeriod}&tx_peak_tps_period_unit=${txPeakTpsPeriodUnit}`,
     );
-    return await response.json();
+    
+    // Get the raw text response (Prometheus format)
+    const text = await response.text();
+    
+    // Parse the Prometheus-formatted metrics text into an AggregateMetrics object
+    const metrics: AggregateMetrics = {
+      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('Failed to fetch aggregate metrics', { cause: error });
+    throw new 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: string, metricName: string): number {
+  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: string): number {
+  // 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: string): number {
+  // For peak TPS, we'll use a simple heuristic: 2x the current TPS estimate
+  return calculateTps(text) * 2;
+}
+
+/**
+ * Extract latency from Prometheus metrics
+ * 
+ * @param text - Prometheus-formatted metrics text
+ * @returns Average latency in seconds
+ */
+function extractLatency(text: string): number {
+  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: string, metricName: string): number {
+  const regex = new RegExp(`^${metricName}\\s+([\\d.]+)`, 'm');
+  const match = text.match(regex);
+  return match ? parseFloat(match[1]) : 0;
+}
+
 /**
  * Get current transactions per second
  *
@@ -49,12 +135,13 @@ export async function aggregateMetrics(
  */
 export async function getCurrentTps(
   webServerUrl: string,
-  period: string = '1m',
+  period: string = "1m",
 ): Promise<number> {
   try {
+    // nord_tx_count doesn't exist in the metrics, use nord_requests_ok_count instead
     return await queryPrometheus(
       webServerUrl,
-      `sum(rate(nord_tx_count[${period}]))`,
+      `sum(rate(nord_requests_ok_count[${period}]))`,
     );
   } catch (error) {
     throw new NordError(`Failed to get current TPS for period ${period}`, {
@@ -73,12 +160,13 @@ export async function getCurrentTps(
  */
 export async function getPeakTps(
   webServerUrl: string,
-  period: string = '24h',
+  period: string = "24h",
 ): Promise<number> {
   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_tx_count[1m]))[${period}:])`,
+      `max_over_time(sum(rate(nord_requests_ok_count[1m]))[${period}:])`,
     );
   } catch (error) {
     throw new NordError(`Failed to get peak TPS for period ${period}`, {
@@ -97,12 +185,14 @@ export async function getPeakTps(
  */
 export async function getMedianLatency(
   webServerUrl: string,
-  period: string = '1m',
+  period: string = "1m",
 ): Promise<number> {
   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_tx_latency_ms[${period}])`,
+      `quantile_over_time(0.5, nord_requests_ok_latency[${period}]) * 1000`, // Convert to milliseconds
     );
   } catch (error) {
     throw new NordError(`Failed to get median latency for period ${period}`, {
@@ -122,9 +212,10 @@ export async function getTotalTransactions(
   webServerUrl: string,
 ): Promise<number> {
   try {
-    return await queryPrometheus(webServerUrl, 'sum(nord_tx_count)');
+    // 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('Failed to get total transactions', { cause: error });
+    throw new NordError("Failed to get total transactions", { cause: error });
   }
 }
 
@@ -144,8 +235,24 @@ export async function queryPrometheus(
     const response = await checkedFetch(
       `${webServerUrl}/prometheus?query=${encodeURIComponent(params)}`,
     );
-    const data = await response.json();
-    return data.data.result[0]?.value[1] || 0;
+    
+    // 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 (e) {
+      
+      // 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(`Failed to query Prometheus: ${params}`, {
       cause: error,