@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/nord/NordUser.js

@@ -1,64 +1,303 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NordUser = void 0;
-const ethers_1 = require("ethers");
-const secp256k1_1 = __importDefault(require("secp256k1"));
-const const_1 = require("../const");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
 const utils_1 = require("../utils");
-const abis_1 = require("../abis");
 const actions_1 = require("./actions");
+const client_1 = require("../bridge/client");
+const utils_2 = require("../bridge/utils");
+const NordError_1 = require("./NordError");
+/**
+ * User class for interacting with the Nord protocol
+ */
 class NordUser {
+    /**
+     * Create a new NordUser instance
+     *
+     * @param params - Parameters for creating a NordUser
+     * @throws {NordError} If required parameters are missing
+     */
     constructor(params) {
+        /** User balances by token symbol */
         this.balances = {};
+        /** User orders by market symbol */
         this.orders = {};
+        /** Last timestamp used */
         this.lastTs = 0;
+        /** Last nonce used */
         this.lastNonce = 0;
+        /** SPL token information */
+        this.splTokenInfos = [];
+        if (!params.nord) {
+            throw new NordError_1.NordError("Nord instance is required");
+        }
+        if (!params.address) {
+            throw new NordError_1.NordError("Address is required");
+        }
+        if (!params.walletSignFn) {
+            throw new NordError_1.NordError("Wallet sign function is required");
+        }
+        if (!params.sessionSignFn) {
+            throw new NordError_1.NordError("Session sign function is required");
+        }
         this.nord = params.nord;
         this.address = params.address;
         this.walletSignFn = params.walletSignFn;
         this.sessionSignFn = params.sessionSignFn;
+        // Initialize Solana-specific properties if provided
+        if (params.solanaPublicKey) {
+            this.solanaPublicKey = typeof params.solanaPublicKey === 'string'
+                ? new web3_js_1.PublicKey(params.solanaPublicKey)
+                : params.solanaPublicKey;
+        }
+        this.keypair = params.keypair;
+        this.connection = params.connection;
+        // Convert TokenInfo to SPLTokenInfo if nord has tokenInfos
+        if (this.nord.tokenInfos) {
+            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();
+        }
     }
+    /**
+     * Create a clone of this NordUser instance
+     *
+     * @returns A new NordUser instance with the same properties
+     */
     clone() {
         const newUser = new NordUser({
             nord: this.nord,
             address: this.address,
             walletSignFn: this.walletSignFn,
             sessionSignFn: this.sessionSignFn,
+            solanaPublicKey: this.solanaPublicKey,
+            keypair: this.keypair,
+            connection: this.connection
         });
         newUser.publicKey = this.publicKey;
         newUser.lastTs = this.lastTs;
         newUser.lastNonce = this.lastNonce;
-        newUser.accountIds = this.accountIds;
+        newUser.accountIds = this.accountIds ? [...this.accountIds] : undefined;
         newUser.sessionId = this.sessionId;
+        newUser.splTokenInfos = [...this.splTokenInfos];
+        // Deep clone balances and orders
+        newUser.balances = JSON.parse(JSON.stringify(this.balances));
+        newUser.orders = JSON.parse(JSON.stringify(this.orders));
         return newUser;
     }
     /**
-     * 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
      */
-    getNonce() {
-        const ts = Date.now() / 1000;
-        if (ts === this.lastTs) {
-            this.lastNonce += 1;
+    initBridgeClient() {
+        if (!this.keypair || !this.connection || !this.nord.solanaProgramId) {
+            throw new NordError_1.NordError('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 (optional)
+     * @returns NordUser instance
+     * @throws {NordError} If the private key is invalid
+     */
+    static fromPrivateKey(nord, privateKey, connection) {
+        try {
+            const keypair = (0, utils_2.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 Buffer.from(keypair.secretKey.slice(0, 64)).toString('hex');
+            };
+            const sessionSignFn = async (message) => {
+                // 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,
+                address: keypair.publicKey.toBase58(),
+                walletSignFn,
+                sessionSignFn,
+                solanaPublicKey: keypair.publicKey,
+                keypair,
+                connection
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to create NordUser from private key", { cause: error });
+        }
+    }
+    /**
+     * 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
+     */
+    async getAssociatedTokenAccount(mint) {
+        if (!this.connection || !this.solanaPublicKey) {
+            throw new NordError_1.NordError('Connection and Solana public key are required to get associated token account');
         }
-        else {
-            this.lastTs = ts;
-            this.lastNonce = 0;
+        try {
+            const associatedTokenAddress = await (0, spl_token_1.getAssociatedTokenAddress)(mint, this.solanaPublicKey);
+            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.solanaPublicKey, this.keypair);
+                }
+            }
+            return associatedTokenAddress;
+        }
+        catch (error) {
+            throw new NordError_1.NordError(`Failed to get associated token account for mint ${mint.toString()}`, { cause: error });
         }
-        return this.lastNonce;
     }
+    /**
+     * 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
+     */
+    async depositSpl(amount, tokenId) {
+        if (!this.bridgeClient || !this.keypair || !this.connection || !this.solanaPublicKey) {
+            throw new NordError_1.NordError('Bridge client, keypair, connection, and Solana public key are required for deposit');
+        }
+        try {
+            // Find the token info
+            const tokenInfo = this.splTokenInfos.find(t => t.tokenId === tokenId);
+            if (!tokenInfo) {
+                throw new NordError_1.NordError(`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);
+        }
+        catch (error) {
+            throw new NordError_1.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) {
+        if (!this.bridgeClient || !this.keypair || !this.connection || !this.solanaPublicKey) {
+            throw new NordError_1.NordError('Bridge client, keypair, connection, and Solana public key are required for withdrawal');
+        }
+        try {
+            // Find the token info
+            const tokenInfo = this.splTokenInfos.find(t => t.tokenId === claim.tokenId);
+            if (!tokenInfo) {
+                throw new NordError_1.NordError(`Token with ID ${claim.tokenId} not found`);
+            }
+            const mint = new web3_js_1.PublicKey(tokenInfo.mint);
+            // Get the user's token account
+            const toAccount = await this.getAssociatedTokenAccount(mint);
+            // Get the bridge's token account
+            const [authority] = await this.bridgeClient.findAuthorityPda();
+            const fromAccount = await (0, spl_token_1.getAssociatedTokenAddress)(mint, authority, true);
+            // Withdraw tokens
+            return await this.bridgeClient.withdraw({
+                claim,
+                fromAccount,
+                toAccount
+            }, this.keypair);
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to withdraw SPL tokens", { cause: error });
+        }
+    }
+    /**
+     * Get a new nonce for actions
+     *
+     * @returns Nonce as number
+     */
+    getNonce() {
+        return ++this.lastNonce;
+    }
+    /**
+     * Update account IDs for this user
+     *
+     * @throws {NordError} If the operation fails
+     */
     async updateAccountId() {
-        const hexPubkey = ethers_1.ethers
-            .hexlify((0, utils_1.optExpect)(this.publicKey, "No user public key"))
-            .slice(2);
-        const accountIds_ = await (await (0, utils_1.checkedFetch)(`${this.nord.webServerUrl}/user_account_ids?pubkey=${hexPubkey}`)).json();
-        (0, utils_1.assert)(Array.isArray(accountIds_), "Unexpected response");
-        const accountIds = accountIds_;
-        this.accountIds = accountIds;
+        try {
+            if (!this.publicKey) {
+                throw new NordError_1.NordError("Public key is required to update account ID");
+            }
+            const resp = await this.nord.getUserAccountIds({
+                pubkey: Buffer.from(this.publicKey).toString('hex')
+            });
+            this.accountIds = resp.accountIds;
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to update account ID", { cause: error });
+        }
     }
+    /**
+     * Fetch user information including balances and orders
+     *
+     * @throws {NordError} If the operation fails
+     */
     async fetchInfo() {
         if (this.accountIds !== undefined) {
             // todo:implement class
@@ -90,160 +329,153 @@ class NordUser {
             }
         }
     }
-    async setPublicKey() {
-        const message = "Layer N - Nord";
-        const msgHash = ethers_1.ethers.hashMessage(message);
-        const msgHashBytes = ethers_1.ethers.getBytes(msgHash);
-        const signature = await this.walletSignFn(message);
-        const recoveredPubKey = ethers_1.SigningKey.recoverPublicKey(msgHashBytes, signature);
-        const publicKeyBuffer = Buffer.from(recoveredPubKey.slice(2), "hex");
-        this.publicKey = secp256k1_1.default.publicKeyConvert(publicKeyBuffer, true);
-    }
-    async fundEthWallet() {
-        const provider = new ethers_1.ethers.JsonRpcProvider(this.nord.evmUrl);
-        const wallet = new ethers_1.ethers.Wallet(const_1.FAUCET_PRIVATE_ADDRESS, provider);
-        (0, utils_1.assert)(const_1.DEFAULT_FUNDING_AMOUNTS["ETH"] != null);
-        const ethTx = await wallet.sendTransaction({
-            to: this.address,
-            value: ethers_1.ethers.parseEther(const_1.DEFAULT_FUNDING_AMOUNTS["ETH"][0]),
-        });
-        await ethTx.wait();
-    }
-    async fundErc20Wallet() {
-        const provider = new ethers_1.ethers.JsonRpcProvider(this.nord.evmUrl);
-        const wallet = new ethers_1.ethers.Wallet(const_1.FAUCET_PRIVATE_ADDRESS, provider);
-        (0, utils_1.assert)(const_1.DEFAULT_FUNDING_AMOUNTS["ETH"] != null);
-        for (const tokenInfo of this.nord.tokenInfos) {
-            const erc20Contract = new ethers_1.ethers.Contract(tokenInfo.address, abis_1.ERC20_ABI, wallet);
-            if (const_1.DEFAULT_FUNDING_AMOUNTS[tokenInfo.address]) {
-                const defaultFundingAmount = const_1.DEFAULT_FUNDING_AMOUNTS[tokenInfo.address];
-                const tokenTx = await erc20Contract.transfer(this.address, ethers_1.ethers.parseUnits(defaultFundingAmount[0], defaultFundingAmount[1]), {
-                    maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
-                    maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
-                });
-                await tokenTx.wait();
-            }
-        }
-    }
+    /**
+     * Refresh the user's session
+     *
+     * @param sessionPk - Session public key
+     * @throws {NordError} If the operation fails
+     */
     async refreshSession(sessionPk) {
-        this.sessionId = await (0, actions_1.createSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
+        this.sessionId = await (0, actions_1.createSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
             userPubkey: (0, utils_1.optExpect)(this.publicKey, "No user's public key"),
             sessionPubkey: sessionPk,
         });
     }
     /**
-     * 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
      */
     async revokeSession(sessionId) {
-        return (0, actions_1.revokeSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
-            sessionId,
-        });
-    }
-    async deposit(provider, amount, tokenId) {
-        const erc20 = this.nord.tokenInfos[tokenId];
-        const erc20Contract = new ethers_1.ethers.Contract(erc20.address, abis_1.ERC20_ABI, await provider.getSigner());
-        const approveTx = await erc20Contract.approve(this.nord.contractAddress, ethers_1.MaxUint256, {
-            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
-            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
-        });
-        await approveTx.wait();
-        const nordContract = new ethers_1.ethers.Contract(this.nord.contractAddress, abis_1.NORD_RAMP_FACET_ABI, await provider.getSigner());
-        const depositTx = await nordContract.depositUnchecked(this.publicKey, BigInt(0), ethers_1.ethers.parseUnits(amount.toString(), erc20.precision), {
-            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
-            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
-        });
-        await depositTx.wait();
-    }
-    async depositApproveTx(provider, amount, tokenId) {
-        const erc20 = this.nord.tokenInfos[tokenId];
-        const erc20Contract = new ethers_1.ethers.Contract(erc20.address, abis_1.ERC20_ABI, await provider.getSigner());
-        const approveTx = await erc20Contract.approve(this.nord.contractAddress, ethers_1.MaxUint256, {
-            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
-            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
-        });
-        return approveTx.hash;
-    }
-    async depositOnlyTx(provider, amount, tokenId) {
-        const erc20 = this.nord.tokenInfos[tokenId];
-        const nordContract = new ethers_1.ethers.Contract(this.nord.contractAddress, abis_1.NORD_RAMP_FACET_ABI, await provider.getSigner());
-        const depositTx = await nordContract.depositUnchecked(this.publicKey, BigInt(0), ethers_1.ethers.parseUnits(amount.toString(), erc20.precision), {
-            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
-            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
-        });
-        return depositTx.hash;
-    }
-    async depositEth(provider, amount, tokenId) {
-        if (tokenId || tokenId == 0) {
-            const nordContract = new ethers_1.ethers.Contract(this.nord.contractAddress, abis_1.NORD_RAMP_FACET_ABI, await provider.getSigner());
-            const depositTx = await nordContract.depositUnchecked(this.publicKey, BigInt(1), ethers_1.ethers.parseUnits(amount.toString(), 18), {
-                maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
-                maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
+        try {
+            await (0, actions_1.revokeSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId
             });
-            await depositTx.wait();
         }
-        else {
-            //     todo:implement eth deposits
+        catch (error) {
+            throw new NordError_1.NordError(`Failed to revoke session ${sessionId}`, { cause: error });
         }
     }
+    /**
+     * Withdraw tokens from the exchange
+     *
+     * @param tokenId - Token ID to withdraw
+     * @param amount - Amount to withdraw
+     * @throws {NordError} If the operation fails
+     */
     async withdraw(tokenId, amount) {
-        (0, actions_1.withdraw)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
-            sizeDecimals: (0, utils_1.findToken)(this.nord.tokens, tokenId).decimals,
-            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
-            tokenId: tokenId,
-            amount,
-        });
+        try {
+            await (0, actions_1.withdraw)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sizeDecimals: (0, utils_1.findToken)(this.nord.tokens, tokenId).decimals,
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                tokenId: tokenId,
+                amount,
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError(`Failed to withdraw ${amount} of token ID ${tokenId}`, { cause: error });
+        }
     }
+    /**
+     * Place an order on the exchange
+     *
+     * @param params - Order parameters
+     * @returns Order ID if successful
+     * @throws {NordError} If the operation fails
+     */
     async placeOrder(params) {
-        const market = (0, utils_1.findMarket)(this.nord.markets, params.marketId);
-        return (0, actions_1.placeOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
-            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
-            senderId: params.accountId,
-            sizeDecimals: market.sizeDecimals,
-            priceDecimals: market.priceDecimals,
-            marketId: params.marketId,
-            side: params.side,
-            fillMode: params.fillMode,
-            isReduceOnly: params.isReduceOnly,
-            size: params.size,
-            price: params.price,
-            quoteSize: params.quoteSize,
-        });
+        try {
+            const market = (0, utils_1.findMarket)(this.nord.markets, params.marketId);
+            if (!market) {
+                throw new NordError_1.NordError(`Market with ID ${params.marketId} not found`);
+            }
+            return (0, actions_1.placeOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                senderId: params.accountId,
+                sizeDecimals: market.sizeDecimals,
+                priceDecimals: market.priceDecimals,
+                marketId: params.marketId,
+                side: params.side,
+                fillMode: params.fillMode,
+                isReduceOnly: params.isReduceOnly,
+                size: params.size,
+                price: params.price,
+                quoteSize: params.quoteSize,
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to place order", { cause: error });
+        }
     }
+    /**
+     * 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
+     */
     async cancelOrder(orderId, accountId) {
-        return (0, actions_1.cancelOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
-            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
-            senderId: accountId,
-            orderId,
-        });
+        try {
+            return (0, actions_1.cancelOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                senderId: accountId,
+                orderId,
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError(`Failed to cancel order ${orderId}`, { cause: error });
+        }
     }
+    /**
+     * Transfer tokens to another account
+     *
+     * @param params - Transfer parameters
+     * @throws {NordError} If the operation fails
+     */
     async transferToAccount(params) {
-        const token = (0, utils_1.findToken)(this.nord.tokens, params.tokenId);
-        await (0, actions_1.transfer)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
-            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
-            fromAccountId: (0, utils_1.optExpect)(params.fromAccountId, "No source account"),
-            toAccountId: (0, utils_1.optExpect)(params.toAccountId, "No target account"),
-            tokenId: params.tokenId,
-            tokenDecimals: token.decimals,
-            amount: params.amount,
-        });
+        try {
+            const token = (0, utils_1.findToken)(this.nord.tokens, params.tokenId);
+            await (0, actions_1.transfer)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                fromAccountId: (0, utils_1.optExpect)(params.fromAccountId, "No source account"),
+                toAccountId: (0, utils_1.optExpect)(params.toAccountId, "No target account"),
+                tokenId: params.tokenId,
+                tokenDecimals: token.decimals,
+                amount: params.amount,
+            });
+        }
+        catch (error) {
+            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) {
-        const token = (0, utils_1.findToken)(this.nord.tokens, params.tokenId);
-        const maybeToAccountId = await (0, actions_1.transfer)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
-            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
-            fromAccountId: (0, utils_1.optExpect)(this.accountIds?.[0], "No source account"),
-            toAccountId: undefined,
-            tokenId: params.tokenId,
-            tokenDecimals: token.decimals,
-            amount: params.amount,
-        });
-        const toAccountId = (0, utils_1.optExpect)(maybeToAccountId, "New account should have been created");
-        const newUser = this.clone();
-        newUser.accountIds?.push(toAccountId);
-        await newUser.fetchInfo();
-        return newUser;
+        try {
+            // 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_1.optExpect)(this.accountIds?.[0], "No account ID"),
+                toAccountId: (0, utils_1.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 });
+        }
     }
 }
 exports.NordUser = NordUser;

package/dist/nord/Subscriber.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from "events";
+import { DeltaEvent, Trades, Account, SubscriberConfig, OrderbookResponse, Trade } from "../types";
+/**
+ * Subscriber class for handling WebSocket subscriptions
+ */
+export declare class Subscriber {
+    streamURL: string;
+    buffer: (DeltaEvent | Trades | Account)[];
+    maxBufferLen: number;
+    /**
+     * Create a new Subscriber instance
+     * @param config Subscriber configuration
+     */
+    constructor(config: SubscriberConfig);
+    /**
+     * Subscribe to WebSocket events
+     */
+    subscribe(): void;
+}
+/**
+ * Interface for orderbook subscription
+ */
+export interface OrderbookSubscription extends EventEmitter {
+    on(event: 'message', listener: (data: OrderbookResponse) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}
+/**
+ * Interface for trade subscription
+ */
+export interface TradeSubscription extends EventEmitter {
+    on(event: 'message', listener: (data: Trade[]) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    close(): void;
+    removeAllListeners(event?: string): this;
+}