@n1xyz/nord-ts 0.0.1 → 0.0.5

package/src/nord/{actions.ts → api/actions.ts}

@@ -1,5 +1,6 @@
-import { ethers } from "ethers";
-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,
@@ -12,9 +13,7 @@ import {
   SESSION_TTL,
   toScaledU128,
   toScaledU64,
-} from "../utils";
-import * as proto from "../gen/nord";
-import Decimal from "decimal.js";
+} from "../../utils";
 
 async function sessionSign(
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
@@ -25,14 +24,11 @@ async function sessionSign(
 }
 
 async function walletSign(
-  walletSignFn: (message: string | Uint8Array) => Promise<string>,
+  walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
   message: Uint8Array,
 ): Promise<Uint8Array> {
   const signature = await walletSignFn(message);
-  return new Uint8Array([
-    ...message,
-    ...ethers.getBytes(signature.slice(0, -2)),
-  ]);
+  return new Uint8Array([...message, ...signature]);
 }
 
 function makeSendHttp(
@@ -72,7 +68,7 @@ async function sendAction(
 
 async function createSessionImpl(
   sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
-  walletSignFn: (message: string | Uint8Array) => Promise<string>,
+  walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
   params: {
@@ -82,7 +78,7 @@ async function createSessionImpl(
     expiryTimestamp?: bigint;
   },
 ): Promise<bigint> {
-  checkPubKeyLength(KeyType.Secp256k1, params.userPubkey.length);
+  checkPubKeyLength(KeyType.Ed25519, params.userPubkey.length);
   checkPubKeyLength(KeyType.Ed25519, params.sessionPubkey.length);
 
   let expiry = 0n;
@@ -126,7 +122,7 @@ async function createSessionImpl(
 
 export async function createSession(
   serverUrl: string,
-  walletSignFn: (message: string | Uint8Array) => Promise<string>,
+  walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
   params: {
@@ -147,7 +143,7 @@ export async function createSession(
 
 async function revokeSessionImpl(
   sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
-  walletSignFn: (message: string | Uint8Array) => Promise<string>,
+  walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
   params: {
@@ -175,7 +171,7 @@ async function revokeSessionImpl(
 
 export async function revokeSession(
   serverUrl: string,
-  walletSignFn: (message: string | Uint8Array) => Promise<string>,
+  walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
   params: {
@@ -440,7 +436,7 @@ async function transferImpl(
 
   if (resp.kind?.$case === "transferred") {
     if (resp.kind.value.accountCreated) {
-      return resp.kind.value.toAccountId;
+      return resp.kind.value.toUserAccount;
     } else {
       return undefined;
     }

package/src/nord/api/core.ts

@@ -0,0 +1,130 @@
+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
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Current timestamp as a bigint
+ * @throws {NordError} If the request fails
+ */
+export async function getTimestamp(webServerUrl: string): Promise<bigint> {
+  try {
+    const response = await checkedFetch(`${webServerUrl}/timestamp`);
+    return BigInt(await response.json());
+  } catch (error) {
+    throw new 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
+ */
+export async function getActionNonce(webServerUrl: string): Promise<number> {
+  try {
+    const response = await checkedFetch(`${webServerUrl}/action_nonce`);
+    const data = await response.json();
+    return data.nonce;
+  } catch (error) {
+    throw new 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
+ */
+export async function getInfo(webServerUrl: string): Promise<Info> {
+  try {
+    const response = await checkedFetch(`${webServerUrl}/info`);
+    return await response.json();
+  } catch (error) {
+    throw new 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
+ */
+export async function getAccount(
+  webServerUrl: string,
+  accountId: number,
+): Promise<Account> {
+  try {
+    const response = await checkedFetch(
+      `${webServerUrl}/account?account_id=${accountId}`,
+    );
+    return await response.json();
+  } catch (error) {
+    throw new 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
+ */
+export function initWebSocketClient(
+  webServerUrl: string,
+  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 wsUrl =
+      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);
+    });
+
+    // 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("Failed to initialize WebSocket client", {
+      cause: error,
+    });
+  }
+}

package/src/nord/api/market.ts

@@ -0,0 +1,125 @@
+import {
+  MarketsStatsResponse,
+  OrderbookQuery,
+  OrderbookResponse,
+  TradesQuery,
+  TradesResponse,
+  UserAccountIdsQuery,
+  UserAccountIdsResponse,
+} from "../../types";
+import { checkedFetch } from "../../utils";
+import { NordError } from "../utils/NordError";
+
+/**
+ * Get market statistics
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @returns Market statistics response
+ * @throws {NordError} If the request fails
+ */
+export async function marketsStats(
+  webServerUrl: string,
+): Promise<MarketsStatsResponse> {
+  try {
+    const response = await checkedFetch(`${webServerUrl}/stats`);
+    return await response.json();
+  } catch (error) {
+    throw new 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
+ */
+export async function getTrades(
+  webServerUrl: string,
+  query: TradesQuery,
+): Promise<TradesResponse> {
+  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 checkedFetch(
+      `${webServerUrl}/trades?${params.toString()}`,
+    );
+    return await response.json();
+  } catch (error) {
+    throw new 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
+ */
+export async function getUserAccountIds(
+  webServerUrl: string,
+  query: UserAccountIdsQuery,
+): Promise<UserAccountIdsResponse> {
+  try {
+    const params = new URLSearchParams();
+    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 });
+  }
+}
+
+/**
+ * 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 async function getOrderbook(
+  webServerUrl: string,
+  query: OrderbookQuery,
+): Promise<OrderbookResponse> {
+  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(
+        "Either symbol or market_id must be provided for orderbook query",
+      );
+    }
+
+    const response = await checkedFetch(
+      `${webServerUrl}/orderbook?${params.toString()}`,
+    );
+    return await response.json();
+  } catch (error) {
+    throw new NordError("Failed to get orderbook", { cause: error });
+  }
+}

package/src/nord/api/metrics.ts

@@ -0,0 +1,154 @@
+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",
+}
+
+/**
+ * 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 async function aggregateMetrics(
+  webServerUrl: string,
+  txPeakTpsPeriod = 1,
+  txPeakTpsPeriodUnit: PeakTpsPeriodUnit = PeakTpsPeriodUnit.Day,
+): Promise<AggregateMetrics> {
+  try {
+    const response = await checkedFetch(
+      `${webServerUrl}/metrics?tx_peak_tps_period=${txPeakTpsPeriod}&tx_peak_tps_period_unit=${txPeakTpsPeriodUnit}`,
+    );
+    return await response.json();
+  } catch (error) {
+    throw new 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
+ */
+export async function getCurrentTps(
+  webServerUrl: string,
+  period: string = "1m",
+): Promise<number> {
+  try {
+    return await queryPrometheus(
+      webServerUrl,
+      `sum(rate(nord_tx_count[${period}]))`,
+    );
+  } catch (error) {
+    throw new 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
+ */
+export async function getPeakTps(
+  webServerUrl: string,
+  period: string = "24h",
+): Promise<number> {
+  try {
+    return await queryPrometheus(
+      webServerUrl,
+      `max_over_time(sum(rate(nord_tx_count[1m]))[${period}:])`,
+    );
+  } catch (error) {
+    throw new 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
+ */
+export async function getMedianLatency(
+  webServerUrl: string,
+  period: string = "1m",
+): Promise<number> {
+  try {
+    return await queryPrometheus(
+      webServerUrl,
+      `quantile_over_time(0.5, nord_tx_latency_ms[${period}])`,
+    );
+  } catch (error) {
+    throw new 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
+ */
+export async function getTotalTransactions(
+  webServerUrl: string,
+): Promise<number> {
+  try {
+    return await queryPrometheus(webServerUrl, "sum(nord_tx_count)");
+  } catch (error) {
+    throw new 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
+ */
+export async function queryPrometheus(
+  webServerUrl: string,
+  params: string,
+): Promise<number> {
+  try {
+    const response = await checkedFetch(
+      `${webServerUrl}/prometheus?query=${encodeURIComponent(params)}`,
+    );
+    const data = await response.json();
+    return data.data.result[0]?.value[1] || 0;
+  } catch (error) {
+    throw new NordError(`Failed to query Prometheus: ${params}`, {
+      cause: error,
+    });
+  }
+}