@flashnet/sdk 0.3.12-rc.1 → 0.3.12-rc.3

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

@@ -250,14 +250,27 @@ class FlashnetClient {
     /**
      * Check if wallet has sufficient balance for an operation
      */
-    async checkBalance(requirements) {
-        const balance = await this.getBalance();
+    async checkBalance(params) {
+        const balance = params.walletBalance ?? (await this.getBalance());
+        // Check balance
+        const requirements = {
+            tokens: new Map(),
+        };
+        for (const balance of params.balancesToCheck) {
+            if (balance.assetAddress === index$1.BTC_ASSET_PUBKEY) {
+                requirements.btc = BigInt(balance.amount);
+            }
+            else {
+                requirements.tokens?.set(balance.assetAddress, BigInt(balance.amount));
+            }
+        }
         // 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`,
-            };
+            throw new Error([
+                params.errorPrefix ?? "",
+                `Insufficient BTC balance. `,
+                `Required: ${requirements.btc} sats, Available: ${balance.balance} sats`,
+            ].join(""));
         }
         // Check token balances
         if (requirements.tokens) {
@@ -268,14 +281,14 @@ class FlashnetClient {
                     balance.tokenBalances.get(hrKey);
                 const available = effectiveTokenBalance?.balance ?? 0n;
                 if (available < requiredAmount) {
-                    return {
-                        sufficient: false,
-                        message: `Insufficient token balance for ${tokenPubkey}. Required: ${requiredAmount}, Available: ${available}`,
-                    };
+                    throw new Error([
+                        params.errorPrefix ?? "",
+                        `Insufficient token balance for ${tokenPubkey}. `,
+                        `Required: ${requiredAmount}, Available: ${available}`,
+                    ].join(""));
                 }
             }
         }
-        return { sufficient: true };
     }
     // ===== Pool Operations =====
     /**
@@ -314,26 +327,19 @@ class FlashnetClient {
         await this.ensureInitialized();
         // Check if we need to add initial liquidity
         if (params.initialLiquidity) {
-            const requirements = {
-                tokens: new Map(),
-            };
-            if (params.assetAAddress === index$1.BTC_ASSET_PUBKEY) {
-                requirements.btc = params.initialLiquidity.assetAAmount;
-            }
-            else {
-                requirements.tokens?.set(params.assetAAddress, params.initialLiquidity.assetAAmount);
-            }
-            if (params.assetBAddress === index$1.BTC_ASSET_PUBKEY) {
-                requirements.btc =
-                    (requirements.btc || 0n) + params.initialLiquidity.assetBAmount;
-            }
-            else {
-                requirements.tokens?.set(params.assetBAddress, params.initialLiquidity.assetBAmount);
-            }
-            const balanceCheck = await this.checkBalance(requirements);
-            if (!balanceCheck.sufficient) {
-                throw new Error(`Insufficient balance for initial liquidity: ${balanceCheck.message}`);
-            }
+            await this.checkBalance({
+                balancesToCheck: [
+                    {
+                        assetAddress: params.assetAAddress,
+                        amount: params.initialLiquidity.assetAAmount,
+                    },
+                    {
+                        assetAddress: params.assetBAddress,
+                        amount: params.initialLiquidity.assetBAmount,
+                    },
+                ],
+                errorPrefix: "Insufficient balance for initial liquidity: ",
+            });
         }
         // Generate intent
         const nonce = index$2.generateNonce();
@@ -362,101 +368,44 @@ class FlashnetClient {
         const response = await this.typedApi.createConstantProductPool(request);
         // Add initial liquidity if specified
         if (params.initialLiquidity && response.poolId) {
-            await this.addInitialLiquidity(response.poolId, params.assetAAddress, params.assetBAddress, params.initialLiquidity.assetAAmount.toString(), params.initialLiquidity.assetBAmount.toString(), params.initialLiquidity.assetAMinAmountIn.toString(), params.initialLiquidity.assetBMinAmountIn.toString());
+            await this.addInitialLiquidity(response.poolId, params.assetAAddress, params.assetBAddress, params.initialLiquidity.assetAAmount.toString(), params.initialLiquidity.assetBAmount.toString());
         }
         return response;
     }
-    /**
-     * Calculates virtual reserves for a bonding curve AMM.
-     *
-     * This helper function calculates the initial virtual reserves (`v_A^0`, `v_B^0`)
-     * based on the bonding curve parameters. These virtual reserves ensure smooth
-     * pricing and price continuity during graduation to the double-sided phase.
-     *
-     * @param params - The parameters for the calculation.
-     * @param params.initialTokenSupply - The initial supply of Asset A (tokens to be sold).
-     * @param params.graduationThresholdPct - The percentage of tokens that need to be sold for graduation (20-95%).
-     * @param params.targetRaise - The target amount of Asset B to raise at graduation.
-     * @returns An object containing `virtualReserveA`, `virtualReserveB`, and `threshold`.
-     */
-    static calculateVirtualReserves(params) {
-        const supply = Number(params.initialTokenSupply);
-        const targetB = Number(params.targetRaise);
-        const lpFrac = 1.0;
-        // Validate inputs
-        if (supply <= 0) {
-            throw new Error("Initial token supply must be positive");
-        }
-        if (targetB <= 0) {
-            throw new Error("Target raise must be positive");
-        }
-        const MIN_GRADUATION_THRESHOLD_PCT = 20;
-        const MAX_GRADUATION_THRESHOLD_PCT = 95;
-        // Validate graduation threshold is a positive whole number
-        if (!Number.isInteger(params.graduationThresholdPct) ||
-            params.graduationThresholdPct <= 0) {
-            throw new Error("Graduation threshold percentage must be a positive whole number");
-        }
-        if (params.graduationThresholdPct < MIN_GRADUATION_THRESHOLD_PCT ||
-            params.graduationThresholdPct > MAX_GRADUATION_THRESHOLD_PCT) {
-            throw new Error(`Graduation threshold percentage must be between ${MIN_GRADUATION_THRESHOLD_PCT} and ${MAX_GRADUATION_THRESHOLD_PCT}`);
-        }
-        // Calculate graduation parameters
-        const f = params.graduationThresholdPct / 100;
-        const g = lpFrac;
-        // Check feasibility: f - g*(1-f) > 0
-        const denom = f - g * (1 - f);
-        if (denom <= 0) {
-            throw new Error(`Invalid configuration: graduation threshold ${f * 100}% with LP fraction ${g} is infeasible. Need f > g/(1+g)`);
-        }
-        // Calculate virtual reserves and round down to integers
-        const virtualA = Math.floor((supply * f * f) / denom);
-        const virtualB = Math.floor((targetB * g * (1 - f)) / denom);
-        return {
-            virtualReserveA: virtualA,
-            virtualReserveB: virtualB,
-            threshold: params.graduationThresholdPct,
-        };
-    }
     /**
      * Create a single-sided pool with automatic initial deposit
      *
-     * This method creates a single-sided pool and automatically handles the initial deposit.
+     * This method creates a single-sided pool and by default automatically handles the initial deposit.
      * The initial reserve amount will be transferred to the pool and confirmed.
      */
     async createSingleSidedPool(params) {
         await this.ensureInitialized();
+        // check that assetAPctSoldAtGraduation is between 0 and 100 - no decimals
+        if (params.assetAPctSoldAtGraduation < 0 ||
+            params.assetAPctSoldAtGraduation > 100) {
+            throw new Error(`assetAPctSoldAtGraduation must be between 0 and 100`);
+        }
         if (!params.hostNamespace && params.totalHostFeeRateBps < 10) {
             throw new Error(`Host fee must be greater than 10 bps when no host namespace is provided`);
         }
-        // Clip decimals off reserves before any operations
-        const clippedAssetAInitialReserve = Math.floor(Number(params.assetAInitialReserve)).toString();
-        const clippedVirtualReserveA = Math.floor(Number(params.virtualReserveA)).toString();
-        const clippedVirtualReserveB = Math.floor(Number(params.virtualReserveB)).toString();
-        // Check balance for initial reserve
-        const requirements = {
-            tokens: new Map(),
-        };
-        if (params.assetAAddress === index$1.BTC_ASSET_PUBKEY) {
-            requirements.btc = BigInt(clippedAssetAInitialReserve);
-        }
-        else {
-            requirements.tokens?.set(params.assetAAddress, BigInt(clippedAssetAInitialReserve));
-        }
-        const balanceCheck = await this.checkBalance(requirements);
-        if (!balanceCheck.sufficient) {
-            throw new Error(`Insufficient balance for pool creation: ${balanceCheck.message}`);
-        }
+        await this.checkBalance({
+            balancesToCheck: [
+                {
+                    assetAddress: params.assetAInitialReserve,
+                    amount: params.assetAInitialReserve,
+                },
+            ],
+            errorPrefix: "Insufficient balance for pool creation: ",
+        });
         // Generate intent
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generatePoolInitializationIntentMessage({
             poolOwnerPublicKey: this.publicKey,
             assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
             assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
-            assetAInitialReserve: clippedAssetAInitialReserve,
-            virtualReserveA: clippedVirtualReserveA,
-            virtualReserveB: clippedVirtualReserveB,
-            threshold: params.threshold,
+            assetAInitialReserve: params.assetAInitialReserve,
+            graduationThresholdPct: params.assetAPctSoldAtGraduation.toString(),
+            targetBRaisedAtGraduation: params.targetBRaisedAtGraduation,
             lpFeeRateBps: params.lpFeeRateBps.toString(),
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
             nonce,
@@ -468,10 +417,9 @@ class FlashnetClient {
             poolOwnerPublicKey: this.publicKey,
             assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
             assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
-            assetAInitialReserve: clippedAssetAInitialReserve,
-            virtualReserveA: clippedVirtualReserveA,
-            virtualReserveB: clippedVirtualReserveB,
-            threshold: params.threshold,
+            assetAInitialReserve: params.assetAInitialReserve,
+            graduationThresholdPct: params.assetAPctSoldAtGraduation,
+            targetBRaisedAtGraduation: params.targetBRaisedAtGraduation,
             lpFeeRateBps: params.lpFeeRateBps.toString(),
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
             hostNamespace: params.hostNamespace,
@@ -479,56 +427,29 @@ class FlashnetClient {
             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 using new address encoding
-                const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
-                    identityPublicKey: createResponse.poolId,
-                    network: this.sparkNetwork,
-                });
-                let assetATransferId;
-                if (params.assetAAddress === index$1.BTC_ASSET_PUBKEY) {
-                    const transfer = await this._wallet.transfer({
-                        amountSats: Number(clippedAssetAInitialReserve),
-                        receiverSparkAddress: lpSparkAddress,
-                    });
-                    assetATransferId = transfer.id;
-                }
-                else {
-                    assetATransferId = await this._wallet.transferTokens({
-                        tokenIdentifier: this.toHumanReadableTokenIdentifier(params.assetAAddress),
-                        tokenAmount: BigInt(clippedAssetAInitialReserve),
-                        receiverSparkAddress: lpSparkAddress,
-                    });
-                }
-                // Confirm the initial deposit
-                const confirmNonce = index$2.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)}`);
+        if (params.disableInitialDeposit) {
+            return createResponse;
+        }
+        try {
+            // Transfer initial reserve to the pool using new address encoding
+            const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
+                identityPublicKey: createResponse.poolId,
+                network: this.sparkNetwork,
+            });
+            const assetATransferId = await this.transferAsset({
+                receiverSparkAddress: lpSparkAddress,
+                assetAddress: params.assetAAddress,
+                amount: params.assetAInitialReserve,
+            });
+            const confirmResponse = await this.confirmInitialDeposit(createResponse.poolId, assetATransferId);
+            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;
     }
     /**
@@ -570,46 +491,30 @@ class FlashnetClient {
      */
     async executeSwap(params) {
         await this.ensureInitialized();
-        // Check balance
-        const requirements = {
-            tokens: new Map(),
-        };
-        if (params.assetInAddress === index$1.BTC_ASSET_PUBKEY) {
-            requirements.btc = BigInt(params.amountIn);
-        }
-        else {
-            requirements.tokens?.set(params.assetInAddress, BigInt(params.amountIn));
-        }
-        const balanceCheck = await this.checkBalance(requirements);
-        if (!balanceCheck.sufficient) {
-            throw new Error(`Insufficient balance for swap: ${balanceCheck.message}`);
-        }
         // Transfer assets to pool using new address encoding
         const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
             identityPublicKey: params.poolId,
             network: this.sparkNetwork,
         });
-        let transferId;
-        if (params.assetInAddress === index$1.BTC_ASSET_PUBKEY) {
-            const transfer = await this._wallet.transfer({
-                amountSats: Number(params.amountIn),
-                receiverSparkAddress: lpSparkAddress,
-            });
-            transferId = transfer.id;
-        }
-        else {
-            transferId = await this._wallet.transferTokens({
-                tokenIdentifier: this.toHumanReadableTokenIdentifier(params.assetInAddress),
-                tokenAmount: BigInt(params.amountIn),
-                receiverSparkAddress: lpSparkAddress,
-            });
-        }
+        const transferId = await this.transferAsset({
+            receiverSparkAddress: lpSparkAddress,
+            assetAddress: params.assetInAddress,
+            amount: params.amountIn,
+        }, "Insufficient balance for swap: ");
+        const response = await this.executeSwapIntent({
+            ...params,
+            transferId,
+        });
+        return response;
+    }
+    async executeSwapIntent(params) {
+        await this.ensureInitialized();
         // Generate swap intent
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generatePoolSwapIntentMessage({
             userPublicKey: this.publicKey,
             lpIdentityPublicKey: params.poolId,
-            assetInSparkTransferId: transferId,
+            assetInSparkTransferId: params.transferId,
             assetInTokenPublicKey: this.toHexTokenIdentifier(params.assetInAddress),
             assetOutTokenPublicKey: this.toHexTokenIdentifier(params.assetOutAddress),
             amountIn: params.amountIn.toString(),
@@ -629,7 +534,7 @@ class FlashnetClient {
             amountIn: params.amountIn.toString(),
             maxSlippageBps: params.maxSlippageBps?.toString(),
             minAmountOut: params.minAmountOut,
-            assetInSparkTransferId: transferId,
+            assetInSparkTransferId: params.transferId,
             totalIntegratorFeeRateBps: params.integratorFeeRateBps?.toString() || "0",
             integratorPublicKey: params.integratorPublicKey || "",
             nonce,
@@ -658,20 +563,6 @@ class FlashnetClient {
      */
     async executeRouteSwap(params) {
         await this.ensureInitialized();
-        // Check balance for initial asset
-        const requirements = {
-            tokens: new Map(),
-        };
-        if (params.initialAssetAddress === index$1.BTC_ASSET_PUBKEY) {
-            requirements.btc = BigInt(params.inputAmount);
-        }
-        else {
-            requirements.tokens?.set(params.initialAssetAddress, BigInt(params.inputAmount));
-        }
-        const balanceCheck = await this.checkBalance(requirements);
-        if (!balanceCheck.sufficient) {
-            throw new Error(`Insufficient balance for route swap: ${balanceCheck.message}`);
-        }
         // Validate hops array
         if (!params.hops.length) {
             throw new Error("Route swap requires at least one hop");
@@ -685,21 +576,11 @@ class FlashnetClient {
             identityPublicKey: firstPoolId,
             network: this.sparkNetwork,
         });
-        let initialTransferId;
-        if (params.initialAssetAddress === index$1.BTC_ASSET_PUBKEY) {
-            const transfer = await this._wallet.transfer({
-                amountSats: Number(params.inputAmount),
-                receiverSparkAddress: lpSparkAddress,
-            });
-            initialTransferId = transfer.id;
-        }
-        else {
-            initialTransferId = await this._wallet.transferTokens({
-                tokenIdentifier: this.toHumanReadableTokenIdentifier(params.initialAssetAddress),
-                tokenAmount: BigInt(params.inputAmount),
-                receiverSparkAddress: lpSparkAddress,
-            });
-        }
+        const initialTransferId = await this.transferAsset({
+            receiverSparkAddress: lpSparkAddress,
+            assetAddress: params.initialAssetAddress,
+            amount: params.inputAmount,
+        }, "Insufficient balance for route swap: ");
         // Prepare hops for validation
         const hops = params.hops.map((hop) => ({
             lpIdentityPublicKey: hop.poolId,
@@ -778,63 +659,23 @@ class FlashnetClient {
         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.assetAAddress === index$1.BTC_ASSET_PUBKEY) {
-            requirements.btc = BigInt(params.assetAAmount);
-        }
-        else {
-            requirements.tokens?.set(pool.assetAAddress, BigInt(params.assetAAmount));
-        }
-        if (pool.assetBAddress === index$1.BTC_ASSET_PUBKEY) {
-            requirements.btc = (requirements.btc || 0n) + BigInt(params.assetBAmount);
-        }
-        else {
-            requirements.tokens?.set(pool.assetBAddress, BigInt(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 using new address encoding
         const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
             identityPublicKey: params.poolId,
             network: this.sparkNetwork,
         });
-        // Transfer asset A
-        let assetATransferId;
-        if (pool.assetAAddress === index$1.BTC_ASSET_PUBKEY) {
-            const transfer = await this._wallet.transfer({
-                amountSats: Number(params.assetAAmount),
-                receiverSparkAddress: lpSparkAddress,
-            });
-            assetATransferId = transfer.id;
-        }
-        else {
-            assetATransferId = await this._wallet.transferTokens({
-                tokenIdentifier: this.toHumanReadableTokenIdentifier(pool.assetAAddress),
-                tokenAmount: BigInt(params.assetAAmount),
+        const [assetATransferId, assetBTransferId] = await this.transferAssets([
+            {
                 receiverSparkAddress: lpSparkAddress,
-            });
-        }
-        // Transfer asset B
-        let assetBTransferId;
-        if (pool.assetBAddress === index$1.BTC_ASSET_PUBKEY) {
-            const transfer = await this._wallet.transfer({
-                amountSats: Number(params.assetBAmount),
+                assetAddress: pool.assetAAddress,
+                amount: params.assetAAmount,
+            },
+            {
                 receiverSparkAddress: lpSparkAddress,
-            });
-            assetBTransferId = transfer.id;
-        }
-        else {
-            assetBTransferId = await this._wallet.transferTokens({
-                tokenIdentifier: this.toHumanReadableTokenIdentifier(pool.assetBAddress),
-                tokenAmount: BigInt(params.assetBAmount),
-                receiverSparkAddress: lpSparkAddress,
-            });
-        }
+                assetAddress: pool.assetBAddress,
+                amount: params.assetBAmount,
+            },
+        ], "Insufficient balance for adding liquidity: ");
         // Generate add liquidity intent
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generateAddLiquidityIntentMessage({
@@ -844,8 +685,6 @@ class FlashnetClient {
             assetBSparkTransferId: assetBTransferId,
             assetAAmount: params.assetAAmount.toString(),
             assetBAmount: params.assetBAmount.toString(),
-            assetAMinAmountIn: params.assetAMinAmountIn.toString(),
-            assetBMinAmountIn: params.assetBMinAmountIn.toString(),
             nonce,
         });
         // Sign intent
@@ -858,8 +697,6 @@ class FlashnetClient {
             assetBSparkTransferId: assetBTransferId,
             assetAAmountToAdd: params.assetAAmount.toString(),
             assetBAmountToAdd: params.assetBAmount.toString(),
-            assetAMinAmountIn: params.assetAMinAmountIn.toString(),
-            assetBMinAmountIn: params.assetBMinAmountIn.toString(),
             nonce,
             signature: Buffer.from(signature).toString("hex"),
         };
@@ -969,6 +806,7 @@ class FlashnetClient {
         const intentMessage = intents.generateWithdrawHostFeesIntentMessage({
             hostPublicKey: this.publicKey,
             lpIdentityPublicKey: params.lpIdentityPublicKey,
+            assetAAmount: params.assetAAmount,
             assetBAmount: params.assetBAmount,
             nonce,
         });
@@ -977,6 +815,7 @@ class FlashnetClient {
         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"),
@@ -1008,6 +847,7 @@ class FlashnetClient {
         const intentMessage = intents.generateWithdrawIntegratorFeesIntentMessage({
             integratorPublicKey: this.publicKey,
             lpIdentityPublicKey: params.lpIdentityPublicKey,
+            assetAAmount: params.assetAAmount,
             assetBAmount: params.assetBAmount,
             nonce,
         });
@@ -1017,6 +857,7 @@ class FlashnetClient {
         const request = {
             integratorPublicKey: this.publicKey,
             lpIdentityPublicKey: params.lpIdentityPublicKey,
+            assetAAmount: params.assetAAmount,
             assetBAmount: params.assetBAmount,
             nonce,
             signature: Buffer.from(signature).toString("hex"),
@@ -1036,151 +877,6 @@ class FlashnetClient {
         await this.ensureInitialized();
         return this.typedApi.getIntegratorFees();
     }
-    // ===== Escrow Operations =====
-    /**
-     * Creates a new escrow contract.
-     * This is the first step in a two-step process: create, then fund.
-     * @param params Parameters to create the escrow.
-     * @returns The escrow creation response, including the ID and deposit address.
-     */
-    async createEscrow(params) {
-        await this.ensureInitialized();
-        const nonce = index$2.generateNonce();
-        // The intent message requires a different structure for recipients and conditions
-        const intentRecipients = params.recipients.map((r) => ({
-            recipientId: r.id,
-            amount: r.amount,
-            hasClaimed: false, // Default value for creation
-        }));
-        const intentMessage = intents.generateCreateEscrowIntentMessage({
-            creatorPublicKey: this.publicKey,
-            assetId: params.assetId,
-            assetAmount: params.assetAmount,
-            recipients: intentRecipients,
-            claimConditions: params.claimConditions, // Assuming API `Condition` is compatible
-            abandonHost: params.abandonHost,
-            abandonConditions: params.abandonConditions || undefined,
-            nonce,
-        });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
-        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
-        const request = {
-            creatorPublicKey: this.publicKey,
-            assetId: params.assetId,
-            assetAmount: params.assetAmount,
-            recipients: params.recipients,
-            claimConditions: params.claimConditions,
-            abandonHost: params.abandonHost,
-            abandonConditions: params.abandonConditions,
-            nonce,
-            signature: Buffer.from(signature).toString("hex"),
-        };
-        const createResponse = await this.typedApi.createEscrow(request);
-        const autoFund = params.autoFund !== false;
-        if (!autoFund) {
-            return createResponse;
-        }
-        // Auto-fund the escrow
-        return this.fundEscrow({
-            escrowId: createResponse.escrowId,
-            depositAddress: createResponse.depositAddress,
-            assetId: params.assetId,
-            assetAmount: params.assetAmount,
-        });
-    }
-    /**
-     * Funds an escrow contract to activate it.
-     * This handles the asset transfer and confirmation in one step.
-     * @param params Parameters to fund the escrow, including asset details and deposit address.
-     * @returns The funding confirmation response.
-     */
-    async fundEscrow(params) {
-        await this.ensureInitialized();
-        // 1. Balance check
-        const requirements = {
-            tokens: new Map(),
-        };
-        if (params.assetId === index$1.BTC_ASSET_PUBKEY) {
-            requirements.btc = BigInt(params.assetAmount);
-        }
-        else {
-            requirements.tokens?.set(params.assetId, BigInt(params.assetAmount));
-        }
-        const balanceCheck = await this.checkBalance(requirements);
-        if (!balanceCheck.sufficient) {
-            throw new Error(`Insufficient balance to fund escrow: ${balanceCheck.message}`);
-        }
-        // 2. Perform transfer
-        const escrowSparkAddress = sparkAddress.encodeSparkAddressNew({
-            identityPublicKey: params.depositAddress,
-            network: this.sparkNetwork,
-        });
-        let sparkTransferId;
-        if (params.assetId === index$1.BTC_ASSET_PUBKEY) {
-            const transfer = await this._wallet.transfer({
-                amountSats: Number(params.assetAmount),
-                receiverSparkAddress: escrowSparkAddress,
-            });
-            sparkTransferId = transfer.id;
-        }
-        else {
-            sparkTransferId = await this._wallet.transferTokens({
-                tokenIdentifier: this.toHumanReadableTokenIdentifier(params.assetId),
-                tokenAmount: BigInt(params.assetAmount),
-                receiverSparkAddress: escrowSparkAddress,
-            });
-        }
-        // 3. Generate intent, sign, and call API
-        const nonce = index$2.generateNonce();
-        const intentMessage = intents.generateFundEscrowIntentMessage({
-            escrowId: params.escrowId,
-            creatorPublicKey: this.publicKey,
-            sparkTransferId,
-            nonce,
-        });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
-        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
-        const request = {
-            escrowId: params.escrowId,
-            sparkTransferId,
-            nonce,
-            signature: Buffer.from(signature).toString("hex"),
-        };
-        return this.typedApi.fundEscrow(request);
-    }
-    /**
-     * Claims funds from an active escrow contract.
-     * The caller must be a valid recipient and all claim conditions must be met.
-     * @param params Parameters for the claim.
-     * @returns The claim processing response.
-     */
-    async claimEscrow(params) {
-        await this.ensureInitialized();
-        const nonce = index$2.generateNonce();
-        const intentMessage = intents.generateClaimEscrowIntentMessage({
-            escrowId: params.escrowId,
-            recipientPublicKey: this.publicKey,
-            nonce,
-        });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
-        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
-        const request = {
-            escrowId: params.escrowId,
-            nonce,
-            signature: Buffer.from(signature).toString("hex"),
-        };
-        return this.typedApi.claimEscrow(request);
-    }
-    /**
-     * Retrieves the current state of an escrow contract.
-     * This is a read-only operation and does not require authentication.
-     * @param escrowId The unique identifier of the escrow.
-     * @returns The full state of the escrow.
-     */
-    async getEscrow(escrowId) {
-        await this.ensureInitialized();
-        return this.typedApi.getEscrow(escrowId);
-    }
     // ===== Swap History =====
     /**
      * Get swaps for a specific pool
@@ -1248,46 +944,64 @@ class FlashnetClient {
         return this.typedApi.ping();
     }
     // ===== Helper Methods =====
+    /**
+     * Performs asset transfer using generalized asset address for both BTC and tokens.
+     */
+    async transferAsset(recipient, checkBalanceErrorPrefix) {
+        const transferIds = await this.transferAssets([recipient], checkBalanceErrorPrefix);
+        return transferIds[0];
+    }
+    /**
+     * Performs asset transfers using generalized asset addresses for both BTC and tokens.
+     * Supports optional generic to hardcode recipients length so output list can be typed with same length.
+     */
+    async transferAssets(recipients, checkBalanceErrorPrefix) {
+        if (checkBalanceErrorPrefix) {
+            await this.checkBalance({
+                balancesToCheck: recipients,
+                errorPrefix: checkBalanceErrorPrefix,
+            });
+        }
+        const transferIds = [];
+        for (const recipient of recipients) {
+            if (recipient.assetAddress === index$1.BTC_ASSET_PUBKEY) {
+                const transfer = await this._wallet.transfer({
+                    amountSats: Number(recipient.amount),
+                    receiverSparkAddress: recipient.receiverSparkAddress,
+                });
+                transferIds.push(transfer.id);
+            }
+            else {
+                const transferId = await this._wallet.transferTokens({
+                    tokenIdentifier: this.toHumanReadableTokenIdentifier(recipient.assetAddress),
+                    tokenAmount: BigInt(recipient.amount),
+                    receiverSparkAddress: recipient.receiverSparkAddress,
+                });
+                transferIds.push(transferId);
+            }
+        }
+        return transferIds;
+    }
     /**
      * Helper method to add initial liquidity after pool creation
      */
-    async addInitialLiquidity(poolId, assetAAddress, assetBAddress, assetAAmount, assetBAmount, assetAMinAmountIn, assetBMinAmountIn) {
+    async addInitialLiquidity(poolId, assetAAddress, assetBAddress, assetAAmount, assetBAmount) {
         const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
             identityPublicKey: poolId,
             network: this.sparkNetwork,
         });
-        // Transfer asset A
-        let assetATransferId;
-        if (assetAAddress === index$1.BTC_ASSET_PUBKEY) {
-            const transfer = await this._wallet.transfer({
-                amountSats: Number(assetAAmount),
+        const [assetATransferId, assetBTransferId] = await this.transferAssets([
+            {
                 receiverSparkAddress: lpSparkAddress,
-            });
-            assetATransferId = transfer.id;
-        }
-        else {
-            assetATransferId = await this._wallet.transferTokens({
-                tokenIdentifier: this.toHumanReadableTokenIdentifier(assetAAddress),
-                tokenAmount: BigInt(assetAAmount),
-                receiverSparkAddress: lpSparkAddress,
-            });
-        }
-        // Transfer asset B
-        let assetBTransferId;
-        if (assetBAddress === index$1.BTC_ASSET_PUBKEY) {
-            const transfer = await this._wallet.transfer({
-                amountSats: Number(assetBAmount),
+                assetAddress: assetAAddress,
+                amount: assetAAmount,
+            },
+            {
                 receiverSparkAddress: lpSparkAddress,
-            });
-            assetBTransferId = transfer.id;
-        }
-        else {
-            assetBTransferId = await this._wallet.transferTokens({
-                tokenIdentifier: this.toHumanReadableTokenIdentifier(assetBAddress),
-                tokenAmount: BigInt(assetBAmount),
-                receiverSparkAddress: lpSparkAddress,
-            });
-        }
+                assetAddress: assetBAddress,
+                amount: assetBAmount,
+            },
+        ]);
         // Add liquidity
         const nonce = index$2.generateNonce();
         const intentMessage = intents.generateAddLiquidityIntentMessage({
@@ -1297,8 +1011,6 @@ class FlashnetClient {
             assetBSparkTransferId: assetBTransferId,
             assetAAmount: assetAAmount.toString(),
             assetBAmount: assetBAmount.toString(),
-            assetAMinAmountIn: assetAMinAmountIn.toString(),
-            assetBMinAmountIn: assetBMinAmountIn.toString(),
             nonce,
         });
         const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
@@ -1310,8 +1022,6 @@ class FlashnetClient {
             assetBSparkTransferId: assetBTransferId,
             assetAAmountToAdd: assetAAmount.toString(),
             assetBAmountToAdd: assetBAmount.toString(),
-            assetAMinAmountIn: assetAMinAmountIn.toString(),
-            assetBMinAmountIn: assetBMinAmountIn.toString(),
             nonce,
             signature: Buffer.from(signature).toString("hex"),
         };