@n1xyz/nord-ts 0.1.6 → 0.1.7

package/src/gen/openapi.ts

@@ -1232,6 +1232,44 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/admin": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description List of assigned admins. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": [
+                            string,
+                            components["schemas"]["AclRole"]
+                        ][];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/tv": {
         parameters: {
             query?: never;
@@ -2689,6 +2727,8 @@ export interface components {
             accountId: number;
             feeTier: components["schemas"]["FeeTierId"];
         };
+        /** Format: uint32 */
+        AclRole: number;
         /** @description TV config query response https://www.tradingview.com/charting-library-docs/latest/connecting_data/UDF/#data-feed-configuration-data */
         TvConfigResponse: {
             supported_resolutions: components["schemas"]["Resolution"][];

package/src/index.ts

@@ -1,5 +1,11 @@
 export * from "./types";
 export * from "./utils";
 export * from "./const";
-export * from "./nord";
+export * from "./error";
 export * from "./websocket/index";
+export * from "./client/Nord";
+export * from "./client/NordUser";
+export * from "./client/NordAdmin";
+
+export * as proto from "./gen/nord_pb";
+export * as openapi from "./gen/openapi";

package/src/types.ts

@@ -2,23 +2,7 @@ import * as proto from "./gen/nord_pb";
 import type { components } from "./gen/openapi.ts";
 import Decimal from "decimal.js";
 import { toScaledU64 } from "./utils";
-
-/**
- * The peak TPS rate is queried over the specified period.
- * The period is specified in units of: {hour, day, week, month, year}.
- * Example inputs:
- *  1. AggregateMetrics.txPeakTpsPeriod = 3,
- *     AggregateMetrics.txPeakTpsPeriodUnit = "d" => Peak TPS over last 3 days.
- *  1. AggregateMetrics.txPeakTpsPeriod = 1,
- *     AggregateMetrics.txPeakTpsPeriodUnit = "w" => Peak TPS over last week.
- */
-export enum PeakTpsPeriodUnit {
-  Hour = "h",
-  Day = "d",
-  Week = "w",
-  Month = "m",
-  Year = "y",
-}
+import { Connection } from "@solana/web3.js";
 
 /**
  * Nord subscription type for trades or deltas
@@ -40,8 +24,8 @@ export interface NordConfig {
   webServerUrl: string;
   /** App address */
   app: string;
-  /** Solana cluster URL */
-  solanaUrl: string;
+  /** Solana connection */
+  solanaConnection: Connection;
   /** Proton URL, defaults to webServerUrl */
   // TODO: this is ass. move to NordUser.
   protonUrl?: string;
@@ -124,12 +108,6 @@ export interface Order {
   marketId: number;
 }
 
-export enum KeyType {
-  Ed25519,
-  Secp256k1,
-  Bls12_381,
-}
-
 export enum Side {
   Ask = "ask",
   Bid = "bid",
@@ -200,34 +178,6 @@ export interface ActionResponse {
   physicalExecTime: Date;
 }
 
-/**
- * Block summary.
- * block_number Block number.
- * from_action_id First action_id in the block.
- * to_action_id Last action_id in the block.
- */
-export interface BlockSummary {
-  block_number: number;
-  from_action_id: number;
-  to_action_id: number;
-}
-
-/**
- * Aggregate metrics
- * blocks_total: Total number of L2 blocks.
- * tx_total: Total number of transactions.
- * tx_tps: Transaction throughput.
- * tx_tps_peak: Peak transaction throughput.
- * request_latency_average: Average request latency.
- */
-export interface AggregateMetrics {
-  blocks_total: number;
-  tx_total: number;
-  tx_tps: number;
-  tx_tps_peak: number;
-  request_latency_average: number;
-}
-
 /**
  * Converts a `FillMode` enum to its corresponding protobuf representation.
  *
@@ -261,7 +211,7 @@ export interface OrderbookEntry {
  */
 export interface OrderbookQuery {
   symbol?: string;
-  market_id?: number;
+  marketId?: number;
 }
 
 /**

package/src/utils.ts

@@ -1,9 +1,5 @@
 import { Decimal } from "decimal.js";
-import { ed25519 } from "@noble/curves/ed25519";
-import { bls12_381 as bls } from "@noble/curves/bls12-381";
-import { secp256k1 as secp } from "@noble/curves/secp256k1";
-import { sha256 } from "@noble/hashes/sha256";
-import { KeyType, type Market, type Token } from "./types";
+import { type Market, type Token } from "./types";
 import { sizeDelimitedPeek } from "@bufbuild/protobuf/wire";
 import { fromBinary, type Message } from "@bufbuild/protobuf";
 import type { GenMessage } from "@bufbuild/protobuf/codegenv2";
@@ -12,6 +8,7 @@ import fetch from "node-fetch";
 import { RequestInfo, RequestInit, Response } from "node-fetch";
 import { Keypair } from "@solana/web3.js";
 import bs58 from "bs58";
+import * as solana from "@solana/web3.js";
 
 export const SESSION_TTL: bigint = 60n * 60n * 24n * 30n;
 export const ZERO_DECIMAL = new Decimal(0);
@@ -33,7 +30,10 @@ export function isRfc3339(s: string): boolean {
   return REGEX.test(s);
 }
 
-export function assert(predicate: boolean, message?: string): void {
+export function assert(
+  predicate: boolean,
+  message?: string,
+): asserts predicate {
   if (!predicate) panic(message ?? "Assertion violated");
 }
 /**
@@ -62,31 +62,6 @@ export async function checkedFetch(
   return resp;
 }
 
-/**
- * Signs an action using the specified secret key and key type.
- * @param action - The action data to be signed.
- * @param sk - Secret key used for signing the action.
- * @param keyType - Type of the key used for signing.
- * @returns A new Uint8Array containing the action followed by its signature.
- */
-export function signAction(
-  action: Uint8Array,
-  sk: Uint8Array,
-  keyType: KeyType,
-): Uint8Array {
-  let sig: Uint8Array;
-  if (keyType === KeyType.Ed25519) {
-    sig = ed25519.sign(action, sk);
-  } else if (keyType === KeyType.Bls12_381) {
-    sig = bls.sign(action, sk);
-  } else if (keyType === KeyType.Secp256k1) {
-    sig = secp.sign(sha256(action), sk).toCompactRawBytes();
-  } else {
-    throw new Error("Invalid key type");
-  }
-  return new Uint8Array([...action, ...sig]);
-}
-
 /**
  * Constructs wallet signing function, usable with `NordUser` type
  *
@@ -217,22 +192,6 @@ export function decodeLengthDelimited<T extends Message>(
   );
 }
 
-export function checkPubKeyLength(keyType: KeyType, len: number): void {
-  if (keyType === KeyType.Bls12_381) {
-    throw new Error(
-      "Cannot create a user using Bls12_381, use Ed25119 or Secp256k1 instead.",
-    );
-  }
-
-  if (len !== 32 && keyType === KeyType.Ed25519) {
-    throw new Error("Ed25519 pubkeys must be 32 length.");
-  }
-
-  if (len !== 33 && keyType === KeyType.Secp256k1) {
-    throw new Error("Secp256k1 pubkeys must be 33 length.");
-  }
-}
-
 export function decodeHex(value: string): Uint8Array {
   const hex = value.startsWith("0x") ? value.slice(2) : value;
   return Uint8Array.from(Buffer.from(hex, "hex"));
@@ -267,3 +226,41 @@ export function keypairFromPrivateKey(
   }
   return Keypair.fromSecretKey(privateKey);
 }
+
+export async function signUserPayload({
+  payload,
+  user,
+  signTransaction,
+}: Readonly<{
+  payload: Uint8Array;
+  user: solana.PublicKey;
+  signTransaction: (tx: solana.Transaction) => Promise<solana.Transaction>;
+}>): Promise<Uint8Array> {
+  const tx = new solana.Transaction({
+    blockhash: bs58.encode(new Uint8Array(32)),
+    lastValidBlockHeight: 0,
+    feePayer: user,
+  });
+  tx.add(
+    new solana.TransactionInstruction({
+      keys: [],
+      programId: user,
+      data: Buffer.from(payload),
+    }),
+  );
+  const signedTx = await signTransaction(tx);
+  const sig = signedTx.signatures[0];
+  assert(
+    sig.signature !== null,
+    "signature must be non-null; check your signTransaction function",
+  );
+  assert(
+    sig.signature.length === 64, //.
+    "signature must be 64 bytes",
+  );
+  assert(
+    sig.publicKey.equals(user),
+    `signature is for ${sig.publicKey}, expected ${user}`,
+  );
+  return sig.signature;
+}

package/src/{nord/models → websocket}/Subscriber.ts

@@ -6,8 +6,8 @@ import {
   SubscriberConfig,
   StreamTrade,
   Trades,
-} from "../../types";
-import { MAX_BUFFER_LEN } from "../../utils";
+} from "../types";
+import { MAX_BUFFER_LEN } from "../utils";
 
 /**
  * Subscriber class for handling WebSocket subscriptions

package/src/websocket/index.ts

@@ -1,2 +1,105 @@
-export { NordWebSocketClient } from "./NordWebSocketClient";
-export type { NordWebSocketEvents, NordWebSocketClientEvents } from "./events";
+import { NordWebSocketClient } from "./NordWebSocketClient";
+import { NordError } from "../error";
+import type { SubscriptionPattern } from "../types";
+import type { NordWebSocketEvents, NordWebSocketClientEvents } from "./events";
+import { Subscriber } from "./Subscriber";
+
+export {
+  NordWebSocketClient,
+  NordWebSocketEvents,
+  NordWebSocketClientEvents,
+  Subscriber,
+};
+
+/**
+ * Initialize a WebSocket client for Nord
+ *
+ * Connects to the Nord WebSocket endpoint with support for multiple subscription types:
+ * - trades@SYMBOL - For trade updates
+ * - deltas@SYMBOL - For orderbook delta updates
+ * - account@ACCOUNT_ID - For user-specific updates
+ *
+ * @param webServerUrl - Base URL for the Nord web server
+ * @param subscriptions - Array of subscriptions (e.g., ["trades@BTCUSDC", "deltas@BTCUSDC", "account@42"])
+ * @returns WebSocket client
+ * @throws {NordError} If initialization fails or invalid subscription is provided
+ */
+export function initWebSocketClient(
+  webServerUrl: string,
+  subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account",
+): NordWebSocketClient {
+  try {
+    // Determine URL and subscriptions based on parameters
+    let wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws`;
+
+    // Validate subscriptions parameter
+    if (typeof subscriptions === "string") {
+      // Legacy mode - handle endpoint string
+      if (
+        subscriptions === "trades" ||
+        subscriptions === "delta" ||
+        subscriptions === "account"
+      ) {
+        wsUrl += `/${subscriptions}`;
+      } else {
+        throw new NordError(
+          `Invalid endpoint: ${subscriptions}. Must be "trades", "deltas", or "account".`,
+        );
+      }
+    } else if (Array.isArray(subscriptions) && subscriptions.length > 0) {
+      // New mode - validate and combine subscriptions in URL
+      subscriptions.forEach(validateSubscription);
+      wsUrl += `/${subscriptions.join("&")}`;
+    } else {
+      // Default to trades endpoint if no subscriptions specified
+      wsUrl += `/trades`;
+    }
+
+    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");
+    });
+
+    // 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,
+    });
+  }
+}
+
+/**
+ * Validates a subscription string follows the correct format
+ *
+ * @param subscription - The subscription to validate
+ * @throws {NordError} If the subscription format is invalid
+ */
+function validateSubscription(subscription: string): void {
+  const [type, param] = subscription.split("@");
+
+  if (!type || !param || !["trades", "deltas", "account"].includes(type)) {
+    throw new NordError(
+      `Invalid subscription format: ${subscription}. Expected format: "trades@SYMBOL", "deltas@SYMBOL", or "account@ID"`,
+    );
+  }
+
+  // Additional validation for account subscriptions
+  if (type === "account" && isNaN(Number(param))) {
+    throw new NordError(
+      `Invalid account ID in subscription: ${subscription}. Account ID must be a number.`,
+    );
+  }
+}