@n1xyz/nord-ts 0.0.14 → 0.0.16-29f6652

package/src/idl/index.ts

@@ -0,0 +1,2 @@
+import data from "./bridge.json";
+export const BRIDGE_IDL = data;

package/src/nord/api/core.ts

@@ -65,9 +65,7 @@ export async function getAccount(
   accountId: number,
 ): Promise<Account> {
   try {
-    const response = await checkedFetch(
-      `${webServerUrl}/account?account_id=${accountId}`,
-    );
+    const response = await checkedFetch(`${webServerUrl}/account/${accountId}`);
     return await response.json();
   } catch (error) {
     throw new NordError(`Failed to get account ${accountId}`, { cause: error });

package/src/nord/api/metrics.ts

@@ -99,6 +99,7 @@ function calculateTps(text: string): number {
  */
 function calculatePeakTps(text: string): number {
   // For peak TPS, we'll use a simple heuristic: 2x the current TPS estimate
+  // TODO: fix this
   return calculateTps(text) * 2;
 }
 
@@ -109,6 +110,7 @@ function calculatePeakTps(text: string): number {
  * @returns Average latency in seconds
  */
 function extractLatency(text: string): number {
+  // TODO: fix - using average for latency is kinda wack. ok to merge for now but should change.
   const latencySum = extractSummaryValue(text, "nord_requests_ok_latency_sum");
   const latencyCount = extractSummaryValue(
     text,

package/src/nord/client/Nord.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "events";
+import { Connection, PublicKey } from "@solana/web3.js";
 import {
   Account,
   ActionQuery,
@@ -55,8 +56,11 @@ export class Nord {
   /** Base URL for the Nord web server */
   public readonly webServerUrl: string;
 
-  /** Solana program ID */
-  public readonly solanaProgramId: string;
+  /** Bridge verification key */
+  public readonly bridgeVk: string;
+
+  /** Optional Solana program ID (will be derived from bridgeVk) */
+  private _solanaProgramId!: string;
 
   /** Solana RPC URL */
   public readonly solanaUrl: string;
@@ -75,26 +79,26 @@ export class Nord {
    *
    * @param config - Configuration options for the Nord client
    * @param config.webServerUrl - Base URL for the Nord web server
-   * @param config.solanaProgramId - Solana program ID
+   * @param config.bridgeVk - Bridge verification key
    * @param config.solanaUrl - Solana cluster URL
    * @throws {Error} If required configuration is missing
    */
-  constructor({ webServerUrl, solanaProgramId, solanaUrl }: NordConfig) {
-    if (!webServerUrl) {
+  constructor(config: NordConfig) {
+    if (!config.webServerUrl) {
       throw new NordError("webServerUrl is required");
     }
 
-    if (!solanaProgramId) {
-      throw new NordError("solanaProgramId is required");
+    if (!config.bridgeVk) {
+      throw new NordError("bridgeVk is required");
     }
 
-    if (!solanaUrl) {
+    if (!config.solanaUrl) {
       throw new NordError("solanaUrl is required");
     }
 
-    this.webServerUrl = webServerUrl;
-    this.solanaProgramId = solanaProgramId;
-    this.solanaUrl = solanaUrl;
+    this.webServerUrl = config.webServerUrl;
+    this.bridgeVk = config.bridgeVk;
+    this.solanaUrl = config.solanaUrl;
   }
 
   /**
@@ -204,17 +208,49 @@ export class Nord {
    *
    * @param nordConfig - Configuration options for the Nord client
    * @param nordConfig.webServerUrl - Base URL for the Nord web server
-   * @param nordConfig.solanaProgramId - Solana program ID
+   * @param nordConfig.bridgeVk - Bridge verification key
    * @param nordConfig.solanaUrl - Solana cluster URL
    * @returns Initialized Nord client
    * @throws {NordError} If initialization fails
    */
   public static async initNord(nordConfig: NordConfig): Promise<Nord> {
     const nord = new Nord(nordConfig);
-    await nord.fetchNordInfo();
+    await nord.init();
     return nord;
   }
 
+  /**
+   * Initialize the Nord client by deriving program ID and fetching info
+   * @private
+   */
+  private async init(): Promise<void> {
+    const connection = new Connection(this.solanaUrl);
+    const bridgeVkPubkey = new PublicKey(this.bridgeVk);
+
+    const bridgeAccount = await connection.getAccountInfo(bridgeVkPubkey);
+    if (!bridgeAccount) {
+      throw new NordError(`Bridge account ${this.bridgeVk} not found`);
+    }
+
+    this._solanaProgramId = bridgeAccount.owner.toString();
+    await this.fetchNordInfo();
+  }
+
+  /**
+   * Get the Solana program ID derived from bridge VK
+   *
+   * @returns Program ID string
+   * @throws {NordError} If program ID hasn't been initialized
+   */
+  public getSolanaProgramId(): string {
+    if (!this._solanaProgramId) {
+      throw new NordError(
+        "Solana program ID not initialized. Have you called Nord.initNord()?",
+      );
+    }
+    return this._solanaProgramId;
+  }
+
   /**
    * Get market statistics
    *

package/src/nord/client/NordUser.ts

@@ -6,7 +6,9 @@ import {
 } from "@solana/spl-token";
 import { Connection, Keypair, PublicKey, Transaction } from "@solana/web3.js";
 import Decimal from "decimal.js";
-import * as nacl from "tweetnacl";
+import * as ed from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha512";
+ed.etc.sha512Sync = sha512;
 import { SolanaBridgeClient } from "../../bridge/client";
 import { SPLTokenInfo } from "../../bridge/types";
 import { keypairFromPrivateKey } from "../../bridge/utils";
@@ -300,7 +302,7 @@ export class NordUser {
     if (
       !this.getSolanaPublicKey() ||
       !this.connection ||
-      !this.nord.solanaProgramId
+      !this.nord.getSolanaProgramId()
     ) {
       throw new NordError(
         "Solana public key, connection, and program ID are required to initialize bridge client",
@@ -331,9 +333,10 @@ export class NordUser {
     this.bridgeClient = new SolanaBridgeClient(
       {
         rpcUrl: this.connection.rpcEndpoint,
-        programId: this.nord.solanaProgramId,
+        programId: this.nord.getSolanaProgramId(),
         commitment: "confirmed",
         tokenInfos: this.splTokenInfos,
+        bridgeVk: this.nord.bridgeVk,
       },
       wallet,
     );
@@ -361,21 +364,28 @@ export class NordUser {
       const walletSignFn = async (
         message: Uint8Array | string,
       ): Promise<Uint8Array> => {
-        const messageBuffer =
-          typeof message === "string"
-            ? Buffer.from(message)
-            : Buffer.from(message);
+        function toHex(buffer: Uint8Array) {
+          return Array.from(buffer)
+            .map((byte) => byte.toString(16).padStart(2, "0"))
+            .join("");
+        }
+        const messageBuffer = new TextEncoder().encode(
+          toHex(message as Uint8Array),
+        );
 
-        // Use the keypair to sign the message
-        const signature = nacl.sign.detached(messageBuffer, keypair.secretKey);
+        // Use ed25519 to sign the message
+        const signature = ed.sign(
+          messageBuffer,
+          keypair.secretKey.slice(0, 32),
+        );
         return signature;
       };
 
       const sessionSignFn = async (
         message: Uint8Array,
       ): Promise<Uint8Array> => {
-        // Use the keypair to sign the message
-        return nacl.sign.detached(message, keypair.secretKey);
+        // Use ed25519 to sign the message
+        return ed.sign(message, keypair.secretKey.slice(0, 32));
       };
 
       // Create a transaction signing function
@@ -445,7 +455,7 @@ export class NordUser {
    * @returns Transaction signature
    * @throws {NordError} If required parameters are missing or operation fails
    */
-  async depositSpl(amount: number, tokenId: number): Promise<string> {
+  async depositSpl(amount: number, tokenId: number, recipientAddress?: PublicKey): Promise<string> {
     if (!this.bridgeClient || !this.getSolanaPublicKey() || !this.connection) {
       throw new NordError(
         "Bridge client, Solana public key, and connection are required for deposit",
@@ -462,16 +472,6 @@ export class NordUser {
       const mint = new PublicKey(tokenInfo.mint);
       // Get the user's token account
       const fromAccount = await this.getAssociatedTokenAccount(mint);
-
-      // Get the bridge's token account
-      const [authority] = await this.bridgeClient.findAuthorityPda();
-      const toAccount = await getAssociatedTokenAddress(
-        mint,
-        authority,
-        true,
-        TOKEN_2022_PROGRAM_ID,
-      );
-
       // Convert amount to BN with proper decimals
       const amountBN = utilsToBN(amount, tokenInfo.precision);
 
@@ -480,7 +480,7 @@ export class NordUser {
         amount: amountBN,
         mint,
         fromAccount,
-        toAccount,
+        ...(recipientAddress ? { recipientAddress } : {})
       });
     } catch (error) {
       throw new NordError(
@@ -588,23 +588,23 @@ export class NordUser {
    * @throws {NordError} If the operation fails
    */
   async fetchInfo(): Promise<void> {
-    interface FetchOrder {
+    type OpenOrder = {
       orderId: number;
-      size: number;
-      price: number;
       marketId: number;
       side: "ask" | "bid";
-      originalOrderSize?: number;
+      size: number;
+      price: number;
+      originalOrderSize: number;
       clientOrderId?: number | null;
-    }
+    };
 
-    interface Balance {
+    type Balance = {
       tokenId: number;
       token: string;
       amount: number;
-    }
+    };
 
-    interface Position {
+    type Position = {
       marketId: number;
       openOrders: number;
       perp?: {
@@ -616,9 +616,9 @@ export class NordUser {
         isLong: boolean;
       };
       actionId: number;
-    }
+    };
 
-    interface Margins {
+    type Margins = {
       omf: number;
       mf: number;
       imf: number;
@@ -627,32 +627,31 @@ export class NordUser {
       pon: number;
       pn: number;
       bankruptcy: boolean;
-    }
+    };
 
-    interface Account {
+    type Account = {
       updateId: number;
-      orders: FetchOrder[];
+      orders: OpenOrder[];
       positions: Position[];
       balances: Balance[];
       margins: Margins;
-      actionNonce?: number | null;
-      accountId: number;
-    }
+    };
 
     if (this.accountIds !== undefined) {
-      const accountsData = await Promise.all(
-        this.accountIds.map(async (accountId) => {
-          const response = await checkedFetch(
-            `${this.nord.webServerUrl}/account?account_id=${accountId}`,
-          );
-          const accountData = (await response.json()) as Account;
-          // Ensure we have the correct accountId
-          return {
-            ...accountData,
-            accountId,
-          };
-        }),
-      );
+      const accountsData: (Account & { accountId: number })[] =
+        await Promise.all(
+          this.accountIds.map(async (accountId) => {
+            const response = await checkedFetch(
+              `${this.nord.webServerUrl}/account/${accountId}`,
+            );
+            const accountData = (await response.json()) as Account;
+            // Ensure we have the correct accountId
+            return {
+              ...accountData,
+              accountId,
+            };
+          }),
+        );
 
       for (const accountData of accountsData) {
         // Process balances
@@ -667,13 +666,7 @@ export class NordUser {
 
         // Process orders
         this.orders[accountData.accountId] = accountData.orders.map(
-          (order: {
-            orderId: number;
-            side: string;
-            size: number;
-            price: number;
-            marketId: number;
-          }) => {
+          (order: OpenOrder) => {
             return {
               orderId: order.orderId,
               isLong: order.side === "bid",

package/src/types.ts

@@ -35,8 +35,8 @@ export type SubscriptionPattern = `${SubscriptionType}@${string}` | string;
 export interface NordConfig {
   /** Base URL for the Nord web server */
   webServerUrl: string;
-  /** Solana program ID */
-  solanaProgramId: string;
+  /** Bridge verification key */
+  bridgeVk: string;
   /** Solana cluster URL */
   solanaUrl: string;
   /** Whether to initialize WebSockets on creation, defaults to true */

package/src/websocket/NordWebSocketClient.ts

@@ -145,9 +145,7 @@ export class NordWebSocketClient
   private getWebSocketClass(): any {
     if (this.isBrowser) {
       // In browser environments
-      // @ts-expect-error - Check for WebSocket in globalThis
       if (typeof globalThis !== "undefined" && globalThis.WebSocket) {
-        // @ts-expect-error - Return WebSocket from globalThis
         return globalThis.WebSocket;
       }
       throw new Error("WebSocket is not available in this environment");

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "declaration": true,
     "target": "es2020",
-    "lib": ["es2020"],
+    "lib": ["es2020", "dom"],
     "module": "commonjs",
     "rootDir": "./src",
     "moduleResolution": "Node",

package/dist/idl/bridge.d.ts

@@ -1,2 +0,0 @@
-import { Idl } from "@coral-xyz/anchor";
-export declare const BRIDGE_IDL: Idl;