@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/nord/NordError.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordError = void 0;
+/**
+ * Custom error class for Nord-related errors
+ * Extends the standard Error class with additional context
+ */
+class NordError extends Error {
+    /**
+     * Create a new NordError
+     *
+     * @param message - Error message
+     * @param options - Additional error options
+     */
+    constructor(message, options) {
+        super(message);
+        // Set the prototype explicitly to ensure instanceof works correctly
+        Object.setPrototypeOf(this, NordError.prototype);
+        // Set the name to the class name for better error messages
+        this.name = 'NordError';
+        // Store the cause if provided
+        if (options?.cause) {
+            this.cause = options.cause;
+        }
+        // Capture stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, NordError);
+        }
+    }
+    /**
+     * Get a string representation of the error including the cause if available
+     *
+     * @returns String representation of the error
+     */
+    toString() {
+        let result = `${this.name}: ${this.message}`;
+        if (this.cause) {
+            if (this.cause instanceof Error) {
+                result += `\nCaused by: ${this.cause.toString()}`;
+            }
+            else {
+                result += `\nCaused by: ${String(this.cause)}`;
+            }
+        }
+        return result;
+    }
+}
+exports.NordError = NordError;

package/dist/nord/NordImpl.d.ts

@@ -1,7 +1,11 @@
+import { Nord } from "./Nord";
 /**
  * Implementation of some functions backing Nord and NordUser as interface,
  * for mocking reasons
  */
-export interface NordImpl {
-    getTimestamp: () => Promise<bigint>;
+export declare class NordImpl {
+    private nord;
+    constructor(nord: Nord);
+    getTimestamp(): Promise<bigint>;
+    getActionNonce(): Promise<number>;
 }

package/dist/nord/NordImpl.js

@@ -1,6 +1,26 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordImpl = void 0;
+const utils_1 = require("../utils");
 /**
  * Implementation of some functions backing Nord and NordUser as interface,
  * for mocking reasons
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+class NordImpl {
+    constructor(nord) {
+        this.nord = nord;
+    }
+    async getTimestamp() {
+        const url = new URL(`${this.nord.webServerUrl}/api/v1/timestamp`);
+        const response = await (0, utils_1.checkedFetch)(url.toString());
+        const json = await response.json();
+        return BigInt(json.timestamp);
+    }
+    async getActionNonce() {
+        const url = new URL(`${this.nord.webServerUrl}/api/v1/action_nonce`);
+        const response = await (0, utils_1.checkedFetch)(url.toString());
+        const json = await response.json();
+        return json.nonce;
+    }
+}
+exports.NordImpl = NordImpl;

package/dist/nord/NordUser.d.ts

@@ -1,13 +1,87 @@
-import { BrowserProvider } from "ethers";
-import { BigIntValue } from "../utils";
+import Decimal from "decimal.js";
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import { FillMode, Order, Side } from "../types";
+import { BigIntValue } from "../utils";
 import { Nord } from "./Nord";
-import Decimal from "decimal.js";
-export declare class NordUser {
+import { SolanaBridgeClient } from '../bridge/client';
+import { SPLTokenInfo } from '../bridge/types';
+/**
+ * Parameters for creating a NordUser instance
+ */
+export interface NordUserParams {
+    /** Nord client instance */
     nord: Nord;
+    /** User's blockchain address */
     address: string;
+    /** Function to sign messages with the user's wallet */
     walletSignFn: (message: Uint8Array | string) => Promise<string>;
+    /** Function to sign messages with the user's session key */
     sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    /** Solana public key (optional) */
+    solanaPublicKey?: PublicKey | string;
+    /** Solana keypair (optional) */
+    keypair?: Keypair;
+    /** Solana connection (optional) */
+    connection?: Connection;
+}
+/**
+ * Parameters for placing an order
+ */
+export interface PlaceOrderParams {
+    /** Market ID */
+    marketId: number;
+    /** Order side (bid or ask) */
+    side: Side;
+    /** Fill mode (limit, market, etc.) */
+    fillMode: FillMode;
+    /** Whether the order is reduce-only */
+    isReduceOnly: boolean;
+    /** Order size */
+    size?: Decimal.Value;
+    /** Order price */
+    price?: Decimal.Value;
+    /** Quote size (for market orders) */
+    quoteSize?: Decimal.Value;
+    /** Account ID to place the order from */
+    accountId?: number;
+}
+/**
+ * Parameters for transferring tokens between accounts
+ */
+export interface TransferParams {
+    /** Recipient user */
+    to: NordUser;
+    /** Token ID to transfer */
+    tokenId: number;
+    /** Amount to transfer */
+    amount: Decimal.Value;
+    /** Source account ID */
+    fromAccountId: number;
+    /** Destination account ID */
+    toAccountId: number;
+}
+/**
+ * Parameters for creating a new account
+ */
+export interface CreateAccountParams {
+    /** Token ID for initial funding */
+    tokenId: number;
+    /** Initial funding amount */
+    amount: Decimal.Value;
+}
+/**
+ * User class for interacting with the Nord protocol
+ */
+export declare class NordUser {
+    /** Nord client instance */
+    readonly nord: Nord;
+    /** User's blockchain address */
+    readonly address: string;
+    /** Function to sign messages with the user's wallet */
+    readonly walletSignFn: (message: Uint8Array | string) => Promise<string>;
+    /** Function to sign messages with the user's session key */
+    readonly sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    /** User balances by token symbol */
     balances: {
         [key: string]: {
             accountId: number;
@@ -15,63 +89,155 @@ export declare class NordUser {
             symbol: string;
         }[];
     };
+    /** User orders by market symbol */
     orders: {
         [key: string]: Order[];
     };
+    /** User's account IDs */
     accountIds?: number[];
+    /** Current session ID */
     sessionId?: bigint;
+    /** User's public key */
     publicKey: Uint8Array | undefined;
+    /** Last timestamp used */
     lastTs: number;
+    /** Last nonce used */
     lastNonce: number;
-    constructor(params: {
-        nord: Nord;
-        address: string;
-        walletSignFn: (message: Uint8Array | string) => Promise<string>;
-        sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
-    });
+    /** Solana public key */
+    solanaPublicKey?: PublicKey;
+    /** Solana keypair */
+    keypair?: Keypair;
+    /** Solana bridge client */
+    bridgeClient?: SolanaBridgeClient;
+    /** Solana connection */
+    connection?: Connection;
+    /** SPL token information */
+    splTokenInfos: SPLTokenInfo[];
+    /**
+     * Create a new NordUser instance
+     *
+     * @param params - Parameters for creating a NordUser
+     * @throws {NordError} If required parameters are missing
+     */
+    constructor(params: NordUserParams);
+    /**
+     * Create a clone of this NordUser instance
+     *
+     * @returns A new NordUser instance with the same properties
+     */
     clone(): NordUser;
     /**
-     * Generates a nonce based on the current timestamp.
-     * @returns Generated nonce as a number.
+     * Initialize the Solana bridge client
+     *
+     * @private
+     * @throws {NordError} If required parameters are missing
+     */
+    private initBridgeClient;
+    /**
+     * Create a NordUser from a private key
+     *
+     * @param nord - Nord instance
+     * @param privateKey - Private key as string or Uint8Array
+     * @param connection - Solana connection (optional)
+     * @returns NordUser instance
+     * @throws {NordError} If the private key is invalid
+     */
+    static fromPrivateKey(nord: Nord, privateKey: string | Uint8Array, connection?: Connection): NordUser;
+    /**
+     * Get the associated token account for a token mint
+     *
+     * @param mint - Token mint address
+     * @returns Associated token account address
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    getAssociatedTokenAccount(mint: PublicKey): Promise<PublicKey>;
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount - Amount to deposit
+     * @param tokenId - Token ID
+     * @returns Transaction signature
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    depositSpl(amount: number, tokenId: number): Promise<string>;
+    /**
+     * Withdraw SPL tokens from the bridge
+     *
+     * @param claim - Claim data
+     * @returns Transaction signature
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    withdrawSpl(claim: any): Promise<string>;
+    /**
+     * Get a new nonce for actions
+     *
+     * @returns Nonce as number
      */
     getNonce(): number;
+    /**
+     * Update account IDs for this user
+     *
+     * @throws {NordError} If the operation fails
+     */
     updateAccountId(): Promise<void>;
+    /**
+     * Fetch user information including balances and orders
+     *
+     * @throws {NordError} If the operation fails
+     */
     fetchInfo(): Promise<void>;
-    setPublicKey(): Promise<void>;
-    fundEthWallet(): Promise<void>;
-    fundErc20Wallet(): Promise<void>;
+    /**
+     * Refresh the user's session
+     *
+     * @param sessionPk - Session public key
+     * @throws {NordError} If the operation fails
+     */
     refreshSession(sessionPk: Uint8Array): Promise<void>;
     /**
-     * Revokes session previously created by user
+     * Revoke a session
      *
-     * @param sessionId - session identifier
+     * @param sessionId - Session ID to revoke
+     * @throws {NordError} If the operation fails
      */
     revokeSession(sessionId: BigIntValue): Promise<void>;
-    deposit(provider: BrowserProvider, amount: number, tokenId: number): Promise<void>;
-    depositApproveTx(provider: BrowserProvider, amount: number, tokenId: number): Promise<void>;
-    depositOnlyTx(provider: BrowserProvider, amount: number, tokenId: number): Promise<void>;
-    depositEth(provider: BrowserProvider, amount: number, tokenId: number): Promise<void>;
+    /**
+     * Withdraw tokens from the exchange
+     *
+     * @param tokenId - Token ID to withdraw
+     * @param amount - Amount to withdraw
+     * @throws {NordError} If the operation fails
+     */
     withdraw(tokenId: number, amount: number): Promise<void>;
-    placeOrder(params: {
-        marketId: number;
-        side: Side;
-        fillMode: FillMode;
-        isReduceOnly: boolean;
-        size?: Decimal.Value;
-        price?: Decimal.Value;
-        quoteSize?: Decimal.Value;
-        accountId?: number;
-    }): Promise<bigint | undefined>;
+    /**
+     * Place an order on the exchange
+     *
+     * @param params - Order parameters
+     * @returns Order ID if successful
+     * @throws {NordError} If the operation fails
+     */
+    placeOrder(params: PlaceOrderParams): Promise<bigint | undefined>;
+    /**
+     * Cancel an order
+     *
+     * @param orderId - Order ID to cancel
+     * @param accountId - Account ID that placed the order
+     * @returns Action ID if successful
+     * @throws {NordError} If the operation fails
+     */
     cancelOrder(orderId: BigIntValue, accountId: number): Promise<bigint>;
-    transferToAccount(params: {
-        to: NordUser;
-        tokenId: number;
-        amount: Decimal.Value;
-        fromAccountId: number;
-        toAccountId: number;
-    }): Promise<void>;
-    createAccount(params: {
-        tokenId: number;
-        amount: Decimal.Value;
-    }): Promise<NordUser>;
+    /**
+     * Transfer tokens to another account
+     *
+     * @param params - Transfer parameters
+     * @throws {NordError} If the operation fails
+     */
+    transferToAccount(params: TransferParams): Promise<void>;
+    /**
+     * Create a new account
+     *
+     * @param params - Account creation parameters
+     * @returns New NordUser instance
+     * @throws {NordError} If the operation fails
+     */
+    createAccount(params: CreateAccountParams): Promise<NordUser>;
 }