@n1xyz/nord-ts 0.0.12 → 0.0.14

package/dist/nord/api/core.d.ts

@@ -1,4 +1,4 @@
-import { Account, Info } from "../../types";
+import { Account, Info, SubscriptionPattern } from "../../types";
 import { NordWebSocketClient } from "../../websocket/index";
 /**
  * Get the current timestamp from the Nord server
@@ -36,14 +36,14 @@ export declare function getAccount(webServerUrl: string, accountId: number): Pro
 /**
  * Initialize a WebSocket client for Nord
  *
- * Connects to one of the specific Nord WebSocket endpoints:
- * - /ws/trades - For trade updates (default)
- * - /ws/deltas - For orderbook delta updates
- * - /ws/user - For user-specific updates
+ * 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 endpoint - Specific WebSocket endpoint to connect to (trades, deltas, or user)
- * @param initialSubscriptions - Optional array of initial subscriptions (e.g., ["trades@BTCUSDC"])
+ * @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 declare function initWebSocketClient(webServerUrl: string, endpoint?: "trades" | "deltas" | "user", initialSubscriptions?: string[]): NordWebSocketClient;
+export declare function initWebSocketClient(webServerUrl: string, subscriptions?: SubscriptionPattern[] | "trades" | "delta" | "account", initialSubscriptions?: SubscriptionPattern[]): NordWebSocketClient;

package/dist/nord/api/core.js

@@ -77,22 +77,46 @@ async function getAccount(webServerUrl, accountId) {
 /**
  * Initialize a WebSocket client for Nord
  *
- * Connects to one of the specific Nord WebSocket endpoints:
- * - /ws/trades - For trade updates (default)
- * - /ws/deltas - For orderbook delta updates
- * - /ws/user - For user-specific updates
+ * 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 endpoint - Specific WebSocket endpoint to connect to (trades, deltas, or user)
- * @param initialSubscriptions - Optional array of initial subscriptions (e.g., ["trades@BTCUSDC"])
+ * @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
  */
-function initWebSocketClient(webServerUrl, endpoint, initialSubscriptions) {
+function initWebSocketClient(webServerUrl, subscriptions, initialSubscriptions) {
     try {
-        // Convert HTTP URL to WebSocket URL with specific endpoint
-        // If no specific endpoint is provided, we'll connect to trades by default
-        const specificEndpoint = endpoint || "trades";
-        const wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws/${specificEndpoint}`;
+        // Determine URL and subscriptions based on parameters
+        let wsUrl = webServerUrl.replace(/^http/, "ws") + `/ws`;
+        let wsSubscriptions = [];
+        // Validate subscriptions parameter
+        if (typeof subscriptions === "string") {
+            // Legacy mode - handle endpoint string
+            if (subscriptions === "trades" || subscriptions === "delta" || subscriptions === "account") {
+                wsUrl += `/${subscriptions}`;
+                // If initialSubscriptions provided, use them
+                if (initialSubscriptions && initialSubscriptions.length > 0) {
+                    // Validate initialSubscriptions
+                    initialSubscriptions.forEach(validateSubscription);
+                    wsSubscriptions = initialSubscriptions;
+                }
+            }
+            else {
+                throw new NordError_1.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 index_1.NordWebSocketClient(wsUrl);
@@ -103,9 +127,10 @@ function initWebSocketClient(webServerUrl, endpoint, initialSubscriptions) {
         // Add connected handler for debugging
         ws.on("connected", () => {
             console.log("Nord WebSocket connected successfully");
-            // Subscribe to initial subscriptions if provided
-            if (initialSubscriptions && initialSubscriptions.length > 0) {
-                ws.subscribe(initialSubscriptions);
+            // Subscribe to additional subscriptions if provided
+            // For new format, these are already part of the URL
+            if (wsSubscriptions.length > 0) {
+                ws.subscribe(wsSubscriptions);
             }
         });
         // Connect the WebSocket
@@ -119,3 +144,19 @@ function initWebSocketClient(webServerUrl, endpoint, initialSubscriptions) {
         });
     }
 }
+/**
+ * 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) {
+    const [type, param] = subscription.split('@');
+    if (!type || !param || !['trades', 'deltas', 'account'].includes(type)) {
+        throw new NordError_1.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_1.NordError(`Invalid account ID in subscription: ${subscription}. Account ID must be a number.`);
+    }
+}

package/dist/nord/api/metrics.js

@@ -208,7 +208,7 @@ async function queryPrometheus(webServerUrl, params) {
             const data = JSON.parse(text);
             return data.data.result[0]?.value[1] || 0;
         }
-        catch (e) {
+        catch (_) {
             // Try to find a number in the response
             const numberMatch = text.match(/[\d.]+/);
             if (numberMatch) {

package/dist/nord/client/Nord.d.ts

@@ -8,6 +8,17 @@ import { OrderbookSubscription, TradeSubscription } from "../models/Subscriber";
 export interface UserSubscription extends EventEmitter {
     close: () => void;
 }
+/**
+ * WebSocket subscription options interface
+ */
+export interface WebSocketSubscriptionOptions {
+    /** Market symbols to subscribe to for trade updates */
+    trades?: string[];
+    /** Market symbols to subscribe to for orderbook delta updates */
+    deltas?: string[];
+    /** Account IDs to subscribe to for account updates */
+    accounts?: number[];
+}
 /**
  * Main Nord client class for interacting with the Nord API
  */
@@ -24,31 +35,6 @@ export declare class Nord {
     tokens: Token[];
     /** Map of symbol to market_id */
     private symbolToMarketId;
-    /**
-     * WebSocket client for trades
-     * @private
-     */
-    private tradesWs;
-    /**
-     * WebSocket client for orderbook deltas
-     * @private
-     */
-    private deltasWs;
-    /**
-     * WebSocket client for user updates
-     * @private
-     */
-    private userWs;
-    /**
-     * Initial subscriptions for the trades WebSocket
-     * @private
-     */
-    private tradesSubscriptions?;
-    /**
-     * Initial subscriptions for the deltas WebSocket
-     * @private
-     */
-    private deltasSubscriptions?;
     /**
      * Create a new Nord client
      *
@@ -56,25 +42,31 @@ export declare class Nord {
      * @param config.webServerUrl - Base URL for the Nord web server
      * @param config.solanaProgramId - Solana program ID
      * @param config.solanaUrl - Solana cluster URL
-     * @param config.initWebSockets - Whether to initialize WebSockets on creation, defaults to true
-     * @param config.tradesSubscriptions - Optional array of trades subscriptions to initialize with (e.g., ["trades@BTCUSDC"])
-     * @param config.deltasSubscriptions - Optional array of deltas subscriptions to initialize with (e.g., ["deltas@BTCUSDC"])
      * @throws {Error} If required configuration is missing
      */
-    constructor({ webServerUrl, solanaProgramId, solanaUrl, initWebSockets, tradesSubscriptions, deltasSubscriptions, }: NordConfig);
+    constructor({ webServerUrl, solanaProgramId, solanaUrl, }: NordConfig);
     /**
-     * Initialize WebSocket clients for trades and deltas
+     * Create a WebSocket client with specific subscriptions
      *
-     * This method can be called manually if websockets were not initialized during construction
-     * (i.e., if initWebSockets was set to false in the constructor).
+     * @param options - Subscription options that specify which data streams to subscribe to
+     * @returns A new WebSocket client with the requested subscriptions
+     * @throws {NordError} If invalid subscription options are provided
      *
-     * It initializes the trades and deltas WebSocket clients. The user WebSocket client
-     * is initialized on demand when needed.
+     * @example
+     * // Create a client for trades and deltas from one market and an account
+     * const wsClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC"],
+     *   deltas: ["BTCUSDC"],
+     *   accounts: [123]
+     * });
      *
-     * @param tradesSubscriptions - Optional array of trades subscriptions to initialize with
-     * @param deltasSubscriptions - Optional array of deltas subscriptions to initialize with
+     * @example
+     * // Create a client for trades from multiple markets
+     * const tradesClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC", "ETHUSDC"]
+     * });
      */
-    initializeWebSockets(tradesSubscriptions?: string[], deltasSubscriptions?: string[]): void;
+    createWebSocketClient(options: WebSocketSubscriptionOptions): NordWebSocketClient;
     /**
      * Get the current timestamp from the Nord server
      *
@@ -102,9 +94,6 @@ export declare class Nord {
      * @param nordConfig.webServerUrl - Base URL for the Nord web server
      * @param nordConfig.solanaProgramId - Solana program ID
      * @param nordConfig.solanaUrl - Solana cluster URL
-     * @param nordConfig.initWebSockets - Whether to initialize WebSockets on creation, defaults to true
-     * @param nordConfig.tradesSubscriptions - Optional array of trades subscriptions (e.g., ["trades@BTCUSDC"])
-     * @param nordConfig.deltasSubscriptions - Optional array of deltas subscriptions (e.g., ["deltas@BTCUSDC"])
      * @returns Initialized Nord client
      * @throws {NordError} If initialization fails
      */
@@ -204,39 +193,12 @@ export declare class Nord {
      * @throws {NordError} If the request fails
      */
     queryPrometheus(params: string): Promise<number>;
-    /**
-     * Get the trades WebSocket client (default)
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for trades
-     */
-    getWebSocketClient(): NordWebSocketClient;
-    /**
-     * Get the trades WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for trades
-     */
-    getTradesWebSocketClient(): NordWebSocketClient;
-    /**
-     * Get the deltas WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for orderbook deltas
-     */
-    getDeltasWebSocketClient(): NordWebSocketClient;
-    /**
-     * Get the user WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for user updates
-     */
-    getUserWebSocketClient(): NordWebSocketClient;
     /**
      * Subscribe to orderbook updates for a market
      *
      * @param symbol - Market symbol
      * @returns Orderbook subscription
+     * @throws {NordError} If symbol is invalid
      */
     subscribeOrderbook(symbol: string): OrderbookSubscription;
     /**
@@ -244,8 +206,17 @@ export declare class Nord {
      *
      * @param symbol - Market symbol
      * @returns Trade subscription
+     * @throws {NordError} If symbol is invalid
      */
     subscribeTrades(symbol: string): TradeSubscription;
+    /**
+     * Subscribe to account updates
+     *
+     * @param accountId - Account ID to subscribe to
+     * @returns User subscription
+     * @throws {NordError} If accountId is invalid
+     */
+    subscribeAccount(accountId: number): UserSubscription;
     /**
      * Get trades for a market
      *

package/dist/nord/client/Nord.js

@@ -52,33 +52,15 @@ class Nord {
      * @param config.webServerUrl - Base URL for the Nord web server
      * @param config.solanaProgramId - Solana program ID
      * @param config.solanaUrl - Solana cluster URL
-     * @param config.initWebSockets - Whether to initialize WebSockets on creation, defaults to true
-     * @param config.tradesSubscriptions - Optional array of trades subscriptions to initialize with (e.g., ["trades@BTCUSDC"])
-     * @param config.deltasSubscriptions - Optional array of deltas subscriptions to initialize with (e.g., ["deltas@BTCUSDC"])
      * @throws {Error} If required configuration is missing
      */
-    constructor({ webServerUrl, solanaProgramId, solanaUrl, initWebSockets = true, tradesSubscriptions, deltasSubscriptions, }) {
+    constructor({ webServerUrl, solanaProgramId, solanaUrl, }) {
         /** Available markets */
         this.markets = [];
         /** Available tokens */
         this.tokens = [];
         /** Map of symbol to market_id */
         this.symbolToMarketId = new Map();
-        /**
-         * WebSocket client for trades
-         * @private
-         */
-        this.tradesWs = null;
-        /**
-         * WebSocket client for orderbook deltas
-         * @private
-         */
-        this.deltasWs = null;
-        /**
-         * WebSocket client for user updates
-         * @private
-         */
-        this.userWs = null;
         if (!webServerUrl) {
             throw new NordError_1.NordError("webServerUrl is required");
         }
@@ -91,33 +73,57 @@ class Nord {
         this.webServerUrl = webServerUrl;
         this.solanaProgramId = solanaProgramId;
         this.solanaUrl = solanaUrl;
-        // Store subscription parameters
-        this.tradesSubscriptions = tradesSubscriptions;
-        this.deltasSubscriptions = deltasSubscriptions;
-        // Initialize WebSocket clients only if initWebSockets is true
-        if (initWebSockets) {
-            this.initializeWebSockets();
-        }
     }
     /**
-     * Initialize WebSocket clients for trades and deltas
-     *
-     * This method can be called manually if websockets were not initialized during construction
-     * (i.e., if initWebSockets was set to false in the constructor).
-     *
-     * It initializes the trades and deltas WebSocket clients. The user WebSocket client
-     * is initialized on demand when needed.
-     *
-     * @param tradesSubscriptions - Optional array of trades subscriptions to initialize with
-     * @param deltasSubscriptions - Optional array of deltas subscriptions to initialize with
+     * Create a WebSocket client with specific subscriptions
+     *
+     * @param options - Subscription options that specify which data streams to subscribe to
+     * @returns A new WebSocket client with the requested subscriptions
+     * @throws {NordError} If invalid subscription options are provided
+     *
+     * @example
+     * // Create a client for trades and deltas from one market and an account
+     * const wsClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC"],
+     *   deltas: ["BTCUSDC"],
+     *   accounts: [123]
+     * });
+     *
+     * @example
+     * // Create a client for trades from multiple markets
+     * const tradesClient = nord.createWebSocketClient({
+     *   trades: ["BTCUSDC", "ETHUSDC"]
+     * });
      */
-    initializeWebSockets(tradesSubscriptions, deltasSubscriptions) {
-        // Use provided subscriptions or fall back to stored ones
-        const trades = tradesSubscriptions || this.tradesSubscriptions;
-        const deltas = deltasSubscriptions || this.deltasSubscriptions;
-        // Initialize WebSocket clients for each endpoint with subscriptions
-        this.tradesWs = core.initWebSocketClient(this.webServerUrl, "trades", trades);
-        this.deltasWs = core.initWebSocketClient(this.webServerUrl, "deltas", deltas);
+    createWebSocketClient(options) {
+        const subscriptions = [];
+        // Add trade subscriptions
+        if (options.trades && options.trades.length > 0) {
+            options.trades.forEach(symbol => {
+                subscriptions.push(`trades@${symbol}`);
+            });
+        }
+        // Add delta subscriptions
+        if (options.deltas && options.deltas.length > 0) {
+            options.deltas.forEach(symbol => {
+                subscriptions.push(`deltas@${symbol}`);
+            });
+        }
+        // Add account subscriptions
+        if (options.accounts && options.accounts.length > 0) {
+            options.accounts.forEach(accountId => {
+                if (isNaN(accountId) || accountId <= 0) {
+                    throw new NordError_1.NordError(`Invalid account ID: ${accountId}. Must be a positive number.`);
+                }
+                subscriptions.push(`account@${accountId}`);
+            });
+        }
+        // Validate that at least one subscription was provided
+        if (subscriptions.length === 0) {
+            throw new NordError_1.NordError('At least one subscription must be provided');
+        }
+        // Create and return a new WebSocket client
+        return core.initWebSocketClient(this.webServerUrl, subscriptions);
     }
     /**
      * Get the current timestamp from the Nord server
@@ -164,9 +170,6 @@ class Nord {
      * @param nordConfig.webServerUrl - Base URL for the Nord web server
      * @param nordConfig.solanaProgramId - Solana program ID
      * @param nordConfig.solanaUrl - Solana cluster URL
-     * @param nordConfig.initWebSockets - Whether to initialize WebSockets on creation, defaults to true
-     * @param nordConfig.tradesSubscriptions - Optional array of trades subscriptions (e.g., ["trades@BTCUSDC"])
-     * @param nordConfig.deltasSubscriptions - Optional array of deltas subscriptions (e.g., ["deltas@BTCUSDC"])
      * @returns Initialized Nord client
      * @throws {NordError} If initialization fails
      */
@@ -294,79 +297,31 @@ class Nord {
     async queryPrometheus(params) {
         return metrics.queryPrometheus(this.webServerUrl, params);
     }
-    /**
-     * Get the trades WebSocket client (default)
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for trades
-     */
-    getWebSocketClient() {
-        if (!this.tradesWs) {
-            this.initializeWebSockets();
-        }
-        return this.tradesWs;
-    }
-    /**
-     * Get the trades WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for trades
-     */
-    getTradesWebSocketClient() {
-        if (!this.tradesWs) {
-            this.initializeWebSockets();
-        }
-        return this.tradesWs;
-    }
-    /**
-     * Get the deltas WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for orderbook deltas
-     */
-    getDeltasWebSocketClient() {
-        if (!this.deltasWs) {
-            this.initializeWebSockets();
-        }
-        return this.deltasWs;
-    }
-    /**
-     * Get the user WebSocket client
-     * If not already initialized, it will be created
-     *
-     * @returns WebSocket client for user updates
-     */
-    getUserWebSocketClient() {
-        if (!this.userWs) {
-            // Initialize user WebSocket client on demand
-            this.userWs = core.initWebSocketClient(this.webServerUrl, "user");
-            return this.userWs;
-        }
-        return this.userWs;
-    }
     /**
      * Subscribe to orderbook updates for a market
      *
      * @param symbol - Market symbol
      * @returns Orderbook subscription
+     * @throws {NordError} If symbol is invalid
      */
     subscribeOrderbook(symbol) {
+        if (!symbol || typeof symbol !== 'string') {
+            throw new NordError_1.NordError('Invalid market symbol');
+        }
         const subscription = new events_1.EventEmitter();
+        const wsClient = this.createWebSocketClient({
+            deltas: [symbol]
+        });
         const handleDelta = (update) => {
             if (update.symbol !== symbol) {
                 return;
             }
             subscription.emit("message", update);
         };
-        // Initialize deltas websocket if it doesn't exist
-        if (!this.deltasWs) {
-            this.initializeWebSockets();
-        }
-        this.deltasWs.on("delta", handleDelta);
-        this.deltasWs.subscribe([`deltas@${symbol}`]);
+        wsClient.on("delta", handleDelta);
         subscription.close = () => {
-            this.deltasWs.unsubscribe([`deltas@${symbol}`]);
-            this.deltasWs.removeListener("delta", handleDelta);
+            wsClient.unsubscribe([`deltas@${symbol}`]);
+            wsClient.removeListener("delta", handleDelta);
             subscription.removeAllListeners();
         };
         return subscription;
@@ -376,24 +331,55 @@ class Nord {
      *
      * @param symbol - Market symbol
      * @returns Trade subscription
+     * @throws {NordError} If symbol is invalid
      */
     subscribeTrades(symbol) {
+        if (!symbol || typeof symbol !== 'string') {
+            throw new NordError_1.NordError('Invalid market symbol');
+        }
         const subscription = new events_1.EventEmitter();
+        const wsClient = this.createWebSocketClient({
+            trades: [symbol]
+        });
         const handleTrade = (update) => {
             if (update.symbol !== symbol) {
                 return;
             }
             subscription.emit("message", update);
         };
-        // Initialize trades websocket if it doesn't exist
-        if (!this.tradesWs) {
-            this.initializeWebSockets();
+        wsClient.on("trades", handleTrade);
+        subscription.close = () => {
+            wsClient.unsubscribe([`trades@${symbol}`]);
+            wsClient.removeListener("trades", handleTrade);
+            subscription.removeAllListeners();
+        };
+        return subscription;
+    }
+    /**
+     * Subscribe to account updates
+     *
+     * @param accountId - Account ID to subscribe to
+     * @returns User subscription
+     * @throws {NordError} If accountId is invalid
+     */
+    subscribeAccount(accountId) {
+        if (isNaN(accountId) || accountId <= 0) {
+            throw new NordError_1.NordError('Invalid account ID');
         }
-        this.tradesWs.on("trade", handleTrade);
-        this.tradesWs.subscribe([`trades@${symbol}`]);
+        const subscription = new events_1.EventEmitter();
+        const wsClient = this.createWebSocketClient({
+            accounts: [accountId]
+        });
+        const handleAccountUpdate = (update) => {
+            if (update.account_id !== accountId) {
+                return;
+            }
+            subscription.emit("message", update);
+        };
+        wsClient.on("account", handleAccountUpdate);
         subscription.close = () => {
-            this.tradesWs.unsubscribe([`trades@${symbol}`]);
-            this.tradesWs.removeListener("trade", handleTrade);
+            wsClient.unsubscribe([`account@${accountId}`]);
+            wsClient.removeListener("account", handleAccountUpdate);
             subscription.removeAllListeners();
         };
         return subscription;
@@ -440,10 +426,6 @@ class Nord {
             }
             query = { market_id: marketId };
         }
-        // Ensure market_id is provided
-        if (query.market_id === undefined) {
-            throw new NordError_1.NordError("market_id is required for orderbook query");
-        }
         return market.getOrderbook(this.webServerUrl, query);
     }
     /**

package/dist/nord/client/NordUser.d.ts

@@ -64,15 +64,6 @@ export interface TransferParams {
     /** 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
  */
@@ -270,14 +261,6 @@ export declare class NordUser {
      * @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>;
     /**
      * Helper function to retry a promise with exponential backoff
      *

package/dist/nord/client/NordUser.js

@@ -547,34 +547,6 @@ class NordUser {
             throw new NordError_1.NordError("Failed to transfer tokens", { cause: error });
         }
     }
-    /**
-     * Create a new account
-     *
-     * @param params - Account creation parameters
-     * @returns New NordUser instance
-     * @throws {NordError} If the operation fails
-     */
-    async createAccount(params) {
-        try {
-            this.checkSessionValidity();
-            // Create a new keypair for the account
-            const keypair = web3_js_1.Keypair.generate();
-            // Create a new NordUser
-            const newUser = NordUser.fromPrivateKey(this.nord, keypair.secretKey, this.connection);
-            // Transfer initial funds
-            await this.transferToAccount({
-                to: newUser,
-                tokenId: params.tokenId,
-                amount: params.amount,
-                fromAccountId: (0, utils_2.optExpect)(this.accountIds?.[0], "No account ID"),
-                toAccountId: (0, utils_2.optExpect)(newUser.accountIds?.[0], "No account ID for new user"),
-            });
-            return newUser;
-        }
-        catch (error) {
-            throw new NordError_1.NordError("Failed to create account", { cause: error });
-        }
-    }
     /**
      * Helper function to retry a promise with exponential backoff
      *