@flaunch/sdk 0.9.5 → 0.9.7

package/dist/index.esm.js

@@ -13998,17 +13998,18 @@ class ReadWriteFlaunchZap extends ReadFlaunchZap {
      * @param params.initialMarketCapUSD - Initial market cap in USD
      * @param params.creator - Address of the token creator
      * @param params.creatorFeeAllocationPercent - Percentage of fees allocated to creator (0-100)
-     * @param params.creatorSplitPercent - Percentage of fees allocated to creator (0-100)
+     * @param params.creatorSplitPercent - Split percentage of the fees for the creator (0-100)
+     * @param params.managerOwnerSplitPercent - Split percentage of the fees for the manager owner (0-100)
      * @param params.splitReceivers - List of recipients and their percentage of the fees
      * @param params.flaunchAt - Optional timestamp when the flaunch should start
      * @param params.premineAmount - Optional amount of tokens to premine
-     * @param params.creatorSplitPercent - Split percentage of the fees for the creator (0-100)
-     * @param params.splitReceivers - List of recipients and their percentage of the fees
+     * @param params.treasuryManagerParams - Optional treasury manager configuration
      * @returns Transaction response for the flaunch creation
      */
     async flaunchWithSplitManager(params) {
         const VALID_SHARE_TOTAL = 10000000n; // 5 decimals as BigInt
         let creatorShare = (BigInt(params.creatorSplitPercent) * VALID_SHARE_TOTAL) / 100n;
+        const managerOwnerShare = (BigInt(params.managerOwnerSplitPercent) * VALID_SHARE_TOTAL) / 100n;
         const recipientShares = params.splitReceivers.map((receiver) => {
             return {
                 recipient: receiver.address,
@@ -14017,7 +14018,7 @@ class ReadWriteFlaunchZap extends ReadFlaunchZap {
         });
         const totalRecipientShares = recipientShares.reduce((acc, curr) => acc + curr.share, 0n);
         // if there's a remainder (due to rounding errors), add it to the creator share
-        const remainderShares = VALID_SHARE_TOTAL - totalRecipientShares;
+        const remainderShares = VALID_SHARE_TOTAL - totalRecipientShares - managerOwnerShare;
         creatorShare += remainderShares;
         const initializeData = encodeAbiParameters$1([
             {
@@ -14025,6 +14026,7 @@ class ReadWriteFlaunchZap extends ReadFlaunchZap {
                 name: "params",
                 components: [
                     { type: "uint256", name: "creatorShare" },
+                    { type: "uint256", name: "ownerShare" },
                     {
                         type: "tuple[]",
                         name: "recipientShares",
@@ -14038,6 +14040,7 @@ class ReadWriteFlaunchZap extends ReadFlaunchZap {
         ], [
             {
                 creatorShare,
+                ownerShare: managerOwnerShare,
                 recipientShares,
             },
         ]);
@@ -25456,6 +25459,10 @@ function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
     if (sqrtRatioAX96 > sqrtRatioBX96) {
         [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
     }
+    // Handle edge case where sqrt ratios are equal (division by zero)
+    if (sqrtRatioAX96 === sqrtRatioBX96) {
+        return 0n;
+    }
     const Q96 = 2n ** 96n;
     const numerator = amount0 * sqrtRatioAX96 * sqrtRatioBX96;
     const denominator = Q96 * (sqrtRatioBX96 - sqrtRatioAX96);
@@ -25472,6 +25479,10 @@ function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
     if (sqrtRatioAX96 > sqrtRatioBX96) {
         [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
     }
+    // Handle edge case where sqrt ratios are equal (division by zero)
+    if (sqrtRatioAX96 === sqrtRatioBX96) {
+        return 0n;
+    }
     const Q96 = 2n ** 96n;
     return (amount1 * Q96) / (sqrtRatioBX96 - sqrtRatioAX96);
 }
@@ -26383,7 +26394,7 @@ class ReadFlaunchSDK {
      * @returns Promise<number> - The current tick of the pool
      */
     async currentTick(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const poolId = await this.poolId(coinAddress, coinVersion);
         const poolState = await this.readStateView.poolSlot0({ poolId });
         return poolState.tick;
@@ -26395,7 +26406,7 @@ class ReadFlaunchSDK {
      * @returns Promise<string> - The price of the coin in ETH with 18 decimals precision
      */
     async coinPriceInETH(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const isFLETHZero = this.flETHIsCurrencyZero(coinAddress);
         const currentTick = await this.currentTick(coinAddress, coinVersion);
         const price = Math.pow(1.0001, currentTick);
@@ -26415,7 +26426,7 @@ class ReadFlaunchSDK {
      * @returns Promise<string> - The price of the coin in USD with 18 decimal precision
      */
     async coinPriceInUSD({ coinAddress, version, drift, }) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const ethPerCoin = await this.coinPriceInETH(coinAddress, coinVersion);
         const ethPrice = await this.getETHUSDCPrice(drift);
         return (parseFloat(ethPerCoin) * ethPrice).toFixed(18);
@@ -26463,7 +26474,7 @@ class ReadFlaunchSDK {
      * @returns Fair launch information from the appropriate contract version
      */
     async fairLaunchInfo(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const poolId = await this.poolId(coinAddress, coinVersion);
         return this.getFairLaunch(coinVersion).fairLaunchInfo({ poolId });
     }
@@ -26474,12 +26485,12 @@ class ReadFlaunchSDK {
      * @returns Promise<boolean> - True if fair launch is active, false otherwise
      */
     async isFairLaunchActive(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const poolId = await this.poolId(coinAddress, coinVersion);
         return this.getFairLaunch(coinVersion).isFairLaunchActive({ poolId });
     }
     async trustedPoolKeySignerStatus(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         if (coinVersion === FlaunchVersion.ANY) {
             throw new Error("AnyPositionManager is not supported for TrustedSigner");
         }
@@ -26528,7 +26539,7 @@ class ReadFlaunchSDK {
      * @returns Promise<number> - The duration in seconds (30 minutes for V1, variable for V1.1)
      */
     async fairLaunchDuration(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const poolId = await this.poolId(coinAddress, coinVersion);
         return this.getFairLaunch(coinVersion).fairLaunchDuration({ poolId });
     }
@@ -26539,7 +26550,7 @@ class ReadFlaunchSDK {
      * @returns Promise<number> - The initial tick value
      */
     async initialTick(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const poolId = await this.poolId(coinAddress, coinVersion);
         const fairLaunchInfo = await this.getFairLaunch(coinVersion).fairLaunchInfo({ poolId });
         return fairLaunchInfo.initialTick;
@@ -26551,7 +26562,7 @@ class ReadFlaunchSDK {
      * @returns Promise<{flETHAmount: bigint, coinAmount: bigint, tickLower: number, tickUpper: number}> - Position details
      */
     async fairLaunchETHOnlyPosition(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const poolId = await this.poolId(coinAddress, coinVersion);
         const initialTick = await this.initialTick(coinAddress, coinVersion);
         const currentTick = await this.currentTick(coinAddress, coinVersion);
@@ -26599,7 +26610,7 @@ class ReadFlaunchSDK {
      * @returns Promise<{flETHAmount: bigint, coinAmount: bigint, tickLower: number, tickUpper: number}> - Position details
      */
     async fairLaunchCoinOnlyPosition(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const poolId = await this.poolId(coinAddress, coinVersion);
         const initialTick = await this.initialTick(coinAddress, coinVersion);
         const currentTick = await this.currentTick(coinAddress, coinVersion);
@@ -26647,7 +26658,7 @@ class ReadFlaunchSDK {
      * @returns Promise<{flETHAmount: bigint, coinAmount: bigint, pendingEth: bigint, tickLower: number, tickUpper: number}> - Bid wall position details
      */
     async bidWallPosition(coinAddress, version) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         const poolId = await this.poolId(coinAddress, coinVersion);
         const isFLETHZero = this.flETHIsCurrencyZero(coinAddress);
         const { amount0_: amount0, amount1_: amount1, pendingEth_: pendingEth, } = await this.getBidWall(coinVersion).position({ poolId });
@@ -26763,13 +26774,8 @@ class ReadFlaunchSDK {
      */
     async poolId(coinAddress, version) {
         let hookAddress;
-        if (version) {
-            hookAddress = this.getPositionManagerAddress(version);
-        }
-        else {
-            const coinVersion = await this.getCoinVersion(coinAddress);
-            hookAddress = this.getPositionManagerAddress(coinVersion);
-        }
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
+        hookAddress = this.getPositionManagerAddress(coinVersion);
         return getPoolId(orderPoolKey({
             currency0: FLETHAddress[this.chainId],
             currency1: coinAddress,
@@ -26827,7 +26833,7 @@ class ReadFlaunchSDK {
      * @returns Promise<bigint> - The expected amount of ETH to receive
      */
     async getSellQuoteExactInput({ coinAddress, version, amountIn, intermediatePoolKey, }) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         return this.readQuoter.getSellQuoteExactInput({
             coinAddress,
             amountIn,
@@ -26846,7 +26852,7 @@ class ReadFlaunchSDK {
      * @returns Promise<bigint> - The expected amount of coins to receive
      */
     async getBuyQuoteExactInput({ coinAddress, version, amountIn, intermediatePoolKey, hookData, userWallet, }) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         return this.readQuoter.getBuyQuoteExactInput({
             coinAddress,
             amountIn,
@@ -26867,7 +26873,7 @@ class ReadFlaunchSDK {
      * @returns Promise<bigint> - The required amount of ETH or inputToken to spend
      */
     async getBuyQuoteExactOutput({ coinAddress, amountOut, version, intermediatePoolKey, hookData, userWallet, }) {
-        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const coinVersion = await this.determineCoinVersion(coinAddress, version);
         return this.readQuoter.getBuyQuoteExactOutput({
             coinAddress,
             coinOut: amountOut,
@@ -27054,24 +27060,9 @@ class ReadFlaunchSDK {
         });
         // If no current tick is provided from the above calculation, get it from the pool state
         if (!currentTick) {
-            let version = params.version;
-            // if version is not provided, check on existing managers, else default to ANY
-            if (!version) {
-                try {
-                    version = await this.getCoinVersion(coinAddress);
-                }
-                catch {
-                    version = FlaunchVersion.ANY;
-                }
-            }
+            const version = await this.determineCoinVersion(coinAddress, params.version);
             const poolState = await this.readStateView.poolSlot0({
-                poolId: getPoolId(orderPoolKey({
-                    currency0: coinAddress,
-                    currency1: FLETHAddress[this.chainId],
-                    fee: 0,
-                    tickSpacing: TICK_SPACING,
-                    hooks: this.getPositionManagerAddress(version),
-                })),
+                poolId: getPoolId(this.createPoolKey(coinAddress, version)),
             });
             currentTick = poolState.tick;
         }
@@ -27145,24 +27136,9 @@ class ReadFlaunchSDK {
         });
         // get the current pool state for the coin
         if (!currentTick) {
-            let version = params.version;
-            // if version is not provided, check on existing managers, else default to ANY
-            if (!version) {
-                try {
-                    version = await this.getCoinVersion(coinAddress);
-                }
-                catch {
-                    version = FlaunchVersion.ANY;
-                }
-            }
+            const version = await this.determineCoinVersion(coinAddress, params.version);
             const poolState = await this.readStateView.poolSlot0({
-                poolId: getPoolId(orderPoolKey({
-                    currency0: coinAddress,
-                    currency1: FLETHAddress[this.chainId],
-                    fee: 0,
-                    tickSpacing: TICK_SPACING,
-                    hooks: this.getPositionManagerAddress(version),
-                })),
+                poolId: getPoolId(this.createPoolKey(coinAddress, version)),
             });
             currentTick = poolState.tick;
         }
@@ -27317,6 +27293,39 @@ class ReadFlaunchSDK {
             args: { owner, operator },
         });
     }
+    /**
+     * Determines the version for a coin, using provided version or fetching it
+     * @param coinAddress - The coin address
+     * @param version - Optional version, if not provided will be fetched
+     * @returns The determined version
+     */
+    async determineCoinVersion(coinAddress, version) {
+        if (!version) {
+            try {
+                version = await this.getCoinVersion(coinAddress);
+            }
+            catch {
+                version = FlaunchVersion.ANY;
+            }
+        }
+        return version;
+    }
+    /**
+     * Creates a pool key for the given coin and version
+     * @param coinAddress - The coin address
+     * @param version - The version to use for position manager
+     * @returns The ordered pool key
+     */
+    createPoolKey(coinAddress, version) {
+        const flethAddress = FLETHAddress[this.chainId];
+        return orderPoolKey({
+            currency0: coinAddress,
+            currency1: flethAddress,
+            fee: 0,
+            tickSpacing: this.TICK_SPACING,
+            hooks: this.getPositionManagerAddress(version),
+        });
+    }
 }
 class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
     constructor(chainId, drift = createDrift$1(), publicClient) {
@@ -27441,7 +27450,7 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
      * @returns Transaction response for the buy operation
      */
     async buyCoin(params, version) {
-        const coinVersion = version || (await this.getCoinVersion(params.coinAddress));
+        const coinVersion = await this.determineCoinVersion(params.coinAddress, version);
         const sender = await this.drift.getSignerAddress();
         let amountIn;
         let amountOutMin;
@@ -27526,7 +27535,7 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
      * @returns Transaction response for the sell operation
      */
     async sellCoin(params, version) {
-        const coinVersion = version || (await this.getCoinVersion(params.coinAddress));
+        const coinVersion = await this.determineCoinVersion(params.coinAddress, version);
         let amountOutMin;
         await this.readQuoter.contract.cache.clear();
         if (params.amountOutMin === undefined) {
@@ -27749,22 +27758,8 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         let tickLower;
         let tickUpper;
         let currentTick;
-        let version = params.version;
-        if (!version) {
-            try {
-                version = await this.getCoinVersion(coinAddress);
-            }
-            catch {
-                version = FlaunchVersion.ANY;
-            }
-        }
-        const poolKey = orderPoolKey({
-            currency0: coinAddress,
-            currency1: flethAddress,
-            fee: 0,
-            tickSpacing: this.TICK_SPACING,
-            hooks: this.getPositionManagerAddress(version),
-        });
+        const version = await this.determineCoinVersion(coinAddress, params.version);
+        const poolKey = this.createPoolKey(coinAddress, version);
         // Check if we need to calculate values or use direct values
         if ("tickLower" in params) {
             // Use the directly provided values
@@ -27962,6 +27957,173 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         // Determine amounts for each currency based on pool key ordering
         const amount0 = poolKey.currency0 === coinAddress ? coinAmount : flethAmount;
         const amount1 = poolKey.currency0 === coinAddress ? flethAmount : coinAmount;
+        // Calculate and constrain liquidity using shared method
+        const { finalLiquidity, finalAmount0, finalAmount1 } = this.calculateConstrainedLiquidity(currentTick, tickLower, tickUpper, amount0, amount1);
+        // 6. Add liquidity
+        calls.push(this.createLiquidityCall(poolKey, tickLower, tickUpper, finalLiquidity, finalAmount0, finalAmount1, userAddress));
+        return calls;
+    }
+    /**
+     * Gets the calls needed to import a memecoin to Flaunch and add liquidity to AnyPositionManager as a batch
+     * @param params - Parameters for importing and adding liquidity
+     * @returns Array of calls with descriptions
+     */
+    async getImportAndAddLiquidityCalls(params) {
+        const importParams = await this.readWriteTokenImporter.getInitializeParams({
+            coinAddress: params.coinAddress,
+            creatorFeeAllocationPercent: params.creatorFeeAllocationPercent,
+            initialMarketCapUSD: params.initialMarketCapUSD,
+            verifier: params.verifier,
+        });
+        const addLiquidityCalls = await this.getAddLiquidityCalls({
+            ...params,
+            version: FlaunchVersion.ANY, // optimize to avoid fetching if not passed
+        });
+        return [
+            {
+                to: this.readWriteTokenImporter.contract.address,
+                data: this.readWriteTokenImporter.contract.encodeFunctionData("initialize", importParams),
+                description: "Import Memecoin to Flaunch",
+            },
+            ...addLiquidityCalls,
+        ];
+    }
+    /**
+     * Gets the calls needed to add single-sided liquidity in coin from current tick to infinity
+     * @param params - Parameters for adding single-sided liquidity
+     * @returns Array of calls with descriptions
+     */
+    async getSingleSidedCoinAddLiquidityCalls(params) {
+        const { coinAddress, coinAmount } = params;
+        const version = await this.determineCoinVersion(coinAddress, params.version);
+        const poolKey = this.createPoolKey(coinAddress, version);
+        // get the current tick from the pool
+        const poolState = await this.readStateView.poolSlot0({
+            poolId: getPoolId(poolKey),
+        });
+        const currentTick = poolState.tick;
+        // We want to add liquidity from current price to infinity (as coin appreciates vs flETH)
+        // This means providing single-sided coin liquidity that becomes active as coin price increases
+        const isFLETHZero = this.flETHIsCurrencyZero(coinAddress);
+        let tickLower;
+        let tickUpper;
+        if (isFLETHZero) {
+            // flETH is currency0, coin is currency1
+            // Price = coin/flETH. As coin appreciates, price and tick increase.
+            // For single-sided coin position, we need the range to end at current tick
+            // so as price increases beyond current, position becomes coin-only
+            tickLower = TickFinder.MIN_TICK;
+            tickUpper = getValidTick({
+                tick: currentTick,
+                tickSpacing: this.TICK_SPACING,
+                roundDown: true,
+            });
+        }
+        else {
+            // coin is currency0, flETH is currency1
+            // Price = flETH/coin. As coin appreciates, price decreases and tick decreases.
+            // For single-sided coin position, we need the range to start at current tick
+            // so as price decreases below current, position becomes coin-only
+            tickLower = getValidTick({
+                tick: currentTick,
+                tickSpacing: this.TICK_SPACING,
+                roundDown: false,
+            });
+            tickUpper = TickFinder.MAX_TICK;
+        }
+        // Fetch approvals via multicall
+        const userAddress = await this.drift.getSignerAddress();
+        const permit2Address = Permit2Address[this.chainId];
+        const results = await this.drift.multicall({
+            calls: [
+                // coin -> permit2
+                {
+                    address: coinAddress,
+                    abi: erc20Abi,
+                    fn: "allowance",
+                    args: {
+                        owner: userAddress,
+                        spender: permit2Address,
+                    },
+                },
+                // coin --permit2--> uni position manager
+                {
+                    address: permit2Address,
+                    abi: Permit2Abi,
+                    fn: "allowance",
+                    args: {
+                        0: userAddress,
+                        1: coinAddress,
+                        2: UniV4PositionManagerAddress[this.chainId],
+                    },
+                },
+                // coin symbol
+                {
+                    address: coinAddress,
+                    abi: erc20Abi,
+                    fn: "symbol",
+                },
+            ],
+        });
+        const coinToPermit2 = results[0].value;
+        const permit2ToUniPosManagerCoinAllowance = results[1].value;
+        const coinSymbol = results[2].value;
+        const needsCoinApproval = coinToPermit2 < coinAmount;
+        const currentTime = Math.floor(Date.now() / 1000);
+        const needsCoinPermit2Approval = permit2ToUniPosManagerCoinAllowance.amount < coinAmount ||
+            permit2ToUniPosManagerCoinAllowance.expiration <= currentTime;
+        const calls = [];
+        // 1. Coin approval to Permit2
+        if (needsCoinApproval) {
+            calls.push({
+                to: coinAddress,
+                description: `Approve ${coinSymbol} for Permit2`,
+                data: encodeFunctionData({
+                    abi: erc20Abi,
+                    functionName: "approve",
+                    args: [permit2Address, coinAmount],
+                }),
+            });
+        }
+        // 2. Permit2 approval for coin to uni position manager
+        const expiration = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
+        if (needsCoinPermit2Approval) {
+            calls.push({
+                to: permit2Address,
+                description: `Permit2 approval for ${coinSymbol} to UniV4PositionManager`,
+                data: encodeFunctionData({
+                    abi: Permit2Abi,
+                    functionName: "approve",
+                    args: [
+                        coinAddress,
+                        UniV4PositionManagerAddress[this.chainId],
+                        coinAmount,
+                        expiration,
+                    ],
+                }),
+            });
+        }
+        // === generate add liquidity call ===
+        // Determine amounts for each currency based on pool key ordering
+        const flethAmount = 0n;
+        const amount0 = poolKey.currency0 === coinAddress ? coinAmount : flethAmount;
+        const amount1 = poolKey.currency0 === coinAddress ? flethAmount : coinAmount;
+        // Calculate and constrain liquidity using shared method
+        const { finalLiquidity, finalAmount0, finalAmount1 } = this.calculateConstrainedLiquidity(currentTick, tickLower, tickUpper, amount0, amount1);
+        // 3. Add liquidity
+        calls.push(this.createLiquidityCall(poolKey, tickLower, tickUpper, finalLiquidity, finalAmount0, finalAmount1, userAddress));
+        return calls;
+    }
+    /**
+     * Calculates and constrains liquidity amounts for a position
+     * @param currentTick - Current pool tick
+     * @param tickLower - Lower tick of the position
+     * @param tickUpper - Upper tick of the position
+     * @param amount0 - Amount of currency0
+     * @param amount1 - Amount of currency1
+     * @returns Final liquidity and amounts
+     */
+    calculateConstrainedLiquidity(currentTick, tickLower, tickUpper, amount0, amount1) {
         // Calculate liquidity first using user's input amounts
         const initialLiquidity = getLiquidityFromAmounts({
             currentTick,
@@ -28027,7 +28189,25 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         }
         finalAmount0 = amount0; // Use user's full amount as maximum
         finalAmount1 = amount1; // Use user's full amount as maximum
-        // Prepare mint position parameters (following swiss-knife pattern)
+        return {
+            finalLiquidity,
+            finalAmount0,
+            finalAmount1,
+        };
+    }
+    /**
+     * Creates the UniV4 Position Manager liquidity call
+     * @param poolKey - The pool key
+     * @param tickLower - Lower tick of the position
+     * @param tickUpper - Upper tick of the position
+     * @param finalLiquidity - Final liquidity amount
+     * @param finalAmount0 - Final amount of currency0
+     * @param finalAmount1 - Final amount of currency1
+     * @param userAddress - User's address
+     * @returns CallWithDescription for adding liquidity
+     */
+    createLiquidityCall(poolKey, tickLower, tickUpper, finalLiquidity, finalAmount0, finalAmount1, userAddress) {
+        // Prepare mint position parameters
         const V4PMActions = {
             MINT_POSITION: "02",
             SETTLE_PAIR: "0d",
@@ -28081,8 +28261,7 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
                 currency1: poolKey.currency1,
             },
         ]);
-        // 6. Add liquidity
-        calls.push({
+        return {
             to: UniV4PositionManagerAddress[this.chainId],
             data: encodeFunctionData({
                 abi: [
@@ -28108,33 +28287,7 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
             }),
             value: 0n,
             description: "Add Liquidity",
-        });
-        return calls;
-    }
-    /**
-     * Gets the calls needed to import a memecoin to Flaunch and add liquidity to AnyPositionManager as a batch
-     * @param params - Parameters for importing and adding liquidity
-     * @returns Array of calls with descriptions
-     */
-    async getImportAndAddLiquidityCalls(params) {
-        const importParams = await this.readWriteTokenImporter.getInitializeParams({
-            coinAddress: params.coinAddress,
-            creatorFeeAllocationPercent: params.creatorFeeAllocationPercent,
-            initialMarketCapUSD: params.initialMarketCapUSD,
-            verifier: params.verifier,
-        });
-        const addLiquidityCalls = await this.getAddLiquidityCalls({
-            ...params,
-            version: FlaunchVersion.ANY, // optimize to avoid fetching if not passed
-        });
-        return [
-            {
-                to: this.readWriteTokenImporter.contract.address,
-                data: this.readWriteTokenImporter.contract.encodeFunctionData("initialize", importParams),
-                description: "Import Memecoin to Flaunch",
-            },
-            ...addLiquidityCalls,
-        ];
+        };
     }
 }