@n1xyz/nord-ts 0.0.15 → 0.0.17

package/src/nord/client/Nord.ts

@@ -1,5 +1,4 @@
 import { EventEmitter } from "events";
-import { Connection, PublicKey } from "@solana/web3.js";
 import {
   Account,
   ActionQuery,
@@ -22,6 +21,7 @@ import {
   UserAccountIdsQuery,
   UserAccountIdsResponse,
 } from "../../types";
+import { ProtonClient } from "@n1xyz/proton";
 import { NordWebSocketClient } from "../../websocket/index";
 import * as core from "../api/core";
 import * as market from "../api/market";
@@ -29,6 +29,7 @@ import * as metrics from "../api/metrics";
 import * as queries from "../api/queries";
 import { OrderbookSubscription, TradeSubscription } from "../models/Subscriber";
 import { NordError } from "../utils/NordError";
+import { PublicKey, Connection } from "@solana/web3.js";
 
 /**
  * User subscription interface
@@ -57,10 +58,7 @@ export class Nord {
   public readonly webServerUrl: string;
 
   /** Bridge verification key */
-  public readonly bridgeVk: string;
-
-  /** Optional Solana program ID (will be derived from bridgeVk) */
-  private _solanaProgramId!: string;
+  public readonly bridgeVk: PublicKey;
 
   /** Solana RPC URL */
   public readonly solanaUrl: string;
@@ -74,6 +72,9 @@ export class Nord {
   /** Map of symbol to market_id */
   private symbolToMarketId: Map<string, number> = new Map();
 
+  /** Proton client for bridge and indexd operations */
+  public protonClient: ProtonClient;
+
   /**
    * Create a new Nord client
    *
@@ -83,22 +84,21 @@ export class Nord {
    * @param config.solanaUrl - Solana cluster URL
    * @throws {Error} If required configuration is missing
    */
-  constructor(config: NordConfig) {
-    if (!config.webServerUrl) {
-      throw new NordError("webServerUrl is required");
-    }
-
-    if (!config.bridgeVk) {
-      throw new NordError("bridgeVk is required");
-    }
-
-    if (!config.solanaUrl) {
-      throw new NordError("solanaUrl is required");
-    }
-
-    this.webServerUrl = config.webServerUrl;
-    this.bridgeVk = config.bridgeVk;
-    this.solanaUrl = config.solanaUrl;
+  private constructor({
+    bridgeVk,
+    solanaUrl,
+    webServerUrl,
+    protonClient,
+  }: Readonly<{
+    bridgeVk: PublicKey;
+    solanaUrl: string;
+    webServerUrl: string;
+    protonClient: ProtonClient;
+  }>) {
+    this.webServerUrl = webServerUrl;
+    this.bridgeVk = bridgeVk;
+    this.solanaUrl = solanaUrl;
+    this.protonClient = protonClient;
   }
 
   /**
@@ -173,13 +173,13 @@ export class Nord {
   }
 
   /**
-   * Get the next action nonce from the Nord server
+   * Get the last event nonce from the Nord server
    *
    * @returns Next action nonce
    * @throws {NordError} If the request fails
    */
   async getActionNonce(): Promise<number> {
-    return core.getActionNonce(this.webServerUrl);
+    return core.getLastEventNonce(this.webServerUrl);
   }
 
   /**
@@ -213,44 +213,39 @@ export class Nord {
    * @returns Initialized Nord client
    * @throws {NordError} If initialization fails
    */
-  public static async initNord(nordConfig: NordConfig): Promise<Nord> {
-    const nord = new Nord(nordConfig);
+  public static async initNord({
+    bridgeVk: bridgeVk_,
+    solanaUrl,
+    webServerUrl,
+  }: Readonly<NordConfig>): Promise<Nord> {
+    // TODO: we should parametrize the connectionn not have it done here.
+    // this is a dogshit api, only here to be compatible with the shitty
+    // vibecoded code and not break zero one team's workflow.
+    const connection = new Connection(solanaUrl, { commitment: "confirmed" });
+    const bridgeVk = new PublicKey(bridgeVk_);
+    const protonClient = await ProtonClient.init({
+      protonUrl: webServerUrl,
+      bridgeVk,
+      solConn: connection,
+    });
+    const nord = new Nord({
+      bridgeVk,
+      protonClient,
+      solanaUrl,
+      webServerUrl,
+    });
     await nord.init();
     return nord;
   }
 
   /**
-   * Initialize the Nord client by deriving program ID and fetching info
+   * Initialize the Nord client
    * @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

@@ -1,15 +1,15 @@
-import * as anchor from "@coral-xyz/anchor";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ID,
   getAssociatedTokenAddress,
+  TOKEN_PROGRAM_ID,
   TOKEN_2022_PROGRAM_ID,
 } from "@solana/spl-token";
-import { Connection, Keypair, PublicKey, Transaction } from "@solana/web3.js";
+import { Connection, PublicKey, Transaction } from "@solana/web3.js";
 import Decimal from "decimal.js";
-import * as nacl from "tweetnacl";
-import { SolanaBridgeClient } from "../../bridge/client";
-import { SPLTokenInfo } from "../../bridge/types";
-import { keypairFromPrivateKey } from "../../bridge/utils";
+import * as ed from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha512";
+ed.etc.sha512Sync = sha512;
+import { SPLTokenInfo, DepositSplParams } from "@n1xyz/proton";
 import { FillMode, Order, Side } from "../../types";
 import {
   BigIntValue,
@@ -18,6 +18,7 @@ import {
   findToken,
   optExpect,
   toBN as utilsToBN,
+  keypairFromPrivateKey,
 } from "../../utils";
 import {
   cancelOrder,
@@ -119,7 +120,7 @@ export class NordUser {
   public readonly nord: Nord;
 
   /** User's blockchain address */
-  public readonly address: string;
+  public readonly address: PublicKey;
 
   /** Function to sign messages with the user's wallet */
   public readonly walletSignFn: (
@@ -189,10 +190,6 @@ export class NordUser {
   /** Last nonce used */
   public lastNonce = 0;
 
-  // Solana-specific properties
-  /** Solana bridge client */
-  public bridgeClient?: SolanaBridgeClient;
-
   /** Solana connection */
   public connection: Connection;
 
@@ -205,46 +202,48 @@ export class NordUser {
    * @param params - Parameters for creating a NordUser
    * @throws {NordError} If required parameters are missing
    */
-  constructor(params: NordUserParams) {
-    if (!params.nord) {
-      throw new NordError("Nord instance is required");
-    }
-    if (!params.address) {
-      throw new NordError("Address is required");
-    }
-    if (!params.walletSignFn) {
+  constructor({
+    address,
+    nord,
+    publicKey,
+    sessionPubKey,
+    sessionSignFn,
+    transactionSignFn,
+    walletSignFn,
+    connection,
+    sessionId,
+  }: NordUserParams) {
+    if (!walletSignFn) {
       throw new NordError("Wallet sign function is required");
     }
-    if (!params.sessionSignFn) {
+    if (!sessionSignFn) {
       throw new NordError("Session sign function is required");
     }
-    if (!params.sessionPubKey) {
+    if (!sessionPubKey) {
       throw new NordError("Session public key is required");
     }
 
-    this.nord = params.nord;
-    this.address = params.address;
-    this.walletSignFn = params.walletSignFn;
-    this.sessionSignFn = params.sessionSignFn;
-    this.transactionSignFn = params.transactionSignFn;
-    this.sessionPubKey = params.sessionPubKey;
-    this.publicKey = params.publicKey;
+    try {
+      this.address = new PublicKey(address);
+    } catch (error) {
+      throw new NordError("Invalid Solana address", { cause: error });
+    }
+
+    this.nord = nord;
+    this.walletSignFn = walletSignFn;
+    this.sessionSignFn = sessionSignFn;
+    this.transactionSignFn = transactionSignFn;
+    this.sessionPubKey = sessionPubKey;
+    this.publicKey = publicKey;
     this.connection =
-      params.connection ||
-      new Connection(params.nord.solanaUrl, {
+      connection ||
+      new Connection(nord.solanaUrl, {
         commitment: "confirmed",
       });
 
     // Set sessionId if provided
-    if (params.sessionId !== undefined) {
-      this.sessionId = params.sessionId;
-    }
-
-    // Initialize bridge client if needed
-    try {
-      this.initBridgeClient();
-    } catch (error) {
-      console.warn("Failed to initialize bridge client:", error);
+    if (sessionId !== undefined) {
+      this.sessionId = sessionId;
     }
 
     // Convert tokens from info endpoint to SPLTokenInfo
@@ -266,7 +265,7 @@ export class NordUser {
   clone(): NordUser {
     const cloned = new NordUser({
       nord: this.nord,
-      address: this.address,
+      address: this.address.toBase58(),
       walletSignFn: this.walletSignFn,
       sessionSignFn: this.sessionSignFn,
       transactionSignFn: this.transactionSignFn,
@@ -290,56 +289,6 @@ export class NordUser {
     return cloned;
   }
 
-  /**
-   * Initialize the Solana bridge client
-   *
-   * @private
-   * @throws {NordError} If required parameters are missing
-   */
-  private initBridgeClient(): void {
-    if (
-      !this.getSolanaPublicKey() ||
-      !this.connection ||
-      !this.nord.getSolanaProgramId()
-    ) {
-      throw new NordError(
-        "Solana public key, connection, and program ID are required to initialize bridge client",
-      );
-    }
-
-    // Create an Anchor wallet that uses walletSignFn for signing
-    const wallet: anchor.Wallet = {
-      publicKey: this.getSolanaPublicKey(),
-      signTransaction: async (tx: any) => {
-        return await this.transactionSignFn(tx);
-      },
-      signAllTransactions: async (txs: any[]) => {
-        return Promise.all(
-          txs.map(async (tx) => {
-            return await this.transactionSignFn(tx);
-          }),
-        );
-      },
-      // Create a keypair-like object with just the public key
-      payer: {
-        publicKey: this.getSolanaPublicKey(),
-        secretKey: new Uint8Array(64), // Dummy secret key to satisfy the type
-      } as Keypair,
-    };
-
-    // Initialize the bridge client
-    this.bridgeClient = new SolanaBridgeClient(
-      {
-        rpcUrl: this.connection.rpcEndpoint,
-        programId: this.nord.getSolanaProgramId(),
-        commitment: "confirmed",
-        tokenInfos: this.splTokenInfos,
-        bridgeVk: this.nord.bridgeVk,
-      },
-      wallet,
-    );
-  }
-
   /**
    * Create a NordUser from a private key
    *
@@ -362,29 +311,36 @@ 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
       const transactionSignFn = async (transaction: any): Promise<any> => {
         // This is a basic implementation - actual implementation would depend on the transaction type
-        if (transaction.serializeMessage) {
+        if (transaction.sign) {
           // Solana transaction
-          transaction.sign([keypair]);
+          transaction.sign(keypair);
           return transaction;
         }
 
@@ -424,13 +380,31 @@ export class NordUser {
     }
 
     try {
-      return await getAssociatedTokenAddress(
+      // Get the token program ID from the mint account
+      const mintAccount = await this.connection.getAccountInfo(mint);
+      if (!mintAccount) {
+        throw new NordError("Mint account not found");
+      }
+      const tokenProgramId = mintAccount.owner;
+
+      // Validate that the mint is owned by a supported SPL token program
+      if (
+        !tokenProgramId.equals(TOKEN_PROGRAM_ID) &&
+        !tokenProgramId.equals(TOKEN_2022_PROGRAM_ID)
+      ) {
+        throw new NordError(
+          "Mint Account is not owned by a supported SPL token program",
+        );
+      }
+
+      const associatedTokenAddress = await getAssociatedTokenAddress(
         mint,
         this.getSolanaPublicKey(),
         false,
-        TOKEN_2022_PROGRAM_ID,
+        tokenProgramId,
         ASSOCIATED_TOKEN_PROGRAM_ID,
       );
+      return associatedTokenAddress;
     } catch (error) {
       throw new NordError("Failed to get associated token account", {
         cause: error,
@@ -447,12 +421,6 @@ export class NordUser {
    * @throws {NordError} If required parameters are missing or operation fails
    */
   async depositSpl(amount: number, tokenId: number): Promise<string> {
-    if (!this.bridgeClient || !this.getSolanaPublicKey() || !this.connection) {
-      throw new NordError(
-        "Bridge client, Solana public key, and connection are required for deposit",
-      );
-    }
-
     try {
       // Find the token info
       const tokenInfo = this.splTokenInfos.find((t) => t.tokenId === tokenId);
@@ -463,82 +431,43 @@ export class NordUser {
       const mint = new PublicKey(tokenInfo.mint);
       // Get the user's token account
       const fromAccount = await this.getAssociatedTokenAccount(mint);
+
       // Convert amount to BN with proper decimals
       const amountBN = utilsToBN(amount, tokenInfo.precision);
 
-      // Deposit tokens
-      return await this.bridgeClient.depositSpl({
+      // Create deposit parameters
+      const depositParams: DepositSplParams = {
         amount: amountBN,
         mint,
         fromAccount,
-      });
-    } catch (error) {
-      throw new NordError(
-        `Failed to deposit ${amount} of token ID ${tokenId}`,
-        { cause: error },
-      );
-    }
-  }
+      };
 
-  /**
-   * Withdraw SPL tokens from the bridge
-   *
-   * @param claim - Claim data
-   * @returns Transaction signature
-   * @throws {NordError} If required parameters are missing or operation fails
-   */
-  async withdrawSpl(claim: any): Promise<string> {
-    if (!this.bridgeClient || !this.getSolanaPublicKey() || !this.connection) {
-      throw new NordError(
-        "Bridge client, Solana public key, and connection are required for withdrawal",
+      // Build the deposit transaction using proton client
+      const depositTx = await this.nord.protonClient.buildDepositTx(
+        depositParams,
+        this.getSolanaPublicKey(),
+        this.connection,
       );
-    }
 
-    try {
-      // Find the token info
-      const tokenInfo = this.splTokenInfos.find(
-        (t) => t.tokenId === claim.tokenId,
-      );
-      if (!tokenInfo) {
-        throw new NordError(`Token with ID ${claim.tokenId} not found`);
-      }
+      const { blockhash } = await this.connection.getLatestBlockhash();
 
-      const mint = new PublicKey(tokenInfo.mint);
+      depositTx.recentBlockhash = blockhash;
+      depositTx.feePayer = this.getSolanaPublicKey();
 
-      // Get the user's token account
-      const toAccount = await this.getAssociatedTokenAccount(mint);
+      const signedTx = await this.transactionSignFn(depositTx);
 
-      // Get the bridge's token account
-      const [authority] = await this.bridgeClient.findAuthorityPda();
-      const fromAccount = await getAssociatedTokenAddress(
-        mint,
-        authority,
-        true,
-        TOKEN_2022_PROGRAM_ID,
+      // TODO: should use `VersionedTransaction` and remove any for `transactionSignFn`,
+      // this is incredibly annoying to debug and i could've saved 30 mins.
+      const signature = await this.connection.sendRawTransaction(
+        signedTx.serialize(),
       );
 
-      // Create a transaction signer that uses walletSignFn
-      const transactionSigner = {
-        publicKey: this.getSolanaPublicKey(),
-        secretKey: new Uint8Array(64), // Dummy secret key, not actually used
-        sign: async (tx: Transaction) => {
-          const message = tx.serializeMessage();
-          await this.walletSignFn(message);
-          return tx;
-        },
-      };
-
-      // Withdraw tokens
-      return await this.bridgeClient.withdraw(
-        {
-          claim,
-          fromAccount,
-          toAccount,
-        },
-        transactionSigner as unknown as Keypair, // Type cast to satisfy the API
-      );
+      return signature;
     } catch (error) {
-      throw new NordError("Failed to withdraw SPL tokens", { cause: error });
+      throw new NordError(
+        `Failed to deposit ${amount} of token ID ${tokenId}`,
+        { cause: error },
+      );
     }
   }
 
@@ -738,10 +667,13 @@ export class NordUser {
    * @param amount - Amount to withdraw
    * @throws {NordError} If the operation fails
    */
-  async withdraw(tokenId: number, amount: number): Promise<void> {
+  async withdraw(
+    tokenId: number,
+    amount: number,
+  ): Promise<{ actionId: bigint }> {
     try {
       this.checkSessionValidity();
-      await withdraw(
+      const { actionId } = await withdraw(
         this.nord.webServerUrl,
         this.sessionSignFn,
         await this.nord.getTimestamp(),
@@ -753,6 +685,7 @@ export class NordUser {
           amount,
         },
       );
+      return { actionId };
     } catch (error) {
       throw new NordError(
         `Failed to withdraw ${amount} of token ID ${tokenId}`,
@@ -804,7 +737,7 @@ export class NordUser {
    * Cancel an order
    *
    * @param orderId - Order ID to cancel
-   * @param accountId - Account ID that placed the order
+   * @param providedAccountId - Account ID that placed the order
    * @returns Action ID if successful
    * @throws {NordError} If the operation fails
    */
@@ -980,7 +913,7 @@ export class NordUser {
               try {
                 const tokenBalance = await this.retryWithBackoff(
                   () =>
-                    this.connection!.getTokenAccountBalance(
+                    this.connection.getTokenAccountBalance(
                       associatedTokenAddress,
                     ),
                   maxRetries,
@@ -1026,10 +959,6 @@ export class NordUser {
    * @returns The Solana public key
    */
   getSolanaPublicKey(): PublicKey {
-    try {
-      return new PublicKey(this.address);
-    } catch (error) {
-      throw new NordError("Invalid Solana address", { cause: error });
-    }
+    return this.address;
   }
 }

package/src/nord/utils/NordError.ts

@@ -60,11 +60,15 @@ export class NordError extends Error {
     let result = `${this.name}: ${this.message}`;
 
     if (this.statusCode) {
-      result += ` (Status: ${this.statusCode})`;
+      result += `  \nstatus: ${this.statusCode}`;
     }
 
     if (this.details && Object.keys(this.details).length > 0) {
-      result += `\nDetails: ${JSON.stringify(this.details, null, 2)}`;
+      result += `  \ndetails: ${JSON.stringify(this.details, null, 2)}`;
+    }
+
+    if (this.cause) {
+      result += `  \ncause: ${this.cause.toString()}`;
     }
 
     return result;