@flaunch/sdk 0.9.6 → 0.9.8

package/dist/index.cjs.js

@@ -25467,6 +25467,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);
@@ -25483,6 +25487,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);
 }
@@ -26394,7 +26402,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;
@@ -26406,7 +26414,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);
@@ -26426,7 +26434,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);
@@ -26474,7 +26482,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 });
     }
@@ -26485,12 +26493,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 === exports.FlaunchVersion.ANY) {
             throw new Error("AnyPositionManager is not supported for TrustedSigner");
         }
@@ -26539,7 +26547,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 });
     }
@@ -26550,7 +26558,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;
@@ -26562,7 +26570,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);
@@ -26610,7 +26618,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);
@@ -26658,7 +26666,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 });
@@ -26774,13 +26782,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,
@@ -26838,7 +26841,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,
@@ -26857,7 +26860,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,
@@ -26878,7 +26881,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,
@@ -26936,7 +26939,8 @@ class ReadFlaunchSDK {
             memecoin.totalSupply(),
             memecoin.decimals(),
         ]);
-        return { totalSupply, decimals };
+        const formattedTotalSupplyInDecimals = parseFloat(viem.formatUnits(totalSupply, decimals));
+        return { totalSupply, decimals, formattedTotalSupplyInDecimals };
     }
     /**
      * Gets market context information needed for tick calculations
@@ -26958,8 +26962,8 @@ class ReadFlaunchSDK {
     /**
      * Converts market cap in USD to token price in ETH
      */
-    marketCapToTokenPriceEth(marketCapUsd, totalSupplyDecimal, ethUsdPrice) {
-        const tokenPriceUsd = marketCapUsd / totalSupplyDecimal;
+    marketCapToTokenPriceEth(marketCapUsd, formattedTotalSupplyInDecimals, ethUsdPrice) {
+        const tokenPriceUsd = marketCapUsd / formattedTotalSupplyInDecimals;
         return tokenPriceUsd / ethUsdPrice;
     }
     /**
@@ -26977,24 +26981,22 @@ class ReadFlaunchSDK {
     /**
      * Calculates current tick from market cap if provided
      */
-    calculateCurrentTickFromMarketCap(currentMarketCap, totalSupplyDecimal, marketContext) {
+    calculateCurrentTickFromMarketCap(currentMarketCap, formattedTotalSupplyInDecimals, marketContext) {
         if (!currentMarketCap) {
             return undefined;
         }
         const currentMarketCapNum = parseFloat(currentMarketCap);
-        const currentTokenPriceEth = this.marketCapToTokenPriceEth(currentMarketCapNum, totalSupplyDecimal, marketContext.ethUsdPrice);
+        const currentTokenPriceEth = this.marketCapToTokenPriceEth(currentMarketCapNum, formattedTotalSupplyInDecimals, marketContext.ethUsdPrice);
         return this.convertPriceToTick(currentTokenPriceEth, marketContext.isFlethZero, marketContext.decimals0, marketContext.decimals1);
     }
     async calculateAddLiquidityTicks({ coinAddress, liquidityMode, minMarketCap, maxMarketCap, currentMarketCap, }) {
         // Get coin information
-        const { totalSupply: coinTotalSupply, decimals: coinDecimals } = await this.getCoinInfo(coinAddress);
-        // Convert total supply to decimal format
-        const totalSupplyDecimal = parseFloat(viem.formatEther(coinTotalSupply));
+        const { totalSupply: coinTotalSupply, decimals: coinDecimals, formattedTotalSupplyInDecimals, } = await this.getCoinInfo(coinAddress);
         if (liquidityMode === exports.LiquidityMode.FULL_RANGE) {
             let currentTick;
             if (currentMarketCap) {
                 const marketContext = await this.getMarketContext(coinAddress, coinDecimals);
-                currentTick = this.calculateCurrentTickFromMarketCap(currentMarketCap, totalSupplyDecimal, marketContext);
+                currentTick = this.calculateCurrentTickFromMarketCap(currentMarketCap, formattedTotalSupplyInDecimals, marketContext);
             }
             return {
                 tickLower: getNearestUsableTick({
@@ -27021,13 +27023,13 @@ class ReadFlaunchSDK {
                 throw new Error("[ReadFlaunchSDK.addLiquidityCalculateTicks]: Invalid market cap range");
             }
             // Convert market caps to token prices in ETH
-            const minTokenPriceEth = this.marketCapToTokenPriceEth(minMarketCapNum, totalSupplyDecimal, marketContext.ethUsdPrice);
-            const maxTokenPriceEth = this.marketCapToTokenPriceEth(maxMarketCapNum, totalSupplyDecimal, marketContext.ethUsdPrice);
+            const minTokenPriceEth = this.marketCapToTokenPriceEth(minMarketCapNum, formattedTotalSupplyInDecimals, marketContext.ethUsdPrice);
+            const maxTokenPriceEth = this.marketCapToTokenPriceEth(maxMarketCapNum, formattedTotalSupplyInDecimals, marketContext.ethUsdPrice);
             // Convert to ticks
             const minTick = this.convertPriceToTick(minTokenPriceEth, marketContext.isFlethZero, marketContext.decimals0, marketContext.decimals1);
             const maxTick = this.convertPriceToTick(maxTokenPriceEth, marketContext.isFlethZero, marketContext.decimals0, marketContext.decimals1);
             // Calculate current tick if provided
-            const currentTick = this.calculateCurrentTickFromMarketCap(currentMarketCap, totalSupplyDecimal, marketContext);
+            const currentTick = this.calculateCurrentTickFromMarketCap(currentMarketCap, formattedTotalSupplyInDecimals, marketContext);
             return {
                 tickLower: Math.min(minTick, maxTick),
                 tickUpper: Math.max(minTick, maxTick),
@@ -27048,12 +27050,11 @@ class ReadFlaunchSDK {
             currentMarketCap = params.currentMarketCap;
         }
         else {
-            const { totalSupply, decimals } = await this.getCoinInfo(coinAddress);
-            const formattedTotalSupply = parseFloat(viem.formatUnits(totalSupply, decimals));
-            minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupply).toString();
-            maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupply).toString();
+            const { formattedTotalSupplyInDecimals } = await this.getCoinInfo(coinAddress);
+            minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupplyInDecimals).toString();
+            maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupplyInDecimals).toString();
             if (params.currentPriceUSD) {
-                currentMarketCap = (params.currentPriceUSD * formattedTotalSupply).toString();
+                currentMarketCap = (params.currentPriceUSD * formattedTotalSupplyInDecimals).toString();
             }
         }
         let { tickLower, tickUpper, currentTick } = await this.calculateAddLiquidityTicks({
@@ -27065,24 +27066,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 = exports.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;
         }
@@ -27139,12 +27125,11 @@ class ReadFlaunchSDK {
             currentMarketCap = params.currentMarketCap;
         }
         else {
-            const { totalSupply, decimals } = await this.getCoinInfo(coinAddress);
-            const formattedTotalSupply = parseFloat(viem.formatUnits(totalSupply, decimals));
-            minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupply).toString();
-            maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupply).toString();
+            const { formattedTotalSupplyInDecimals } = await this.getCoinInfo(coinAddress);
+            minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupplyInDecimals).toString();
+            maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupplyInDecimals).toString();
             if (params.currentPriceUSD) {
-                currentMarketCap = (params.currentPriceUSD * formattedTotalSupply).toString();
+                currentMarketCap = (params.currentPriceUSD * formattedTotalSupplyInDecimals).toString();
             }
         }
         let { tickLower, tickUpper, currentTick } = await this.calculateAddLiquidityTicks({
@@ -27156,24 +27141,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 = exports.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;
         }
@@ -27328,6 +27298,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 = exports.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$1 = drift.createDrift(), publicClient) {
@@ -27452,7 +27455,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;
@@ -27537,7 +27540,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) {
@@ -27760,22 +27763,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 = exports.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
@@ -27804,12 +27793,12 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
                 initialMarketCapUSD = params.initialMarketCapUSD;
             }
             else {
-                const { totalSupply, decimals } = await this.getCoinInfo(coinAddress);
-                const formattedTotalSupply = parseFloat(viem.formatUnits(totalSupply, decimals));
-                minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupply).toString();
-                maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupply).toString();
+                const { formattedTotalSupplyInDecimals } = await this.getCoinInfo(coinAddress);
+                minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupplyInDecimals).toString();
+                maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupplyInDecimals).toString();
                 if (params.initialPriceUSD) {
-                    initialMarketCapUSD = params.initialPriceUSD * formattedTotalSupply;
+                    initialMarketCapUSD =
+                        params.initialPriceUSD * formattedTotalSupplyInDecimals;
                 }
             }
             const calculated = await this.calculateAddLiquidityAmounts({
@@ -27973,6 +27962,246 @@ 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;
+    }
+    // Implementation with union type for internal use
+    async getImportAndAddLiquidityCalls(params) {
+        let importParams;
+        if ("initialMarketCapUSD" in params) {
+            const paramsWithMarketCap = params;
+            importParams = await this.readWriteTokenImporter.getInitializeParams({
+                coinAddress: paramsWithMarketCap.coinAddress,
+                creatorFeeAllocationPercent: paramsWithMarketCap.creatorFeeAllocationPercent,
+                initialMarketCapUSD: paramsWithMarketCap.initialMarketCapUSD,
+                verifier: paramsWithMarketCap.verifier,
+            });
+        }
+        else {
+            const paramsWithPrice = params;
+            importParams = await this.readWriteTokenImporter.getInitializeParams({
+                coinAddress: paramsWithPrice.coinAddress,
+                creatorFeeAllocationPercent: paramsWithPrice.creatorFeeAllocationPercent,
+                initialPriceUSD: paramsWithPrice.initialPriceUSD,
+                verifier: paramsWithPrice.verifier,
+            });
+        }
+        const addLiquidityCalls = await this.getAddLiquidityCalls({
+            ...params,
+            version: exports.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);
+        let currentTick;
+        // if initial marketcap or price is provided, it means that the pool is not initialized yet
+        // so determining the currentTick
+        if (("initialMarketCapUSD" in params && params.initialMarketCapUSD) ||
+            ("initialPriceUSD" in params && params.initialPriceUSD)) {
+            const { decimals: coinDecimals, formattedTotalSupplyInDecimals } = await this.getCoinInfo(coinAddress);
+            // Determine market cap based on provided parameter
+            let initialMarketCapUSD;
+            if ("initialMarketCapUSD" in params && params.initialMarketCapUSD) {
+                initialMarketCapUSD = params.initialMarketCapUSD;
+            }
+            else if ("initialPriceUSD" in params && params.initialPriceUSD) {
+                initialMarketCapUSD =
+                    params.initialPriceUSD * formattedTotalSupplyInDecimals;
+            }
+            else {
+                throw new Error("Either initialMarketCapUSD or initialPriceUSD must be provided");
+            }
+            const marketContext = await this.getMarketContext(coinAddress, coinDecimals);
+            const calculatedTick = this.calculateCurrentTickFromMarketCap(initialMarketCapUSD.toString(), formattedTotalSupplyInDecimals, marketContext);
+            if (calculatedTick === undefined) {
+                throw new Error("Failed to calculate current tick from market cap");
+            }
+            currentTick = calculatedTick;
+        }
+        else {
+            // the pool is already initialized, get the current tick from the pool
+            const poolState = await this.readStateView.poolSlot0({
+                poolId: getPoolId(poolKey),
+            });
+            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: viem.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: viem.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: viem.encodeFunctionData({
+                    abi: viem.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: viem.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;
+    }
+    // Implementation with union type for internal use
+    async getImportAndSingleSidedCoinAddLiquidityCalls(params) {
+        let importParams;
+        if ("initialMarketCapUSD" in params) {
+            const paramsWithMarketCap = params;
+            importParams = await this.readWriteTokenImporter.getInitializeParams({
+                coinAddress: paramsWithMarketCap.coinAddress,
+                creatorFeeAllocationPercent: paramsWithMarketCap.creatorFeeAllocationPercent,
+                initialMarketCapUSD: paramsWithMarketCap.initialMarketCapUSD,
+                verifier: paramsWithMarketCap.verifier,
+            });
+        }
+        else {
+            const paramsWithPrice = params;
+            importParams = await this.readWriteTokenImporter.getInitializeParams({
+                coinAddress: paramsWithPrice.coinAddress,
+                creatorFeeAllocationPercent: paramsWithPrice.creatorFeeAllocationPercent,
+                initialPriceUSD: paramsWithPrice.initialPriceUSD,
+                verifier: paramsWithPrice.verifier,
+            });
+        }
+        const addLiquidityCalls = await this.getSingleSidedCoinAddLiquidityCalls({
+            ...params,
+            version: exports.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,
+        ];
+    }
+    /**
+     * === Private helper functions ===
+     */
+    /**
+     * 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,
@@ -28038,7 +28267,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",
@@ -28092,8 +28339,7 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
                 currency1: poolKey.currency1,
             },
         ]);
-        // 6. Add liquidity
-        calls.push({
+        return {
             to: UniV4PositionManagerAddress[this.chainId],
             data: viem.encodeFunctionData({
                 abi: [
@@ -28119,33 +28365,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: exports.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,
-        ];
+        };
     }
 }