@flashnet/sdk 0.1.1 → 0.1.2

package/dist/cjs/src/client/FlashnetClient.js

@@ -0,0 +1,804 @@
+'use strict';
+
+var client = require('../api/client.js');
+var typedEndpoints = require('../api/typed-endpoints.js');
+var auth = require('../utils/auth.js');
+var signer = require('../utils/signer.js');
+var sparkAddress = require('../utils/spark-address.js');
+var index = require('../config/index.js');
+var index$1 = require('../utils/index.js');
+var intents = require('../utils/intents.js');
+var sparkSdk = require('@buildonspark/spark-sdk');
+
+/**
+ * FlashnetClient - A comprehensive client for interacting with Flashnet AMM
+ *
+ * This client wraps a SparkWallet and provides:
+ * - Automatic network detection from the wallet
+ * - Automatic authentication
+ * - Balance checking before operations
+ * - All AMM operations (pools, swaps, liquidity, hosts)
+ * - Direct wallet access via client.wallet
+ */
+class FlashnetClient {
+    _wallet;
+    apiClient;
+    typedApi;
+    authManager;
+    network;
+    publicKey = "";
+    sparkAddress = "";
+    isAuthenticated = false;
+    /**
+     * Get the underlying wallet instance for direct wallet operations
+     */
+    get wallet() {
+        return this._wallet;
+    }
+    /**
+     * Get the network type
+     */
+    get networkType() {
+        return this.network;
+    }
+    /**
+     * Get the wallet's public key
+     */
+    get pubkey() {
+        return this.publicKey;
+    }
+    /**
+     * Get the wallet's Spark address
+     */
+    get address() {
+        return this.sparkAddress;
+    }
+    /**
+     * Create a new FlashnetClient instance
+     * @param wallet - The SparkWallet to use
+     * @param options - Client options
+     */
+    constructor(wallet, options = {}) {
+        this._wallet = wallet;
+        // We'll initialize these in the init method
+        // @ts-expect-error - wallet.config is protected
+        const networkEnum = wallet.config.getNetwork();
+        const networkName = sparkSdk.Network[networkEnum];
+        this.network = networkName === "MAINNET" ? "MAINNET" : "REGTEST";
+        // panic if mainnet for now
+        if (networkName === "MAINNET") {
+            throw new Error("Mainnet is not supported yet");
+        }
+        const config = index.getNetworkConfig(this.network);
+        this.apiClient = new client.ApiClient(config);
+        this.typedApi = new typedEndpoints.TypedAmmApi(this.apiClient);
+        this.authManager = new auth.AuthManager(this.apiClient, "", wallet);
+    }
+    /**
+     * Initialize the client by deducing network and authenticating
+     * This is called automatically on first use if not called manually
+     */
+    async initialize() {
+        if (this.isAuthenticated) {
+            return;
+        }
+        // Get wallet details
+        this.publicKey = await this._wallet.getIdentityPublicKey();
+        this.sparkAddress = await this._wallet.getSparkAddress();
+        // Deduce network from spark address
+        const detectedNetwork = sparkAddress.getNetworkFromAddress(this.sparkAddress);
+        if (!detectedNetwork) {
+            throw new Error(`Unable to determine network from spark address: ${this.sparkAddress}`);
+        }
+        this.network = detectedNetwork;
+        // panic if mainnet for now
+        if (detectedNetwork === "MAINNET") {
+            throw new Error("Mainnet is not supported yet");
+        }
+        // Reinitialize API client with correct network
+        const config = index.getNetworkConfig(this.network);
+        this.apiClient = new client.ApiClient(config);
+        this.typedApi = new typedEndpoints.TypedAmmApi(this.apiClient);
+        this.authManager = new auth.AuthManager(this.apiClient, this.publicKey, signer.createWalletSigner(this._wallet));
+        // Authenticate
+        const token = await this.authManager.authenticate();
+        this.apiClient.setAuthToken(token);
+        this.isAuthenticated = true;
+    }
+    /**
+     * Ensure the client is initialized
+     */
+    async ensureInitialized() {
+        if (!this.isAuthenticated) {
+            await this.initialize();
+        }
+    }
+    /**
+     * Get wallet balance including BTC and token balances
+     */
+    async getBalance() {
+        const balance = await this._wallet.getBalance();
+        // Convert the wallet's balance format to our format
+        const tokenBalances = new Map();
+        if (balance.tokenBalances) {
+            for (const [tokenPubkey, tokenData] of balance.tokenBalances.entries()) {
+                tokenBalances.set(tokenPubkey, {
+                    balance: BigInt(tokenData.balance),
+                    tokenInfo: {
+                        tokenPublicKey: tokenData.tokenInfo.tokenPublicKey,
+                        tokenName: tokenData.tokenInfo.tokenName,
+                        tokenSymbol: tokenData.tokenInfo.tokenSymbol,
+                        tokenDecimals: tokenData.tokenInfo.tokenDecimals,
+                        maxSupply: tokenData.tokenInfo.maxSupply,
+                    },
+                });
+            }
+        }
+        return {
+            balance: BigInt(balance.balance),
+            tokenBalances,
+        };
+    }
+    /**
+     * Check if wallet has sufficient balance for an operation
+     */
+    async checkBalance(requirements) {
+        const balance = await this.getBalance();
+        // Check BTC balance
+        if (requirements.btc && balance.balance < requirements.btc) {
+            return {
+                sufficient: false,
+                message: `Insufficient BTC balance. Required: ${requirements.btc} sats, Available: ${balance.balance} sats`,
+            };
+        }
+        // Check token balances
+        if (requirements.tokens) {
+            for (const [tokenPubkey, requiredAmount,] of requirements.tokens.entries()) {
+                const tokenBalance = balance.tokenBalances.get(tokenPubkey);
+                const available = tokenBalance?.balance ?? 0n;
+                if (available < requiredAmount) {
+                    return {
+                        sufficient: false,
+                        message: `Insufficient token balance for ${tokenPubkey}. Required: ${requiredAmount}, Available: ${available}`,
+                    };
+                }
+            }
+        }
+        return { sufficient: true };
+    }
+    // ===== Pool Operations =====
+    /**
+     * List pools with optional filters
+     */
+    async listPools(query) {
+        await this.ensureInitialized();
+        return this.typedApi.listPools(query);
+    }
+    /**
+     * Get detailed information about a specific pool
+     */
+    async getPool(poolId) {
+        await this.ensureInitialized();
+        return this.typedApi.getPool(poolId);
+    }
+    /**
+     * Get LP position details for a provider in a pool
+     */
+    async getLpPosition(poolId, providerPublicKey) {
+        await this.ensureInitialized();
+        const provider = providerPublicKey || this.publicKey;
+        return this.typedApi.getLpPosition(poolId, provider);
+    }
+    /**
+     * Create a constant product pool
+     */
+    async createConstantProductPool(params) {
+        await this.ensureInitialized();
+        // Check if we need to add initial liquidity
+        if (params.initialLiquidity) {
+            const requirements = {
+                tokens: new Map(),
+            };
+            if (params.assetATokenPublicKey === index.BTC_ASSET_PUBKEY) {
+                requirements.btc = params.initialLiquidity.assetAAmount;
+            }
+            else {
+                requirements.tokens.set(params.assetATokenPublicKey, params.initialLiquidity.assetAAmount);
+            }
+            if (params.assetBTokenPublicKey === index.BTC_ASSET_PUBKEY) {
+                requirements.btc =
+                    (requirements.btc || 0n) + params.initialLiquidity.assetBAmount;
+            }
+            else {
+                requirements.tokens.set(params.assetBTokenPublicKey, params.initialLiquidity.assetBAmount);
+            }
+            const balanceCheck = await this.checkBalance(requirements);
+            if (!balanceCheck.sufficient) {
+                throw new Error(`Insufficient balance for initial liquidity: ${balanceCheck.message}`);
+            }
+        }
+        // Generate intent
+        const nonce = index$1.generateNonce();
+        const intentMessage = intents.generateConstantProductPoolInitializationIntentMessage({
+            poolOwnerPublicKey: this.publicKey,
+            assetATokenPublicKey: params.assetATokenPublicKey,
+            assetBTokenPublicKey: params.assetBTokenPublicKey,
+            lpFeeRateBps: params.lpFeeRateBps.toString(),
+            totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
+            nonce,
+        });
+        // Sign intent
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        // Create pool
+        const request = {
+            poolOwnerPublicKey: this.publicKey,
+            assetATokenPublicKey: params.assetATokenPublicKey,
+            assetBTokenPublicKey: params.assetBTokenPublicKey,
+            lpFeeRateBps: params.lpFeeRateBps.toString(),
+            totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
+            integratorNamespace: params.integratorNamespace || "",
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+        };
+        const response = await this.typedApi.createConstantProductPool(request);
+        // Add initial liquidity if specified
+        if (params.initialLiquidity && response.poolId) {
+            await this.addInitialLiquidity(response.poolId, params.assetATokenPublicKey, params.assetBTokenPublicKey, params.initialLiquidity.assetAAmount, params.initialLiquidity.assetBAmount);
+        }
+        return response;
+    }
+    /**
+     * Create a single-sided pool with automatic initial deposit
+     *
+     * This method creates a single-sided pool and automatically handles the initial deposit.
+     * The initial reserve amount will be transferred to the pool and confirmed.
+     */
+    async createSingleSidedPool(params) {
+        await this.ensureInitialized();
+        // Check balance for initial reserve
+        const requirements = {
+            tokens: new Map(),
+        };
+        if (params.assetATokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            requirements.btc = BigInt(params.assetAInitialReserve);
+        }
+        else {
+            requirements.tokens.set(params.assetATokenPublicKey, BigInt(params.assetAInitialReserve));
+        }
+        const balanceCheck = await this.checkBalance(requirements);
+        if (!balanceCheck.sufficient) {
+            throw new Error(`Insufficient balance for pool creation: ${balanceCheck.message}`);
+        }
+        // Generate intent
+        const nonce = index$1.generateNonce();
+        const intentMessage = intents.generatePoolInitializationIntentMessage({
+            poolOwnerPublicKey: this.publicKey,
+            assetATokenPublicKey: params.assetATokenPublicKey,
+            assetBTokenPublicKey: params.assetBTokenPublicKey,
+            assetAInitialReserve: params.assetAInitialReserve,
+            assetAInitialVirtualReserve: params.assetAInitialVirtualReserve,
+            assetBInitialVirtualReserve: params.assetBInitialVirtualReserve,
+            threshold: params.threshold,
+            lpFeeRateBps: params.lpFeeRateBps.toString(),
+            totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
+            nonce,
+        });
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        // Create pool
+        const request = {
+            poolOwnerPublicKey: this.publicKey,
+            assetATokenPublicKey: params.assetATokenPublicKey,
+            assetBTokenPublicKey: params.assetBTokenPublicKey,
+            assetAInitialReserve: params.assetAInitialReserve,
+            assetAInitialVirtualReserve: params.assetAInitialVirtualReserve,
+            assetBInitialVirtualReserve: params.assetBInitialVirtualReserve,
+            threshold: params.threshold,
+            lpFeeRateBps: params.lpFeeRateBps.toString(),
+            totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
+            hostNamespace: params.hostNamespace,
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+        };
+        const createResponse = await this.typedApi.createSingleSidedPool(request);
+        // If pool creation was successful, handle the initial deposit
+        if (createResponse.poolId) {
+            try {
+                // Transfer initial reserve to the pool
+                const lpSparkAddress = sparkAddress.encodeSparkAddress({
+                    identityPublicKey: createResponse.poolId,
+                    network: this.network,
+                });
+                let assetATransferId;
+                if (params.assetATokenPublicKey === index.BTC_ASSET_PUBKEY) {
+                    const transfer = await this._wallet.transfer({
+                        amountSats: Number(params.assetAInitialReserve),
+                        receiverSparkAddress: lpSparkAddress,
+                    });
+                    assetATransferId = transfer.id;
+                }
+                else {
+                    assetATransferId = await this._wallet.transferTokens({
+                        tokenPublicKey: params.assetATokenPublicKey,
+                        tokenAmount: BigInt(params.assetAInitialReserve),
+                        receiverSparkAddress: lpSparkAddress,
+                    });
+                }
+                // Confirm the initial deposit
+                const confirmNonce = index$1.generateNonce();
+                const confirmIntentMessage = intents.generatePoolConfirmInitialDepositIntentMessage({
+                    poolOwnerPublicKey: this.publicKey,
+                    lpIdentityPublicKey: createResponse.poolId,
+                    assetASparkTransferId: assetATransferId,
+                    nonce: confirmNonce,
+                });
+                const confirmMessageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", confirmIntentMessage));
+                const confirmSignature = await this._wallet.config.signer.signMessageWithIdentityKey(confirmMessageHash, true);
+                const confirmRequest = {
+                    poolId: createResponse.poolId,
+                    assetASparkTransferId: assetATransferId,
+                    nonce: confirmNonce,
+                    signature: Buffer.from(confirmSignature).toString("hex"),
+                    poolOwnerPublicKey: this.publicKey,
+                };
+                const confirmResponse = await this.typedApi.confirmInitialDeposit(confirmRequest);
+                if (!confirmResponse.confirmed) {
+                    throw new Error(`Failed to confirm initial deposit: ${confirmResponse.message}`);
+                }
+            }
+            catch (error) {
+                // If initial deposit fails, we should inform the user
+                throw new Error(`Pool created with ID ${createResponse.poolId}, but initial deposit failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return createResponse;
+    }
+    /**
+     * Confirm initial deposit for single-sided pool
+     *
+     * Note: This is typically handled automatically by createSingleSidedPool().
+     * Use this method only if you need to manually confirm a deposit (e.g., after a failed attempt).
+     */
+    async confirmInitialDeposit(poolId, assetASparkTransferId) {
+        await this.ensureInitialized();
+        const nonce = index$1.generateNonce();
+        const intentMessage = intents.generatePoolConfirmInitialDepositIntentMessage({
+            poolOwnerPublicKey: this.publicKey,
+            lpIdentityPublicKey: poolId,
+            assetASparkTransferId,
+            nonce,
+        });
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            poolId,
+            assetASparkTransferId,
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+            poolOwnerPublicKey: this.publicKey,
+        };
+        return this.typedApi.confirmInitialDeposit(request);
+    }
+    // ===== Swap Operations =====
+    /**
+     * Simulate a swap without executing it
+     */
+    async simulateSwap(params) {
+        await this.ensureInitialized();
+        return this.typedApi.simulateSwap(params);
+    }
+    /**
+     * Execute a swap
+     */
+    async executeSwap(params) {
+        await this.ensureInitialized();
+        // Check balance
+        const requirements = {
+            tokens: new Map(),
+        };
+        if (params.assetInTokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            requirements.btc = params.amountIn;
+        }
+        else {
+            requirements.tokens.set(params.assetInTokenPublicKey, params.amountIn);
+        }
+        const balanceCheck = await this.checkBalance(requirements);
+        if (!balanceCheck.sufficient) {
+            throw new Error(`Insufficient balance for swap: ${balanceCheck.message}`);
+        }
+        // Transfer assets to pool
+        const lpSparkAddress = sparkAddress.encodeSparkAddress({
+            identityPublicKey: params.poolId,
+            network: this.network,
+        });
+        let transferId;
+        if (params.assetInTokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            const transfer = await this._wallet.transfer({
+                amountSats: Number(params.amountIn),
+                receiverSparkAddress: lpSparkAddress,
+            });
+            transferId = transfer.id;
+        }
+        else {
+            transferId = await this._wallet.transferTokens({
+                tokenPublicKey: params.assetInTokenPublicKey,
+                tokenAmount: params.amountIn,
+                receiverSparkAddress: lpSparkAddress,
+            });
+        }
+        // Generate swap intent
+        const nonce = index$1.generateNonce();
+        const intentMessage = intents.generatePoolSwapIntentMessage({
+            userPublicKey: this.publicKey,
+            lpIdentityPublicKey: params.poolId,
+            assetASparkTransferId: transferId,
+            assetInTokenPublicKey: params.assetInTokenPublicKey,
+            assetOutTokenPublicKey: params.assetOutTokenPublicKey,
+            amountIn: params.amountIn.toString(),
+            minAmountOut: params.minAmountOut.toString(),
+            maxSlippageBps: params.maxSlippageBps.toString(),
+            nonce,
+        });
+        // Sign intent
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            userPublicKey: this.publicKey,
+            poolId: params.poolId,
+            assetInTokenPublicKey: params.assetInTokenPublicKey,
+            assetOutTokenPublicKey: params.assetOutTokenPublicKey,
+            amountIn: params.amountIn.toString(),
+            minAmountOut: params.minAmountOut.toString(),
+            maxSlippageBps: params.maxSlippageBps?.toString(),
+            assetInSparkTransferId: transferId,
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+        };
+        const response = await this.typedApi.executeSwap(request);
+        // Check if the swap was accepted
+        if (!response.accepted) {
+            const errorMessage = response.error || "Swap rejected by the AMM";
+            const refundInfo = response.refundedAmount
+                ? ` Refunded ${response.refundedAmount} of ${response.refundedAssetPublicKey} via transfer ${response.refundTransferId}`
+                : "";
+            throw new Error(`${errorMessage}.${refundInfo}`);
+        }
+        return response;
+    }
+    // ===== Liquidity Operations =====
+    /**
+     * Simulate adding liquidity
+     */
+    async simulateAddLiquidity(params) {
+        await this.ensureInitialized();
+        return this.typedApi.simulateAddLiquidity(params);
+    }
+    /**
+     * Add liquidity to a pool
+     */
+    async addLiquidity(params) {
+        await this.ensureInitialized();
+        // Get pool details to know which assets we're dealing with
+        const pool = await this.getPool(params.poolId);
+        // Check balance
+        const requirements = {
+            tokens: new Map(),
+        };
+        if (pool.assetATokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            requirements.btc = params.assetAAmount;
+        }
+        else {
+            requirements.tokens.set(pool.assetATokenPublicKey, params.assetAAmount);
+        }
+        if (pool.assetBTokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            requirements.btc = (requirements.btc || 0n) + params.assetBAmount;
+        }
+        else {
+            requirements.tokens.set(pool.assetBTokenPublicKey, params.assetBAmount);
+        }
+        const balanceCheck = await this.checkBalance(requirements);
+        if (!balanceCheck.sufficient) {
+            throw new Error(`Insufficient balance for adding liquidity: ${balanceCheck.message}`);
+        }
+        // Transfer assets to pool
+        const lpSparkAddress = sparkAddress.encodeSparkAddress({
+            identityPublicKey: params.poolId,
+            network: this.network,
+        });
+        // Transfer asset A
+        let assetATransferId;
+        if (pool.assetATokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            const transfer = await this._wallet.transfer({
+                amountSats: Number(params.assetAAmount),
+                receiverSparkAddress: lpSparkAddress,
+            });
+            assetATransferId = transfer.id;
+        }
+        else {
+            assetATransferId = await this._wallet.transferTokens({
+                tokenPublicKey: pool.assetATokenPublicKey,
+                tokenAmount: params.assetAAmount,
+                receiverSparkAddress: lpSparkAddress,
+            });
+        }
+        // Transfer asset B
+        let assetBTransferId;
+        if (pool.assetBTokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            const transfer = await this._wallet.transfer({
+                amountSats: Number(params.assetBAmount),
+                receiverSparkAddress: lpSparkAddress,
+            });
+            assetBTransferId = transfer.id;
+        }
+        else {
+            assetBTransferId = await this._wallet.transferTokens({
+                tokenPublicKey: pool.assetBTokenPublicKey,
+                tokenAmount: params.assetBAmount,
+                receiverSparkAddress: lpSparkAddress,
+            });
+        }
+        // Generate add liquidity intent
+        const nonce = index$1.generateNonce();
+        const intentMessage = intents.generateAddLiquidityIntentMessage({
+            userPublicKey: this.publicKey,
+            lpIdentityPublicKey: params.poolId,
+            assetASparkTransferId: assetATransferId,
+            assetBSparkTransferId: assetBTransferId,
+            assetAAmount: params.assetAAmount.toString(),
+            assetBAmount: params.assetBAmount.toString(),
+            nonce,
+        });
+        // Sign intent
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            userPublicKey: this.publicKey,
+            poolId: params.poolId,
+            assetASparkTransferId: assetATransferId,
+            assetBSparkTransferId: assetBTransferId,
+            assetAAmountToAdd: params.assetAAmount.toString(),
+            assetBAmountToAdd: params.assetBAmount.toString(),
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+        };
+        const response = await this.typedApi.addLiquidity(request);
+        // Check if the liquidity addition was accepted
+        if (!response.accepted) {
+            const errorMessage = response.error || "Add liquidity rejected by the AMM";
+            const refundInfo = response.refund
+                ? ` Refunds: Asset A: ${response.refund.assetAAmount || 0}, Asset B: ${response.refund.assetBAmount || 0}`
+                : "";
+            throw new Error(`${errorMessage}.${refundInfo}`);
+        }
+        return response;
+    }
+    /**
+     * Simulate removing liquidity
+     */
+    async simulateRemoveLiquidity(params) {
+        await this.ensureInitialized();
+        return this.typedApi.simulateRemoveLiquidity(params);
+    }
+    /**
+     * Remove liquidity from a pool
+     */
+    async removeLiquidity(params) {
+        await this.ensureInitialized();
+        // Check LP token balance
+        const position = await this.getLpPosition(params.poolId);
+        const lpTokensOwned = BigInt(position.lpTokensOwned);
+        const tokensToRemove = BigInt(params.lpTokensToRemove);
+        if (lpTokensOwned < tokensToRemove) {
+            throw new Error(`Insufficient LP tokens. Owned: ${lpTokensOwned}, Requested: ${tokensToRemove}`);
+        }
+        // Generate remove liquidity intent
+        const nonce = index$1.generateNonce();
+        const intentMessage = intents.generateRemoveLiquidityIntentMessage({
+            userPublicKey: this.publicKey,
+            lpIdentityPublicKey: params.poolId,
+            lpTokensToRemove: params.lpTokensToRemove,
+            nonce,
+        });
+        // Sign intent
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            userPublicKey: this.publicKey,
+            poolId: params.poolId,
+            lpTokensToRemove: params.lpTokensToRemove,
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+        };
+        const response = await this.typedApi.removeLiquidity(request);
+        // Check if the liquidity removal was accepted
+        if (!response.accepted) {
+            const errorMessage = response.error || "Remove liquidity rejected by the AMM";
+            throw new Error(errorMessage);
+        }
+        return response;
+    }
+    // ===== Host Operations =====
+    /**
+     * Register as a host
+     */
+    async registerHost(params) {
+        await this.ensureInitialized();
+        const feeRecipient = params.feeRecipientPublicKey || this.publicKey;
+        const nonce = index$1.generateNonce();
+        // Generate intent
+        const intentMessage = intents.generateRegisterHostIntentMessage({
+            namespace: params.namespace,
+            minFeeBps: params.minFeeBps,
+            feeRecipientPublicKey: feeRecipient,
+            nonce,
+        });
+        // Sign intent
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            namespace: params.namespace,
+            minFeeBps: params.minFeeBps,
+            feeRecipientPublicKey: feeRecipient,
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+        };
+        return this.typedApi.registerHost(request);
+    }
+    /**
+     * Get host information
+     */
+    async getHost(namespace) {
+        await this.ensureInitialized();
+        return this.typedApi.getHost(namespace);
+    }
+    /**
+     * Get pool host fees
+     */
+    async getPoolHostFees(hostNamespace, poolId) {
+        await this.ensureInitialized();
+        return this.typedApi.getPoolHostFees({ hostNamespace, poolId });
+    }
+    /**
+     * Withdraw host fees
+     */
+    async withdrawHostFees(params) {
+        await this.ensureInitialized();
+        const nonce = index$1.generateNonce();
+        const intentMessage = intents.generateWithdrawHostFeesIntentMessage({
+            hostPublicKey: this.publicKey,
+            lpIdentityPublicKey: params.lpIdentityPublicKey,
+            assetAAmount: params.assetAAmount,
+            assetBAmount: params.assetBAmount,
+            nonce,
+        });
+        // Sign intent
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            lpIdentityPublicKey: params.lpIdentityPublicKey,
+            assetAAmount: params.assetAAmount,
+            assetBAmount: params.assetBAmount,
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+        };
+        const response = await this.typedApi.withdrawHostFees(request);
+        // Check if the withdrawal was accepted
+        if (!response.accepted) {
+            const errorMessage = response.error || "Withdraw host fees rejected by the AMM";
+            throw new Error(errorMessage);
+        }
+        return response;
+    }
+    // ===== Swap History =====
+    /**
+     * Get swaps for a specific pool
+     */
+    async getPoolSwaps(lpPubkey, query) {
+        await this.ensureInitialized();
+        return this.typedApi.getPoolSwaps(lpPubkey, query);
+    }
+    /**
+     * Get global swaps across all pools
+     */
+    async getGlobalSwaps(query) {
+        await this.ensureInitialized();
+        return this.typedApi.getGlobalSwaps(query);
+    }
+    /**
+     * Get swaps for a specific user
+     */
+    async getUserSwaps(userPublicKey, query) {
+        await this.ensureInitialized();
+        const user = userPublicKey || this.publicKey;
+        return this.typedApi.getUserSwaps(user, query);
+    }
+    // ===== Status =====
+    /**
+     * Ping the settlement service
+     */
+    async ping() {
+        await this.ensureInitialized();
+        return this.typedApi.ping();
+    }
+    // ===== Helper Methods =====
+    /**
+     * Helper method to add initial liquidity after pool creation
+     */
+    async addInitialLiquidity(poolId, assetATokenPublicKey, assetBTokenPublicKey, assetAAmount, assetBAmount) {
+        const lpSparkAddress = sparkAddress.encodeSparkAddress({
+            identityPublicKey: poolId,
+            network: this.network,
+        });
+        // Transfer asset A
+        let assetATransferId;
+        if (assetATokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            const transfer = await this._wallet.transfer({
+                amountSats: Number(assetAAmount),
+                receiverSparkAddress: lpSparkAddress,
+            });
+            assetATransferId = transfer.id;
+        }
+        else {
+            assetATransferId = await this._wallet.transferTokens({
+                tokenPublicKey: assetATokenPublicKey,
+                tokenAmount: assetAAmount,
+                receiverSparkAddress: lpSparkAddress,
+            });
+        }
+        // Transfer asset B
+        let assetBTransferId;
+        if (assetBTokenPublicKey === index.BTC_ASSET_PUBKEY) {
+            const transfer = await this._wallet.transfer({
+                amountSats: Number(assetBAmount),
+                receiverSparkAddress: lpSparkAddress,
+            });
+            assetBTransferId = transfer.id;
+        }
+        else {
+            assetBTransferId = await this._wallet.transferTokens({
+                tokenPublicKey: assetBTokenPublicKey,
+                tokenAmount: assetBAmount,
+                receiverSparkAddress: lpSparkAddress,
+            });
+        }
+        // Add liquidity
+        const nonce = index$1.generateNonce();
+        const intentMessage = intents.generateAddLiquidityIntentMessage({
+            userPublicKey: this.publicKey,
+            lpIdentityPublicKey: poolId,
+            assetASparkTransferId: assetATransferId,
+            assetBSparkTransferId: assetBTransferId,
+            assetAAmount: assetAAmount.toString(),
+            assetBAmount: assetBAmount.toString(),
+            nonce,
+        });
+        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            userPublicKey: this.publicKey,
+            poolId: poolId,
+            assetASparkTransferId: assetATransferId,
+            assetBSparkTransferId: assetBTransferId,
+            assetAAmountToAdd: assetAAmount.toString(),
+            assetBAmountToAdd: assetBAmount.toString(),
+            nonce,
+            signature: Buffer.from(signature).toString("hex"),
+        };
+        const response = await this.typedApi.addLiquidity(request);
+        // Check if the initial liquidity addition was accepted
+        if (!response.accepted) {
+            const errorMessage = response.error || "Initial liquidity addition rejected by the AMM";
+            throw new Error(errorMessage);
+        }
+    }
+    /**
+     * Clean up wallet connections
+     */
+    async cleanup() {
+        await this._wallet.cleanupConnections();
+    }
+}
+
+exports.FlashnetClient = FlashnetClient;
+//# sourceMappingURL=FlashnetClient.js.map