@n1xyz/nord-ts 0.0.1 → 0.0.4

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(
@@ -40,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,
     });
@@ -61,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)}`,
     );
@@ -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;
@@ -91,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;
@@ -101,7 +97,7 @@ async function createSessionImpl(
     currentTimestamp,
     nonce,
     kind: {
-      $case: "createSession",
+      $case: 'createSession',
       value: {
         userPubkey: params.userPubkey,
         blstPubkey: params.sessionPubkey,
@@ -114,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}`);
@@ -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: {
@@ -158,7 +154,7 @@ async function revokeSessionImpl(
     currentTimestamp,
     nonce,
     kind: {
-      $case: "revokeSession",
+      $case: 'revokeSession',
       value: {
         sessionId: BigInt(params.sessionId),
       },
@@ -169,13 +165,13 @@ async function revokeSessionImpl(
     sendFn,
     (m) => walletSign(walletSignFn, m),
     action,
-    "create a new session",
+    'create a new session',
   );
 }
 
 export async function revokeSession(
   serverUrl: string,
-  walletSignFn: (message: string | Uint8Array) => Promise<string>,
+  walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
   params: {
@@ -206,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,
@@ -222,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(
@@ -280,7 +276,7 @@ async function placeOrderImpl(
     currentTimestamp,
     nonce,
     kind: {
-      $case: "placeOrder",
+      $case: 'placeOrder',
       value: {
         sessionId: BigInt(params.sessionId),
         senderAccountId: params.senderId,
@@ -301,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}`);
@@ -357,7 +353,7 @@ async function cancelOrderImpl(
     currentTimestamp,
     nonce: nonce,
     kind: {
-      $case: "cancelOrderById",
+      $case: 'cancelOrderById',
       value: {
         orderId: BigInt(params.orderId),
         sessionId: BigInt(params.sessionId),
@@ -371,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}`);
@@ -420,7 +416,7 @@ async function transferImpl(
     currentTimestamp,
     nonce: nonce,
     kind: {
-      $case: "transfer",
+      $case: 'transfer',
       value: {
         sessionId: BigInt(params.sessionId),
         fromAccountId: params.fromAccountId,
@@ -435,12 +431,12 @@ 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.toAccountId;
+      return resp.kind.value.toUserAccount;
     } else {
       return undefined;
     }

package/src/nord/api/core.ts

@@ -0,0 +1,130 @@
+import { Account, Info, NordConfig, TokenInfo } from '../../types';
+import { checkedFetch } from '../../utils';
+import { NordError } from '../utils/NordError';
+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 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,
+    });
+  }
+}