@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/operations/market.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Market-related operations
+ * @module operations/market
+ */
+import { NordClientConfig } from '../types/config';
+import { Market, OrderbookData, Trade, Candle } from '../models';
+/**
+ * Market operations implementation
+ */
+export declare class MarketOperations {
+    /**
+     * Client configuration
+     */
+    private readonly config;
+    /**
+     * Create a new MarketOperations instance
+     *
+     * @param config - Client configuration
+     */
+    constructor(config: NordClientConfig);
+    /**
+     * Get all available markets
+     *
+     * @returns Promise resolving to an array of markets
+     * @throws {NordApiError} If the API request fails
+     */
+    getMarkets(): Promise<Market[]>;
+    /**
+     * Get orderbook data for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @returns Promise resolving to orderbook data
+     * @throws {NordValidationError} If the market parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getOrderbook(market: string): Promise<OrderbookData>;
+    /**
+     * Get recent trades for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param limit - Maximum number of trades to return (optional)
+     * @returns Promise resolving to an array of trades
+     * @throws {NordValidationError} If the market parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getTrades(market: string, limit?: number): Promise<Trade[]>;
+    /**
+     * Get candle data for a specific market and timeframe
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param timeframe - Candle timeframe (e.g., "1m", "5m", "1h", "1d")
+     * @param limit - Maximum number of candles to return (optional)
+     * @returns Promise resolving to an array of candles
+     * @throws {NordValidationError} If any parameters are invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getCandles(market: string, timeframe: string, limit?: number): Promise<Candle[]>;
+    /**
+     * Get current server timestamp
+     *
+     * @returns Promise resolving to the current server timestamp in milliseconds
+     * @throws {NordApiError} If the API request fails
+     */
+    getTimestamp(): Promise<number>;
+}

package/dist/operations/market.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Market-related operations
+ * @module operations/market
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketOperations = void 0;
+const errors_1 = require("../utils/errors");
+const http_1 = require("../utils/http");
+const endpoints_1 = require("../constants/endpoints");
+/**
+ * Market operations implementation
+ */
+class MarketOperations {
+    /**
+     * Create a new MarketOperations instance
+     *
+     * @param config - Client configuration
+     */
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Get all available markets
+     *
+     * @returns Promise resolving to an array of markets
+     * @throws {NordApiError} If the API request fails
+     */
+    async getMarkets() {
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.MARKETS}`;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError('Failed to fetch markets', error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.MARKETS, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get orderbook data for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @returns Promise resolving to orderbook data
+     * @throws {NordValidationError} If the market parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getOrderbook(market) {
+        if (!market) {
+            throw new errors_1.NordValidationError('Market symbol is required', 'market');
+        }
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.ORDERBOOK}?market=${encodeURIComponent(market)}`;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch orderbook for market ${market}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.ORDERBOOK, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get recent trades for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param limit - Maximum number of trades to return (optional)
+     * @returns Promise resolving to an array of trades
+     * @throws {NordValidationError} If the market parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getTrades(market, limit) {
+        if (!market) {
+            throw new errors_1.NordValidationError('Market symbol is required', 'market');
+        }
+        try {
+            let endpoint = `${endpoints_1.ENDPOINTS.TRADES}?market=${encodeURIComponent(market)}`;
+            if (limit) {
+                endpoint += `&limit=${limit}`;
+            }
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch trades for market ${market}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.TRADES, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get candle data for a specific market and timeframe
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param timeframe - Candle timeframe (e.g., "1m", "5m", "1h", "1d")
+     * @param limit - Maximum number of candles to return (optional)
+     * @returns Promise resolving to an array of candles
+     * @throws {NordValidationError} If any parameters are invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getCandles(market, timeframe, limit) {
+        if (!market) {
+            throw new errors_1.NordValidationError('Market symbol is required', 'market');
+        }
+        if (!timeframe) {
+            throw new errors_1.NordValidationError('Timeframe is required', 'timeframe');
+        }
+        try {
+            let endpoint = `${endpoints_1.ENDPOINTS.CANDLES}?market=${encodeURIComponent(market)}&timeframe=${encodeURIComponent(timeframe)}`;
+            if (limit) {
+                endpoint += `&limit=${limit}`;
+            }
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch candles for market ${market} with timeframe ${timeframe}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.CANDLES, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get current server timestamp
+     *
+     * @returns Promise resolving to the current server timestamp in milliseconds
+     * @throws {NordApiError} If the API request fails
+     */
+    async getTimestamp() {
+        try {
+            const endpoint = endpoints_1.ENDPOINTS.TIMESTAMP;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response.timestamp;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError('Failed to fetch server timestamp', error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.TIMESTAMP, error instanceof Error ? error : undefined);
+        }
+    }
+}
+exports.MarketOperations = MarketOperations;

package/dist/operations/orders.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Order-related operations
+ * @module operations/orders
+ */
+import { NordClientConfig } from '../types/config';
+import { Order, OrderResult, PlaceOrderParams } from '../models';
+/**
+ * Order operations implementation
+ */
+export declare class OrderOperations {
+    /**
+     * Client configuration
+     */
+    private readonly config;
+    /**
+     * Create a new OrderOperations instance
+     *
+     * @param config - Client configuration
+     */
+    constructor(config: NordClientConfig);
+    /**
+     * Place a new order
+     *
+     * @param params - Order parameters
+     * @returns Promise resolving to order result
+     * @throws {NordValidationError} If any parameters are invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    placeOrder(params: PlaceOrderParams): Promise<OrderResult>;
+    /**
+     * Cancel an existing order
+     *
+     * @param orderId - Order ID to cancel
+     * @returns Promise resolving to true if successful
+     * @throws {NordValidationError} If the orderId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    cancelOrder(orderId: number): Promise<boolean>;
+    /**
+     * Get information about a specific order
+     *
+     * @param orderId - Order ID
+     * @returns Promise resolving to order information
+     * @throws {NordValidationError} If the orderId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getOrder(orderId: number): Promise<Order>;
+    /**
+     * Get all orders for an account
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to an array of orders
+     * @throws {NordValidationError} If the accountId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    getOrders(accountId: number): Promise<Order[]>;
+}

package/dist/operations/orders.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Order-related operations
+ * @module operations/orders
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderOperations = void 0;
+const errors_1 = require("../utils/errors");
+const http_1 = require("../utils/http");
+const endpoints_1 = require("../constants/endpoints");
+/**
+ * Order operations implementation
+ */
+class OrderOperations {
+    /**
+     * Create a new OrderOperations instance
+     *
+     * @param config - Client configuration
+     */
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Place a new order
+     *
+     * @param params - Order parameters
+     * @returns Promise resolving to order result
+     * @throws {NordValidationError} If any parameters are invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async placeOrder(params) {
+        // Validate required parameters
+        if (!params.market) {
+            throw new errors_1.NordValidationError('Market symbol is required', 'market');
+        }
+        if (!params.side) {
+            throw new errors_1.NordValidationError('Order side is required', 'side');
+        }
+        if (params.size === undefined || params.size <= 0) {
+            throw new errors_1.NordValidationError('Order size must be greater than zero', 'size');
+        }
+        // Type-specific validation
+        if (params.type === 'limit' && (params.price === undefined || params.price <= 0)) {
+            throw new errors_1.NordValidationError('Limit price must be greater than zero', 'price');
+        }
+        if (params.type === 'stop' && (params.stopPrice === undefined || params.stopPrice <= 0)) {
+            throw new errors_1.NordValidationError('Stop price must be greater than zero', 'stopPrice');
+        }
+        if (params.type === 'stopLimit') {
+            if (params.stopPrice === undefined || params.stopPrice <= 0) {
+                throw new errors_1.NordValidationError('Stop price must be greater than zero', 'stopPrice');
+            }
+            if (params.limitPrice === undefined || params.limitPrice <= 0) {
+                throw new errors_1.NordValidationError('Limit price must be greater than zero', 'limitPrice');
+            }
+        }
+        try {
+            const response = await (0, http_1.httpPost)(this.config.webServerUrl, endpoints_1.ENDPOINTS.PLACE_ORDER, params);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to place order for market ${params.market}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.PLACE_ORDER, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Cancel an existing order
+     *
+     * @param orderId - Order ID to cancel
+     * @returns Promise resolving to true if successful
+     * @throws {NordValidationError} If the orderId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async cancelOrder(orderId) {
+        if (orderId === undefined || orderId === null) {
+            throw new errors_1.NordValidationError('Order ID is required', 'orderId');
+        }
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.CANCEL_ORDER}/${orderId}`;
+            await (0, http_1.httpDelete)(this.config.webServerUrl, endpoint);
+            return true;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to cancel order ${orderId}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.CANCEL_ORDER, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get information about a specific order
+     *
+     * @param orderId - Order ID
+     * @returns Promise resolving to order information
+     * @throws {NordValidationError} If the orderId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getOrder(orderId) {
+        if (orderId === undefined || orderId === null) {
+            throw new errors_1.NordValidationError('Order ID is required', 'orderId');
+        }
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.ORDER}/${orderId}`;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch order ${orderId}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.ORDER, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get all orders for an account
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to an array of orders
+     * @throws {NordValidationError} If the accountId parameter is invalid
+     * @throws {NordApiError} If the API request fails
+     */
+    async getOrders(accountId) {
+        if (accountId === undefined || accountId === null) {
+            throw new errors_1.NordValidationError('Account ID is required', 'accountId');
+        }
+        try {
+            const endpoint = `${endpoints_1.ENDPOINTS.ORDERS}?accountId=${accountId}`;
+            const response = await (0, http_1.httpGet)(this.config.webServerUrl, endpoint);
+            return response;
+        }
+        catch (error) {
+            throw new errors_1.NordApiError(`Failed to fetch orders for account ${accountId}`, error instanceof errors_1.NordApiError ? error.statusCode : 500, endpoints_1.ENDPOINTS.ORDERS, error instanceof Error ? error : undefined);
+        }
+    }
+}
+exports.OrderOperations = OrderOperations;

package/dist/solana/NordUser.d.ts

@@ -0,0 +1,78 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { Nord } from '../nord/Nord';
+import { Order } from '../types';
+import { SolanaBridgeClient } from './client';
+import { SPLTokenInfo } from './types';
+export declare class NordUser {
+    nord: Nord;
+    publicKey: PublicKey;
+    walletSignFn: (message: Uint8Array | string) => Promise<Uint8Array>;
+    sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    balances: {
+        [key: string]: {
+            accountId: number;
+            balance: number;
+            symbol: string;
+        }[];
+    };
+    orders: {
+        [key: string]: Order[];
+    };
+    accountIds?: number[];
+    sessionId?: bigint;
+    keypair?: Keypair;
+    bridgeClient?: SolanaBridgeClient;
+    connection?: Connection;
+    splTokenInfos: SPLTokenInfo[];
+    lastTs: number;
+    lastNonce: number;
+    constructor(params: {
+        nord: Nord;
+        publicKey: PublicKey | string;
+        walletSignFn: (message: Uint8Array | string) => Promise<Uint8Array>;
+        sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+        keypair?: Keypair;
+        connection?: Connection;
+    });
+    /**
+     * Initialize the Solana bridge client
+     */
+    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
+     * @returns NordUser instance
+     */
+    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
+     */
+    getAssociatedTokenAccount(mint: PublicKey): Promise<PublicKey>;
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount Amount to deposit
+     * @param tokenId Token ID
+     * @returns Transaction signature
+     */
+    depositSpl(amount: number, tokenId: number): Promise<string>;
+    /**
+     * Withdraw tokens from the bridge
+     *
+     * @param claim Withdrawal claim
+     * @returns Transaction signature
+     */
+    withdrawSpl(claim: any): Promise<string>;
+    /**
+     * Fund the user's SPL token accounts for testing
+     *
+     * @param faucetKeypair Keypair with funds to distribute
+     */
+    fundSplWallet(faucetKeypair: Keypair): Promise<void>;
+}

package/dist/solana/NordUser.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordUser = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const client_1 = require("./client");
+const const_1 = require("./const");
+const utils_1 = require("./utils");
+class NordUser {
+    constructor(params) {
+        this.balances = {};
+        this.orders = {};
+        // Convert TokenInfo to SPLTokenInfo
+        this.splTokenInfos = [];
+        this.lastTs = 0;
+        this.lastNonce = 0;
+        this.nord = params.nord;
+        this.publicKey = typeof params.publicKey === 'string'
+            ? new web3_js_1.PublicKey(params.publicKey)
+            : params.publicKey;
+        this.walletSignFn = params.walletSignFn;
+        this.sessionSignFn = params.sessionSignFn;
+        this.keypair = params.keypair;
+        this.connection = params.connection;
+        // Convert TokenInfo to SPLTokenInfo
+        this.splTokenInfos = this.nord.tokenInfos.map(tokenInfo => ({
+            mint: tokenInfo.address, // Use address as mint
+            precision: tokenInfo.precision,
+            tokenId: tokenInfo.tokenId,
+            name: tokenInfo.name
+        }));
+        // Initialize bridge client if keypair and connection are provided
+        if (this.keypair && this.connection && this.nord.solanaProgramId) {
+            this.initBridgeClient();
+        }
+    }
+    /**
+     * Initialize the Solana bridge client
+     */
+    initBridgeClient() {
+        if (!this.keypair || !this.connection || !this.nord.solanaProgramId) {
+            throw new Error('Keypair, connection, and program ID are required to initialize bridge client');
+        }
+        // Create an Anchor wallet from the keypair
+        const wallet = {
+            publicKey: this.keypair.publicKey,
+            signTransaction: async (tx) => {
+                tx.partialSign(this.keypair);
+                return tx;
+            },
+            signAllTransactions: async (txs) => {
+                return txs.map(tx => {
+                    tx.partialSign(this.keypair);
+                    return tx;
+                });
+            },
+            // Add payer property to satisfy NodeWallet interface
+            payer: this.keypair
+        };
+        // Initialize the bridge client
+        this.bridgeClient = new client_1.SolanaBridgeClient({
+            rpcUrl: this.connection.rpcEndpoint,
+            programId: this.nord.solanaProgramId,
+            commitment: 'confirmed',
+            tokenInfos: this.splTokenInfos
+        }, wallet);
+    }
+    /**
+     * Create a NordUser from a private key
+     *
+     * @param nord Nord instance
+     * @param privateKey Private key as string or Uint8Array
+     * @param connection Solana connection
+     * @returns NordUser instance
+     */
+    static fromPrivateKey(nord, privateKey, connection) {
+        const keypair = (0, utils_1.keypairFromPrivateKey)(privateKey);
+        // Create a signing function that returns Uint8Array
+        const walletSignFn = async (message) => {
+            const messageBuffer = typeof message === 'string'
+                ? Buffer.from(message)
+                : Buffer.from(message);
+            // Use nacl for signing since Keypair doesn't have a sign method
+            // This is a simplified version - in a real implementation, you would use proper signing
+            return new Uint8Array(keypair.secretKey.slice(0, 64));
+        };
+        return new NordUser({
+            nord,
+            publicKey: keypair.publicKey,
+            walletSignFn,
+            sessionSignFn: walletSignFn,
+            keypair,
+            connection
+        });
+    }
+    /**
+     * Get the associated token account for a token mint
+     *
+     * @param mint Token mint address
+     * @returns Associated token account address
+     */
+    async getAssociatedTokenAccount(mint) {
+        if (!this.connection) {
+            throw new Error('Connection is required to get associated token account');
+        }
+        const associatedTokenAddress = await (0, spl_token_1.getAssociatedTokenAddress)(mint, this.publicKey);
+        try {
+            await (0, spl_token_1.getAccount)(this.connection, associatedTokenAddress);
+        }
+        catch (error) {
+            // Account doesn't exist, create it if keypair is available
+            if (this.keypair && this.bridgeClient) {
+                await this.bridgeClient.createTokenAccountIfNeeded(mint, this.publicKey, this.keypair);
+            }
+        }
+        return associatedTokenAddress;
+    }
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount Amount to deposit
+     * @param tokenId Token ID
+     * @returns Transaction signature
+     */
+    async depositSpl(amount, tokenId) {
+        if (!this.bridgeClient || !this.keypair || !this.connection) {
+            throw new Error('Bridge client, keypair, and connection are required for deposit');
+        }
+        // Find the token info
+        const tokenInfo = this.splTokenInfos.find(t => t.tokenId === tokenId);
+        if (!tokenInfo) {
+            throw new Error(`Token with ID ${tokenId} not found`);
+        }
+        const mint = new web3_js_1.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 (0, spl_token_1.getAssociatedTokenAddress)(mint, authority, true);
+        // Convert amount to BN with proper decimals
+        const amountBN = (0, utils_1.toBN)(amount, tokenInfo.precision);
+        // Deposit tokens
+        return await this.bridgeClient.depositSpl({
+            amount: amountBN,
+            mint,
+            fromAccount,
+            toAccount
+        }, this.keypair);
+    }
+    /**
+     * Withdraw tokens from the bridge
+     *
+     * @param claim Withdrawal claim
+     * @returns Transaction signature
+     */
+    async withdrawSpl(claim) {
+        if (!this.bridgeClient || !this.keypair || !this.connection) {
+            throw new Error('Bridge client, keypair, and connection are required for withdrawal');
+        }
+        // Get the user's token account
+        const toAccount = await this.getAssociatedTokenAccount(claim.mint);
+        // Get the bridge's token account
+        const [authority] = await this.bridgeClient.findAuthorityPda();
+        const fromAccount = await (0, spl_token_1.getAssociatedTokenAddress)(claim.mint, authority, true);
+        // Withdraw tokens
+        return await this.bridgeClient.withdraw({
+            claim,
+            toAccount,
+            fromAccount
+        }, this.keypair);
+    }
+    /**
+     * Fund the user's SPL token accounts for testing
+     *
+     * @param faucetKeypair Keypair with funds to distribute
+     */
+    async fundSplWallet(faucetKeypair) {
+        if (!this.connection) {
+            throw new Error('Connection is required to fund wallet');
+        }
+        // Fund SOL if needed
+        const solBalance = await this.connection.getBalance(this.publicKey);
+        if (solBalance < 10000000) { // 0.01 SOL
+            const solFundingAmount = const_1.DEFAULT_FUNDING_AMOUNTS["SOL"];
+            // Implement SOL transfer logic here
+        }
+        // Fund SPL tokens
+        for (const tokenInfo of this.splTokenInfos) {
+            if (const_1.DEFAULT_FUNDING_AMOUNTS[tokenInfo.mint]) {
+                const tokenAccount = await this.getAssociatedTokenAccount(new web3_js_1.PublicKey(tokenInfo.mint));
+                // Implement SPL token transfer logic here
+            }
+        }
+    }
+}
+exports.NordUser = NordUser;