@flashnet/sdk 0.4.4 → 0.5.0

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

@@ -6,7 +6,7 @@ import { getSparkNetworkFromLegacy, getClientEnvironmentFromLegacy, Network } fr
 import { generateNonce, compareDecimalStrings } from '../utils/index.js';
 import { AuthManager } from '../utils/auth.js';
 import { getHexFromUint8Array } from '../utils/hex.js';
-import { generateConstantProductPoolInitializationIntentMessage, generatePoolInitializationIntentMessage, generatePoolConfirmInitialDepositIntentMessage, generatePoolSwapIntentMessage, generateRouteSwapIntentMessage, generateAddLiquidityIntentMessage, generateRemoveLiquidityIntentMessage, generateRegisterHostIntentMessage, generateWithdrawHostFeesIntentMessage, generateWithdrawIntegratorFeesIntentMessage, generateCreateEscrowIntentMessage, generateFundEscrowIntentMessage, generateClaimEscrowIntentMessage, generateClawbackIntentMessage } from '../utils/intents.js';
+import { generateConstantProductPoolInitializationIntentMessage, generatePoolInitializationIntentMessage, generatePoolConfirmInitialDepositIntentMessage, generatePoolSwapIntentMessage, generateRouteSwapIntentMessage, generateAddLiquidityIntentMessage, generateRemoveLiquidityIntentMessage, generateRegisterHostIntentMessage, generateWithdrawHostFeesIntentMessage, generateWithdrawIntegratorFeesIntentMessage, generateCreateEscrowIntentMessage, generateFundEscrowIntentMessage, generateClaimEscrowIntentMessage, generateClawbackIntentMessage, generateCreateConcentratedPoolIntentMessage, generateDecreaseLiquidityIntentMessage, generateCollectFeesIntentMessage, generateWithdrawBalanceIntentMessage, generateIncreaseLiquidityIntentMessage, generateRebalancePositionIntentMessage } from '../utils/intents.js';
 import { getSparkNetworkFromAddress, encodeSparkAddressNew } from '../utils/spark-address.js';
 import { encodeSparkHumanReadableTokenIdentifier, decodeSparkHumanReadableTokenIdentifier } from '../utils/tokenAddress.js';
 import { FlashnetError } from '../types/errors.js';
@@ -299,7 +299,7 @@ class FlashnetClient {
             }
         }
     }
-    // ===== Pool Operations =====
+    // Pool Operations
     /**
      * List pools with optional filters
      */
@@ -562,7 +562,7 @@ class FlashnetClient {
         };
         return this.typedApi.confirmInitialDeposit(request);
     }
-    // ===== Swap Operations =====
+    // Swap Operations
     /**
      * Simulate a swap without executing it
      */
@@ -811,7 +811,7 @@ class FlashnetClient {
             return response;
         }, [initialTransferId], firstPoolId);
     }
-    // ===== Liquidity Operations =====
+    // Liquidity Operations
     /**
      * Simulate adding liquidity
      */
@@ -962,7 +962,7 @@ class FlashnetClient {
         }
         return response;
     }
-    // ===== Host Operations =====
+    // Host Operations
     /**
      * Register as a host
      */
@@ -1108,7 +1108,7 @@ class FlashnetClient {
         await this.ensureInitialized();
         return this.typedApi.getIntegratorFees();
     }
-    // ===== Escrow Operations =====
+    // Escrow Operations
     /**
      * Creates a new escrow contract.
      * This is the first step in a two-step process: create, then fund.
@@ -1247,7 +1247,7 @@ class FlashnetClient {
         await this.ensureInitialized();
         return this.typedApi.getEscrow(escrowId);
     }
-    // ===== Swap History =====
+    // Swap History
     /**
      * Get swaps for a specific pool
      */
@@ -1270,7 +1270,7 @@ class FlashnetClient {
         const user = userPublicKey || this.publicKey;
         return this.typedApi.getUserSwaps(user, query);
     }
-    // ===== Clawback =====
+    // Clawback
     /**
      * Request clawback of a stuck inbound transfer to an LP wallet
      */
@@ -1455,7 +1455,7 @@ class FlashnetClient {
             throw flashnetError;
         }
     }
-    // ===== Clawback Monitor =====
+    // Clawback Monitor
     /**
      * Start a background job that periodically polls for clawbackable transfers
      * and automatically claws them back.
@@ -1589,7 +1589,7 @@ class FlashnetClient {
             },
         };
     }
-    // ===== Token Address Operations =====
+    // Token Address Operations
     /**
      * Encode a token identifier into a human-readable token address using the client's Spark network
      * @param tokenIdentifier - Token identifier as hex string or Uint8Array
@@ -1624,8 +1624,8 @@ class FlashnetClient {
     decodeLegacyTokenAddress(address) {
         return decodeSparkHumanReadableTokenIdentifier(address, this.sparkNetwork);
     }
-    // ===== Status =====
-    // ===== Config Inspection =====
+    // Status
+    // Config Inspection
     /**
      * Get raw feature status list (cached briefly)
      */
@@ -1686,7 +1686,7 @@ class FlashnetClient {
         await this.ensureInitialized();
         return this.typedApi.ping();
     }
-    // ===== Helper Methods =====
+    // Helper Methods
     /**
      * Performs asset transfer using generalized asset address for both BTC and tokens.
      */
@@ -1786,7 +1786,7 @@ class FlashnetClient {
             throw new Error(errorMessage);
         }
     }
-    // ===== Lightning Payment with Token =====
+    // Lightning Payment with Token
     /**
      * Get a quote for paying a Lightning invoice with a token.
      * This calculates the optimal pool and token amount needed.
@@ -2488,7 +2488,7 @@ class FlashnetClient {
     async cleanup() {
         await this._wallet.cleanupConnections();
     }
-    // ===== Config and Policy Enforcement Helpers =====
+    // Config and Policy Enforcement Helpers
     async ensureAmmOperationAllowed(requiredFeature) {
         await this.ensurePingOk();
         const featureMap = await this.getFeatureStatusMap();
@@ -2668,6 +2668,470 @@ ${relaxed.toString()} (50% relaxed), provided minAmountOut ${minAmountOut.toStri
             throw new Error(`Asset B is not allowed for pool creation: ${assetBHex}`);
         }
     }
+    // V3 Concentrated Liquidity Operations
+    /**
+     * Create a V3 concentrated liquidity pool
+     *
+     * Concentrated liquidity pools allow LPs to provide liquidity within specific
+     * price ranges (tick ranges) for higher capital efficiency.
+     *
+     * @param params Pool creation parameters
+     * @param params.assetAAddress - Address of asset A (base asset)
+     * @param params.assetBAddress - Address of asset B (quote asset)
+     * @param params.tickSpacing - Tick spacing (common values: 10, 60, 200)
+     * @param params.initialPrice - Initial price of asset A in terms of asset B
+     * @param params.lpFeeRateBps - LP fee rate in basis points
+     * @param params.hostFeeRateBps - Host fee rate in basis points
+     * @param params.hostNamespace - Optional host namespace
+     * @param params.poolOwnerPublicKey - Optional pool owner (defaults to wallet pubkey)
+     */
+    async createConcentratedPool(params) {
+        await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_pool_creation");
+        await this.assertAllowedAssetBForPoolCreation(this.toHexTokenIdentifier(params.assetBAddress));
+        const poolOwnerPublicKey = params.poolOwnerPublicKey ?? this.publicKey;
+        // Generate intent
+        const nonce = generateNonce();
+        const intentMessage = generateCreateConcentratedPoolIntentMessage({
+            poolOwnerPublicKey,
+            assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
+            assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
+            tickSpacing: params.tickSpacing,
+            initialPrice: params.initialPrice,
+            lpFeeRateBps: params.lpFeeRateBps.toString(),
+            hostFeeRateBps: params.hostFeeRateBps.toString(),
+            nonce,
+        });
+        // Sign intent
+        const messageHash = sha256(intentMessage);
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            poolOwnerPublicKey,
+            assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
+            assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
+            tickSpacing: params.tickSpacing,
+            initialPrice: params.initialPrice,
+            lpFeeRateBps: params.lpFeeRateBps.toString(),
+            hostFeeRateBps: params.hostFeeRateBps.toString(),
+            hostNamespace: params.hostNamespace,
+            nonce,
+            signature: getHexFromUint8Array(signature),
+        };
+        return this.typedApi.createConcentratedPool(request);
+    }
+    /**
+     * Add liquidity to a V3 concentrated position
+     *
+     * Increases liquidity within a specific tick range. If the position doesn't exist,
+     * a new position is created.
+     *
+     * @param params Position parameters
+     * @param params.poolId - Pool ID (LP identity public key)
+     * @param params.tickLower - Lower tick of the position
+     * @param params.tickUpper - Upper tick of the position
+     * @param params.amountADesired - Desired amount of asset A to add
+     * @param params.amountBDesired - Desired amount of asset B to add
+     * @param params.amountAMin - Minimum amount of asset A (slippage protection)
+     * @param params.amountBMin - Minimum amount of asset B (slippage protection)
+     * @param params.useFreeBalanceA - If true, use free balance from pool for asset A instead of Spark transfer
+     * @param params.useFreeBalanceB - If true, use free balance from pool for asset B instead of Spark transfer
+     * @param params.retainExcessInBalance - If true, retain any excess amounts in pool free balance instead of refunding via Spark
+     */
+    async increaseLiquidity(params) {
+        await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_add_liquidity");
+        // Get pool details to know asset addresses
+        const pool = await this.getPool(params.poolId);
+        // Transfer assets to pool (unless using free balance)
+        const lpSparkAddress = encodeSparkAddressNew({
+            identityPublicKey: params.poolId,
+            network: this.sparkNetwork,
+        });
+        let assetATransferId = "";
+        let assetBTransferId = "";
+        const transferIds = [];
+        // Transfer asset A if not using free balance
+        if (!params.useFreeBalanceA && BigInt(params.amountADesired) > 0n) {
+            assetATransferId = await this.transferAsset({
+                receiverSparkAddress: lpSparkAddress,
+                assetAddress: pool.assetAAddress,
+                amount: params.amountADesired,
+            }, "Insufficient balance for adding V3 liquidity (Asset A): ");
+            transferIds.push(assetATransferId);
+        }
+        // Transfer asset B if not using free balance
+        if (!params.useFreeBalanceB && BigInt(params.amountBDesired) > 0n) {
+            assetBTransferId = await this.transferAsset({
+                receiverSparkAddress: lpSparkAddress,
+                assetAddress: pool.assetBAddress,
+                amount: params.amountBDesired,
+            }, "Insufficient balance for adding V3 liquidity (Asset B): ");
+            transferIds.push(assetBTransferId);
+        }
+        const executeIncrease = async () => {
+            // Generate intent
+            const nonce = generateNonce();
+            const intentMessage = generateIncreaseLiquidityIntentMessage({
+                userPublicKey: this.publicKey,
+                lpIdentityPublicKey: params.poolId,
+                tickLower: params.tickLower,
+                tickUpper: params.tickUpper,
+                assetASparkTransferId: assetATransferId,
+                assetBSparkTransferId: assetBTransferId,
+                amountADesired: params.amountADesired,
+                amountBDesired: params.amountBDesired,
+                amountAMin: params.amountAMin,
+                amountBMin: params.amountBMin,
+                nonce,
+            });
+            // Sign intent
+            const messageHash = sha256(intentMessage);
+            const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+            const request = {
+                poolId: params.poolId,
+                tickLower: params.tickLower,
+                tickUpper: params.tickUpper,
+                assetASparkTransferId: assetATransferId,
+                assetBSparkTransferId: assetBTransferId,
+                amountADesired: params.amountADesired,
+                amountBDesired: params.amountBDesired,
+                amountAMin: params.amountAMin,
+                amountBMin: params.amountBMin,
+                useFreeBalanceA: params.useFreeBalanceA,
+                useFreeBalanceB: params.useFreeBalanceB,
+                retainExcessInBalance: params.retainExcessInBalance,
+                nonce,
+                signature: getHexFromUint8Array(signature),
+            };
+            const response = await this.typedApi.increaseLiquidity(request);
+            if (!response.accepted) {
+                const errorMessage = response.error || "Increase liquidity rejected by the AMM";
+                const hasRefund = !!(response.amountARefund || response.amountBRefund);
+                const refundInfo = hasRefund
+                    ? ` Refunds: Asset A: ${response.amountARefund || "0"}, Asset B: ${response.amountBRefund || "0"}`
+                    : "";
+                throw new FlashnetError(`${errorMessage}.${refundInfo}`, {
+                    response: {
+                        errorCode: hasRefund ? "FSAG-4203" : "UNKNOWN",
+                        errorCategory: hasRefund ? "Business" : "System",
+                        message: `${errorMessage}.${refundInfo}`,
+                        requestId: response.requestId || "",
+                        timestamp: new Date().toISOString(),
+                        service: "amm-gateway",
+                        severity: "Error",
+                    },
+                    httpStatus: 400,
+                    transferIds: hasRefund ? [] : transferIds,
+                    lpIdentityPublicKey: params.poolId,
+                });
+            }
+            return response;
+        };
+        // Execute with auto-clawback if we made transfers
+        if (transferIds.length > 0) {
+            return this.executeWithAutoClawback(executeIncrease, transferIds, params.poolId);
+        }
+        return executeIncrease();
+    }
+    /**
+     * Remove liquidity from a V3 concentrated position
+     *
+     * Decreases liquidity from a specific tick range position.
+     *
+     * @param params Position parameters
+     * @param params.poolId - Pool ID (LP identity public key)
+     * @param params.tickLower - Lower tick of the position
+     * @param params.tickUpper - Upper tick of the position
+     * @param params.liquidityToRemove - Amount of liquidity to remove (use "0" to remove all)
+     * @param params.amountAMin - Minimum amount of asset A to receive (slippage protection)
+     * @param params.amountBMin - Minimum amount of asset B to receive (slippage protection)
+     * @param params.retainInBalance - If true, retain withdrawn assets in pool free balance instead of sending via Spark
+     */
+    async decreaseLiquidity(params) {
+        await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_withdraw_liquidity");
+        // Generate intent
+        const nonce = generateNonce();
+        const intentMessage = generateDecreaseLiquidityIntentMessage({
+            userPublicKey: this.publicKey,
+            lpIdentityPublicKey: params.poolId,
+            tickLower: params.tickLower,
+            tickUpper: params.tickUpper,
+            liquidityToRemove: params.liquidityToRemove,
+            amountAMin: params.amountAMin,
+            amountBMin: params.amountBMin,
+            nonce,
+        });
+        // Sign intent
+        const messageHash = sha256(intentMessage);
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            poolId: params.poolId,
+            tickLower: params.tickLower,
+            tickUpper: params.tickUpper,
+            liquidityToRemove: params.liquidityToRemove,
+            amountAMin: params.amountAMin,
+            amountBMin: params.amountBMin,
+            retainInBalance: params.retainInBalance,
+            nonce,
+            signature: getHexFromUint8Array(signature),
+        };
+        const response = await this.typedApi.decreaseLiquidity(request);
+        if (!response.accepted) {
+            const errorMessage = response.error || "Decrease liquidity rejected by the AMM";
+            throw new Error(errorMessage);
+        }
+        return response;
+    }
+    /**
+     * Collect accumulated fees from a V3 position
+     *
+     * Collects fees earned from trading activity without removing liquidity.
+     *
+     * @param params Position parameters
+     * @param params.poolId - Pool ID (LP identity public key)
+     * @param params.tickLower - Lower tick of the position
+     * @param params.tickUpper - Upper tick of the position
+     * @param params.retainInBalance - If true, retain collected fees in pool free balance instead of sending via Spark
+     */
+    async collectFees(params) {
+        await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_withdraw_fees");
+        // Generate intent
+        const nonce = generateNonce();
+        const intentMessage = generateCollectFeesIntentMessage({
+            userPublicKey: this.publicKey,
+            lpIdentityPublicKey: params.poolId,
+            tickLower: params.tickLower,
+            tickUpper: params.tickUpper,
+            nonce,
+        });
+        // Sign intent
+        const messageHash = sha256(intentMessage);
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            poolId: params.poolId,
+            tickLower: params.tickLower,
+            tickUpper: params.tickUpper,
+            retainInBalance: params.retainInBalance,
+            nonce,
+            signature: getHexFromUint8Array(signature),
+        };
+        const response = await this.typedApi.collectFees(request);
+        if (!response.accepted) {
+            const errorMessage = response.error || "Collect fees rejected by the AMM";
+            throw new Error(errorMessage);
+        }
+        return response;
+    }
+    /**
+     * Rebalance a V3 position to a new tick range
+     *
+     * Atomically moves liquidity from an old position to a new tick range.
+     * Optionally can add additional funds during rebalancing.
+     *
+     * @param params Rebalance parameters
+     * @param params.poolId - Pool ID (LP identity public key)
+     * @param params.oldTickLower - Lower tick of the current position
+     * @param params.oldTickUpper - Upper tick of the current position
+     * @param params.newTickLower - Lower tick for the new position
+     * @param params.newTickUpper - Upper tick for the new position
+     * @param params.liquidityToMove - Amount of liquidity to move (use "0" to move all)
+     * @param params.additionalAmountA - Optional additional asset A to add
+     * @param params.additionalAmountB - Optional additional asset B to add
+     * @param params.retainInBalance - If true, retain any excess amounts in pool free balance instead of sending via Spark
+     */
+    async rebalancePosition(params) {
+        await this.ensureInitialized();
+        await this.ensureAmmOperationAllowed("allow_add_liquidity");
+        // Get pool details
+        const pool = await this.getPool(params.poolId);
+        // Transfer additional assets if provided
+        let assetATransferId;
+        let assetBTransferId;
+        const lpSparkAddress = encodeSparkAddressNew({
+            identityPublicKey: params.poolId,
+            network: this.sparkNetwork,
+        });
+        if (params.additionalAmountA && BigInt(params.additionalAmountA) > 0n) {
+            assetATransferId = await this.transferAsset({
+                receiverSparkAddress: lpSparkAddress,
+                assetAddress: pool.assetAAddress,
+                amount: params.additionalAmountA,
+            }, "Insufficient balance for rebalance (Asset A): ");
+        }
+        if (params.additionalAmountB && BigInt(params.additionalAmountB) > 0n) {
+            assetBTransferId = await this.transferAsset({
+                receiverSparkAddress: lpSparkAddress,
+                assetAddress: pool.assetBAddress,
+                amount: params.additionalAmountB,
+            }, "Insufficient balance for rebalance (Asset B): ");
+        }
+        // Collect transfer IDs for potential clawback
+        const transferIds = [];
+        if (assetATransferId) {
+            transferIds.push(assetATransferId);
+        }
+        if (assetBTransferId) {
+            transferIds.push(assetBTransferId);
+        }
+        // Execute (with auto-clawback if we have transfers)
+        const executeRebalance = async () => {
+            // Generate intent
+            const nonce = generateNonce();
+            const intentMessage = generateRebalancePositionIntentMessage({
+                userPublicKey: this.publicKey,
+                lpIdentityPublicKey: params.poolId,
+                oldTickLower: params.oldTickLower,
+                oldTickUpper: params.oldTickUpper,
+                newTickLower: params.newTickLower,
+                newTickUpper: params.newTickUpper,
+                liquidityToMove: params.liquidityToMove,
+                assetASparkTransferId: assetATransferId,
+                assetBSparkTransferId: assetBTransferId,
+                additionalAmountA: params.additionalAmountA,
+                additionalAmountB: params.additionalAmountB,
+                nonce,
+            });
+            // Sign intent
+            const messageHash = sha256(intentMessage);
+            const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+            const request = {
+                poolId: params.poolId,
+                oldTickLower: params.oldTickLower,
+                oldTickUpper: params.oldTickUpper,
+                newTickLower: params.newTickLower,
+                newTickUpper: params.newTickUpper,
+                liquidityToMove: params.liquidityToMove,
+                assetASparkTransferId: assetATransferId,
+                assetBSparkTransferId: assetBTransferId,
+                additionalAmountA: params.additionalAmountA,
+                additionalAmountB: params.additionalAmountB,
+                retainInBalance: params.retainInBalance,
+                nonce,
+                signature: getHexFromUint8Array(signature),
+            };
+            const response = await this.typedApi.rebalancePosition(request);
+            if (!response.accepted) {
+                const errorMessage = response.error || "Rebalance position rejected by the AMM";
+                throw new FlashnetError(errorMessage, {
+                    response: {
+                        errorCode: "UNKNOWN",
+                        errorCategory: "System",
+                        message: errorMessage,
+                        requestId: response.requestId || "",
+                        timestamp: new Date().toISOString(),
+                        service: "amm-gateway",
+                        severity: "Error",
+                    },
+                    httpStatus: 400,
+                    transferIds,
+                    lpIdentityPublicKey: params.poolId,
+                });
+            }
+            return response;
+        };
+        // Use auto-clawback if we made transfers
+        if (transferIds.length > 0) {
+            return this.executeWithAutoClawback(executeRebalance, transferIds, params.poolId);
+        }
+        return executeRebalance();
+    }
+    /**
+     * List V3 concentrated liquidity positions
+     *
+     * @param query Optional query parameters
+     * @param query.poolId - Filter by pool ID
+     * @param query.page - Page number (default: 1)
+     * @param query.pageSize - Page size (default: 20, max: 100)
+     */
+    async listConcentratedPositions(query) {
+        await this.ensureInitialized();
+        return this.typedApi.listConcentratedPositions(query);
+    }
+    /**
+     * Get pool liquidity distribution for visualization
+     *
+     * Returns aggregated liquidity ranges for visualizing the liquidity distribution.
+     *
+     * @param poolId - Pool ID (LP identity public key)
+     */
+    async getPoolLiquidity(poolId) {
+        await this.ensureInitialized();
+        return this.typedApi.getPoolLiquidity(poolId);
+    }
+    /**
+     * Get pool ticks for simulation
+     *
+     * Returns all initialized ticks with their liquidity deltas for swap simulation.
+     *
+     * @param poolId - Pool ID (LP identity public key)
+     */
+    async getPoolTicks(poolId) {
+        await this.ensureInitialized();
+        return this.typedApi.getPoolTicks(poolId);
+    }
+    // V3 Free Balance Methods
+    /**
+     * Get user's free balance for a specific V3 pool
+     *
+     * Returns the user's current free balance in the pool, which can be used for
+     * liquidity operations without needing to transfer from the wallet.
+     *
+     * @param poolId - Pool ID (LP identity public key)
+     */
+    async getConcentratedBalance(poolId) {
+        await this.ensureInitialized();
+        return this.typedApi.getConcentratedBalance(poolId);
+    }
+    /**
+     * Get user's free balances across all V3 pools
+     *
+     * Returns all free balances for the authenticated user across all V3 pools.
+     */
+    async getConcentratedBalances() {
+        await this.ensureInitialized();
+        return this.typedApi.getConcentratedBalances();
+    }
+    /**
+     * Withdraw free balance from a V3 pool to user's Spark wallet
+     *
+     * Withdraws accumulated free balance from a pool. Use "0" to skip an asset,
+     * or "max" to withdraw all available balance of that asset.
+     *
+     * @param params Withdrawal parameters
+     * @param params.poolId - Pool ID (LP identity public key)
+     * @param params.amountA - Amount of asset A to withdraw ("0" to skip, "max" to withdraw all)
+     * @param params.amountB - Amount of asset B to withdraw ("0" to skip, "max" to withdraw all)
+     */
+    async withdrawConcentratedBalance(params) {
+        await this.ensureInitialized();
+        // Generate intent
+        const nonce = generateNonce();
+        const intentMessage = generateWithdrawBalanceIntentMessage({
+            userPublicKey: this.publicKey,
+            lpIdentityPublicKey: params.poolId,
+            amountA: params.amountA,
+            amountB: params.amountB,
+            nonce,
+        });
+        // Sign intent
+        const messageHash = sha256(intentMessage);
+        const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
+        const request = {
+            poolId: params.poolId,
+            amountA: params.amountA,
+            amountB: params.amountB,
+            nonce,
+            signature: getHexFromUint8Array(signature),
+        };
+        const response = await this.typedApi.withdrawConcentratedBalance(request);
+        if (!response.accepted) {
+            const errorMessage = response.error || "Withdraw balance rejected by the AMM";
+            throw new Error(errorMessage);
+        }
+        return response;
+    }
 }
 
 export { FlashnetClient };