@flaunch/sdk 0.8.3-beta.3 → 0.8.3-beta.4

package/dist/index.cjs.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var drift = require('@delvtech/drift');
 var viem = require('viem');
 var axios = require('axios');
-var v3Sdk = require('@uniswap/v3-sdk');
 var driftViem = require('@delvtech/drift-viem');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -5467,6 +5466,10 @@ const Permit2Address = {
     [base.id]: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
     [baseSepolia.id]: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
 };
+const UniV4PositionManagerAddress = {
+    [base.id]: "0x7C5f5A4bBd8fD63184577525326123B519429bDc",
+    [baseSepolia.id]: "0x4B2C77d209D3405F41a037Ec6c77F7F5b8e2ca80",
+};
 const USDCETHPoolKeys = {
     [base.id]: {
         currency0: viem.zeroAddress,
@@ -11208,6 +11211,11 @@ exports.Verifier = void 0;
     Verifier["WHITELIST"] = "whitelist";
     Verifier["ZORA"] = "zora";
 })(exports.Verifier || (exports.Verifier = {}));
+exports.LiquidityMode = void 0;
+(function (LiquidityMode) {
+    LiquidityMode["FULL_RANGE"] = "full-range";
+    LiquidityMode["CONCENTRATED"] = "concentrated";
+})(exports.LiquidityMode || (exports.LiquidityMode = {}));
 /**
  * Enumeration of Permissions for TreasuryManagers. Defaults to OPEN.
  */
@@ -14667,6 +14675,13 @@ class ReadMemecoin {
     tokenURI() {
         return this.contract.read("tokenURI");
     }
+    /**
+     * Gets the decimals of the token
+     * @returns Promise<number> - The decimals of the token
+     */
+    decimals() {
+        return this.contract.read("decimals");
+    }
     /**
      * Gets the total supply of the token
      * @returns Promise<bigint> - The total supply
@@ -19518,26 +19533,21 @@ class ReadWriteTokenImporter extends ReadTokenImporter {
     constructor(chainId, address, drift$1 = drift.createDrift()) {
         super(chainId, address, drift$1);
     }
-    initialize({ memecoin, creatorFeeAllocationPercent, initialMarketCapUSD, verifier, }) {
+    async initialize({ memecoin, creatorFeeAllocationPercent, initialMarketCapUSD, verifier, }) {
         const initialMCapInUSDCWei = viem.parseUnits(initialMarketCapUSD.toString(), 6);
         const creatorFeeAllocationInBps = creatorFeeAllocationPercent * 100;
-        // if the verifier is known then use that to save on gas
-        if (verifier) {
-            const verifierAddress = this.verifierAddress(verifier);
-            return this.contract.write("initialize", {
-                _memecoin: memecoin,
-                _creatorFeeAllocation: creatorFeeAllocationInBps,
-                _initialMarketCap: initialMCapInUSDCWei,
-                _verifier: verifierAddress,
-            });
-        }
-        else {
-            return this.contract.write("initialize", {
+        // Passing in the verifier here, as drift doesn't recognize the other initialize function without the verifier param
+        let _verifier = verifier
+            ? this.verifierAddress(verifier)
+            : await this.contract.read("verifyMemecoin", {
                 _memecoin: memecoin,
-                _creatorFeeAllocation: creatorFeeAllocationInBps,
-                _initialMarketCap: initialMCapInUSDCWei,
             });
-        }
+        return this.contract.write("initialize", {
+            _memecoin: memecoin,
+            _creatorFeeAllocation: creatorFeeAllocationInBps,
+            _initialMarketCap: initialMCapInUSDCWei,
+            _verifier,
+        });
     }
 }
 
@@ -24384,6 +24394,8 @@ const TickFinder = {
     MIN_TICK: -887220,
     MAX_TICK: 887220,
 };
+const Q96 = 2n ** 96n;
+const Q192 = 2n ** 192n;
 const TICK_SPACING = 60;
 const getPoolId = (poolKey) => {
     // Pack the data in the same order as Solidity struct
@@ -24406,7 +24418,7 @@ const orderPoolKey = (poolKey) => {
         currency1,
     };
 };
-const getValidTick = ({ tick, tickSpacing, roundDown, }) => {
+const getValidTick = ({ tick, tickSpacing, roundDown = true, }) => {
     // If the tick is already valid, exit early
     if (tick % tickSpacing === 0) {
         return tick;
@@ -24423,6 +24435,11 @@ const getValidTick = ({ tick, tickSpacing, roundDown, }) => {
     }
     return validTick;
 };
+// Rounds up or down to the nearest tick
+const getNearestUsableTick = ({ tick, tickSpacing, }) => {
+    const rounded = Math.round(tick / tickSpacing) * tickSpacing;
+    return Math.max(TickFinder.MIN_TICK, Math.min(TickFinder.MAX_TICK, rounded));
+};
 const getAmount0ForLiquidity = (sqrtRatioAX96, sqrtRatioBX96, liquidity) => {
     let [sqrtRatioA, sqrtRatioB] = [sqrtRatioAX96, sqrtRatioBX96];
     if (sqrtRatioA > sqrtRatioB) {
@@ -24446,7 +24463,60 @@ const getAmount1ForLiquidity = (sqrtRatioAX96, sqrtRatioBX96, liquidity) => {
     return amount1;
 };
 const getSqrtPriceX96FromTick = (tick) => {
-    return BigInt(v3Sdk.TickMath.getSqrtRatioAtTick(tick).toString());
+    const absTick = tick < 0 ? BigInt(-tick) : BigInt(tick);
+    if (absTick > TickFinder.MAX_TICK) {
+        throw new Error("Tick out of range");
+    }
+    let ratio = (absTick & 1n) !== 0n
+        ? 0xfffcb933bd6fad37aa2d162d1a594001n
+        : 0x100000000000000000000000000000000n;
+    if ((absTick & 2n) !== 0n)
+        ratio = (ratio * 0xfff97272373d413259a46990580e213an) >> 128n;
+    if ((absTick & 4n) !== 0n)
+        ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn) >> 128n;
+    if ((absTick & 8n) !== 0n)
+        ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n) >> 128n;
+    if ((absTick & 16n) !== 0n)
+        ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644n) >> 128n;
+    if ((absTick & 32n) !== 0n)
+        ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0n) >> 128n;
+    if ((absTick & 64n) !== 0n)
+        ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861n) >> 128n;
+    if ((absTick & 128n) !== 0n)
+        ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053n) >> 128n;
+    if ((absTick & 256n) !== 0n)
+        ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n) >> 128n;
+    if ((absTick & 512n) !== 0n)
+        ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54n) >> 128n;
+    if ((absTick & 1024n) !== 0n)
+        ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3n) >> 128n;
+    if ((absTick & 2048n) !== 0n)
+        ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n) >> 128n;
+    if ((absTick & 4096n) !== 0n)
+        ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n) >> 128n;
+    if ((absTick & 8192n) !== 0n)
+        ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n) >> 128n;
+    if ((absTick & 16384n) !== 0n)
+        ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7n) >> 128n;
+    if ((absTick & 32768n) !== 0n)
+        ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6n) >> 128n;
+    if ((absTick & 65536n) !== 0n)
+        ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n) >> 128n;
+    if ((absTick & 131072n) !== 0n)
+        ratio = (ratio * 0x5d6af8dedb81196699c329225ee604n) >> 128n;
+    if ((absTick & 262144n) !== 0n)
+        ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98n) >> 128n;
+    if ((absTick & 524288n) !== 0n)
+        ratio = (ratio * 0x48a170391f7dc42444e8fa2n) >> 128n;
+    if (tick > 0) {
+        ratio = (2n ** 256n - 1n) / ratio;
+    }
+    // Convert from Q128.128 to Q128.96
+    const resultShifted = ratio >> 32n;
+    if (ratio % (1n << 32n) === 0n) {
+        return resultShifted;
+    }
+    return resultShifted + 1n;
 };
 const calculateUnderlyingTokenBalances = (liquidity, tickLower, tickUpper, tickCurrent) => {
     const sqrtPriceCurrentX96 = getSqrtPriceX96FromTick(tickCurrent);
@@ -24469,6 +24539,137 @@ const calculateUnderlyingTokenBalances = (liquidity, tickLower, tickUpper, tickC
     }
     return { amount0, amount1 };
 };
+// Helper function to convert price ratio to tick with decimal handling
+const priceRatioToTick = ({ priceInput, isDirection1Per0, decimals0, decimals1, spacing, shouldGetNearestUsableTick = true, }) => {
+    if (!priceInput || isNaN(Number(priceInput)))
+        return 0;
+    const inputPrice = Number(priceInput);
+    try {
+        // For Uniswap v3/v4, the tick represents price as: price = 1.0001^tick
+        // where price = amount1/amount0 in their raw decimal format
+        let priceRatio;
+        if (isDirection1Per0) {
+            // Input is token1 per token0 (e.g., memecoin per flETH)
+            // Convert from human-readable to raw: divide by (10^decimals0 / 10^decimals1)
+            priceRatio = inputPrice / Math.pow(10, decimals0 - decimals1);
+        }
+        else {
+            // Input is token0 per token1 (e.g., flETH per memecoin)
+            // Invert to get token1 per token0, then convert to raw
+            priceRatio = 1 / inputPrice / Math.pow(10, decimals0 - decimals1);
+        }
+        // Calculate tick: tick = log(price) / log(1.0001)
+        const tick = Math.log(priceRatio) / Math.log(1.0001);
+        if (shouldGetNearestUsableTick) {
+            return getValidTick({
+                tick: Math.round(tick),
+                tickSpacing: spacing,
+            });
+        }
+        else {
+            return Math.round(tick);
+        }
+    }
+    catch (error) {
+        console.error("Error converting price to tick:", error);
+        // Fallback to basic calculation
+        const rawTick = Math.floor(Math.log(inputPrice) / Math.log(1.0001));
+        if (shouldGetNearestUsableTick) {
+            return getValidTick({
+                tick: rawTick,
+                tickSpacing: spacing,
+            });
+        }
+        else {
+            return rawTick;
+        }
+    }
+};
+/**
+ * Accurate liquidity calculation using proper Uniswap v3/v4 math
+ */
+const getLiquidityFromAmounts = (params) => {
+    const sqrtRatioCurrentX96 = getSqrtPriceX96FromTick(params.currentTick);
+    let sqrtRatioAX96 = getSqrtPriceX96FromTick(params.tickLower);
+    let sqrtRatioBX96 = getSqrtPriceX96FromTick(params.tickUpper);
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
+        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    if (sqrtRatioCurrentX96 <= sqrtRatioAX96) {
+        return maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, params.amount0);
+    }
+    else if (sqrtRatioCurrentX96 < sqrtRatioBX96) {
+        const liquidity0 = maxLiquidityForAmount0Precise(sqrtRatioCurrentX96, sqrtRatioBX96, params.amount0);
+        const liquidity1 = maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioCurrentX96, params.amount1);
+        return liquidity0 < liquidity1 ? liquidity0 : liquidity1;
+    }
+    else {
+        return maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, params.amount1);
+    }
+};
+/**
+ * Returns a precise maximum amount of liquidity received for a given amount of token 0 by dividing by Q64 instead of Q96 in the intermediate step,
+ * and shifting the subtracted ratio left by 32 bits.
+ * @param sqrtRatioAX96 The price at the lower boundary
+ * @param sqrtRatioBX96 The price at the upper boundary
+ * @param amount0 The token0 amount
+ * @returns liquidity for amount0, precise
+ */
+function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
+        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    const Q96 = 2n ** 96n;
+    const numerator = amount0 * sqrtRatioAX96 * sqrtRatioBX96;
+    const denominator = Q96 * (sqrtRatioBX96 - sqrtRatioAX96);
+    return numerator / denominator;
+}
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token1
+ * @param sqrtRatioAX96 The price at the lower tick boundary
+ * @param sqrtRatioBX96 The price at the upper tick boundary
+ * @param amount1 The token1 amount
+ * @returns liquidity for amount1
+ */
+function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
+        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    const Q96 = 2n ** 96n;
+    return (amount1 * Q96) / (sqrtRatioBX96 - sqrtRatioAX96);
+}
+/**
+ * Calculate the actual amounts needed for a given liquidity
+ * This prevents MaximumAmountExceeded errors by ensuring we provide sufficient maximums
+ */
+const getAmountsForLiquidity = (params) => {
+    // Handle zero liquidity case
+    if (params.liquidity === 0n) {
+        return { amount0: 0n, amount1: 0n };
+    }
+    const sqrtRatioCurrentX96 = getSqrtPriceX96FromTick(params.currentTick);
+    let sqrtRatioAX96 = getSqrtPriceX96FromTick(params.tickLower);
+    let sqrtRatioBX96 = getSqrtPriceX96FromTick(params.tickUpper);
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
+        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    let amount0 = 0n;
+    let amount1 = 0n;
+    if (sqrtRatioCurrentX96 <= sqrtRatioAX96) {
+        // Current price is below the range, only token0 needed
+        amount0 = getAmount0ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, params.liquidity);
+    }
+    else if (sqrtRatioCurrentX96 < sqrtRatioBX96) {
+        // Current price is within the range, need both tokens
+        amount0 = getAmount0ForLiquidity(sqrtRatioCurrentX96, sqrtRatioBX96, params.liquidity);
+        amount1 = getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioCurrentX96, params.liquidity);
+    }
+    else {
+        // Current price is above the range, only token1 needed
+        amount1 = getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, params.liquidity);
+    }
+    return { amount0, amount1 };
+};
 
 const FastFlaunchZapAbi = [
     {
@@ -24533,6 +24734,58 @@ const FastFlaunchZapAbi = [
     },
 ];
 
+const FLETHAbi = [
+    {
+        inputs: [{ internalType: "uint256", name: "wethAmount", type: "uint256" }],
+        name: "deposit",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint256", name: "amount", type: "uint256" }],
+        name: "withdraw",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "account", type: "address" }],
+        name: "balanceOf",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "totalSupply",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "name",
+        outputs: [{ internalType: "string", name: "", type: "string" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "symbol",
+        outputs: [{ internalType: "string", name: "", type: "string" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "decimals",
+        outputs: [{ internalType: "uint8", name: "", type: "uint8" }],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+
 /**
  * Base class for interacting with Flaunch protocol in read-only mode
  */
@@ -25336,6 +25589,177 @@ class ReadFlaunchSDK {
     tokenImporterVerifyMemecoin(memecoin) {
         return this.readTokenImporter.verifyMemecoin(memecoin);
     }
+    async calculateAddLiquidityTicks({ coinAddress, liquidityMode, minMarketCap, maxMarketCap, }) {
+        const memecoin = new ReadMemecoin(coinAddress, this.drift);
+        const coinTotalSupply = await memecoin.totalSupply();
+        const coinDecimals = await memecoin.decimals();
+        if (liquidityMode === exports.LiquidityMode.FULL_RANGE) {
+            return {
+                tickLower: getNearestUsableTick({
+                    tick: TickFinder.MIN_TICK,
+                    tickSpacing: TICK_SPACING,
+                }),
+                tickUpper: getNearestUsableTick({
+                    tick: TickFinder.MAX_TICK,
+                    tickSpacing: TICK_SPACING,
+                }),
+                coinTotalSupply,
+                coinDecimals,
+            };
+        }
+        else {
+            const ethUsdPrice = await this.getETHUSDCPrice();
+            const isFlethZero = this.flETHIsCurrencyZero(coinAddress);
+            const minMarketCapNum = parseFloat(minMarketCap);
+            const maxMarketCapNum = parseFloat(maxMarketCap);
+            if (minMarketCapNum <= 0 ||
+                maxMarketCapNum <= 0 ||
+                minMarketCapNum >= maxMarketCapNum) {
+                throw new Error("[ReadFlaunchSDK.addLiquidityCalculateTicks]: Invalid market cap range");
+            }
+            // Convert total supply to decimal format
+            const totalSupplyDecimal = parseFloat(viem.formatEther(coinTotalSupply));
+            // Calculate token price in USD at min and max market caps
+            const minTokenPriceUsd = minMarketCapNum / totalSupplyDecimal;
+            const maxTokenPriceUsd = maxMarketCapNum / totalSupplyDecimal;
+            // Convert to token price in ETH
+            const minTokenPriceEth = minTokenPriceUsd / ethUsdPrice;
+            const maxTokenPriceEth = maxTokenPriceUsd / ethUsdPrice;
+            const flETHDecimals = 18; // flETH has 18 decimals
+            // Determine decimals based on token ordering
+            const decimals0 = isFlethZero ? flETHDecimals : coinDecimals;
+            const decimals1 = isFlethZero ? coinDecimals : flETHDecimals;
+            // Convert to ticks using proper price direction handling
+            const minTick = priceRatioToTick({
+                priceInput: minTokenPriceEth.toString(),
+                isDirection1Per0: !isFlethZero,
+                decimals0,
+                decimals1,
+                spacing: TICK_SPACING,
+            });
+            const maxTick = priceRatioToTick({
+                priceInput: maxTokenPriceEth.toString(),
+                isDirection1Per0: !isFlethZero,
+                decimals0,
+                decimals1,
+                spacing: TICK_SPACING,
+            });
+            return {
+                tickLower: Math.min(minTick, maxTick),
+                tickUpper: Math.max(minTick, maxTick),
+                coinTotalSupply,
+                coinDecimals,
+            };
+        }
+    }
+    async calculateAddLiquidityAmounts({ coinAddress, liquidityMode, coinOrEthInputAmount, inputToken, minMarketCap, maxMarketCap, }) {
+        const { tickLower, tickUpper } = await this.calculateAddLiquidityTicks({
+            coinAddress,
+            liquidityMode,
+            minMarketCap,
+            maxMarketCap,
+        });
+        // get the current pool state for AnyPositionManager pool for the coin
+        const poolState = await this.readStateView.poolSlot0({
+            poolId: getPoolId(orderPoolKey({
+                currency0: coinAddress,
+                currency1: FLETHAddress[this.chainId],
+                fee: 0,
+                tickSpacing: TICK_SPACING,
+                hooks: AnyPositionManagerAddress[this.chainId],
+            })),
+        });
+        const currentTick = poolState.tick;
+        // Determine currency ordering
+        const isFlETHCurrency0 = this.flETHIsCurrencyZero(coinAddress);
+        try {
+            const sqrtRatioCurrentX96 = getSqrtPriceX96FromTick(currentTick);
+            let sqrtRatioLowerX96 = getSqrtPriceX96FromTick(tickLower);
+            let sqrtRatioUpperX96 = getSqrtPriceX96FromTick(tickUpper);
+            if (sqrtRatioLowerX96 > sqrtRatioUpperX96) {
+                [sqrtRatioLowerX96, sqrtRatioUpperX96] = [
+                    sqrtRatioUpperX96,
+                    sqrtRatioLowerX96,
+                ];
+            }
+            let amount0Calculated;
+            let amount1Calculated;
+            // Determine which calculation to use based on input token and currency ordering
+            const isCoinInput = inputToken === "coin";
+            const inputAmount = coinOrEthInputAmount;
+            if ((isCoinInput && !isFlETHCurrency0) || // coin input and coin is currency0
+                (!isCoinInput && isFlETHCurrency0) // eth input and flETH is currency0
+            ) {
+                // We have amount0 and need to calculate amount1
+                amount0Calculated = inputAmount;
+                if (sqrtRatioCurrentX96 <= sqrtRatioLowerX96) {
+                    // Current price below range - no currency1 needed
+                    amount1Calculated = 0n;
+                }
+                else if (sqrtRatioCurrentX96 >= sqrtRatioUpperX96) {
+                    // Current price above range - proportional amount1 needed
+                    const ratio = (sqrtRatioUpperX96 * sqrtRatioUpperX96) / Q96;
+                    amount1Calculated = (inputAmount * ratio) / Q96;
+                }
+                else {
+                    // Current price in range - proportional amounts
+                    const intermediate1 = (sqrtRatioUpperX96 *
+                        sqrtRatioCurrentX96 *
+                        (sqrtRatioCurrentX96 - sqrtRatioLowerX96)) /
+                        Q96;
+                    const intermediate2 = (Q192 * (sqrtRatioUpperX96 - sqrtRatioCurrentX96)) / Q96;
+                    if (intermediate2 > 0n) {
+                        amount1Calculated = (inputAmount * intermediate1) / intermediate2;
+                    }
+                    else {
+                        amount1Calculated = 0n;
+                    }
+                }
+            }
+            else {
+                // We have amount1 and need to calculate amount0
+                amount1Calculated = inputAmount;
+                if (sqrtRatioCurrentX96 <= sqrtRatioLowerX96) {
+                    // Current price below range - proportional amount0 needed
+                    const ratio = (sqrtRatioLowerX96 * sqrtRatioLowerX96) / Q96;
+                    amount0Calculated = (inputAmount * Q96) / ratio;
+                }
+                else if (sqrtRatioCurrentX96 >= sqrtRatioUpperX96) {
+                    // Current price above range - no amount0 needed
+                    amount0Calculated = 0n;
+                }
+                else {
+                    // Current price in range - proportional amounts
+                    const intermediate1 = (sqrtRatioUpperX96 *
+                        sqrtRatioCurrentX96 *
+                        (sqrtRatioCurrentX96 - sqrtRatioLowerX96)) /
+                        Q96;
+                    const intermediate2 = (Q192 * (sqrtRatioUpperX96 - sqrtRatioCurrentX96)) / Q96;
+                    if (intermediate1 > 0n) {
+                        amount0Calculated = (inputAmount * intermediate2) / intermediate1;
+                    }
+                    else {
+                        amount0Calculated = 0n;
+                    }
+                }
+            }
+            // Map amount0/amount1 back to coin/eth amounts based on currency ordering
+            const [ethAmount, coinAmount] = isFlETHCurrency0
+                ? [amount0Calculated, amount1Calculated]
+                : [amount1Calculated, amount0Calculated];
+            return {
+                coinAmount,
+                ethAmount,
+                tickLower,
+                tickUpper,
+                currentTick,
+            };
+        }
+        catch (error) {
+            console.error("Error calculating liquidity amounts:", error);
+            throw error;
+        }
+    }
     /**
      * Checks if an operator is approved for all flaunch tokens of an owner
      * @param version - The flaunch version to determine the correct contract address
@@ -25715,6 +26139,343 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
     importMemecoin(params) {
         return this.readWriteTokenImporter.initialize(params);
     }
+    async getAddLiquidityCalls(params) {
+        const { coinAddress } = params;
+        const flethAddress = FLETHAddress[this.chainId];
+        let coinAmount;
+        let flethAmount;
+        let tickLower;
+        let tickUpper;
+        let currentTick;
+        const poolKey = orderPoolKey({
+            currency0: coinAddress,
+            currency1: flethAddress,
+            fee: 0,
+            tickSpacing: this.TICK_SPACING,
+            hooks: AnyPositionManagerAddress[this.chainId],
+        });
+        // Check if we need to calculate values or use direct values
+        if ("tickLower" in params) {
+            // Use the directly provided values
+            coinAmount = params.coinAmount;
+            flethAmount = params.flethAmount;
+            tickLower = params.tickLower;
+            tickUpper = params.tickUpper;
+            const poolState = await this.readStateView.poolSlot0({
+                poolId: getPoolId(poolKey),
+            });
+            currentTick = poolState.tick;
+        }
+        else {
+            // Calculate the amounts
+            const calculated = await this.calculateAddLiquidityAmounts({
+                coinAddress,
+                liquidityMode: params.liquidityMode,
+                coinOrEthInputAmount: params.coinOrEthInputAmount,
+                inputToken: params.inputToken,
+                minMarketCap: params.minMarketCap,
+                maxMarketCap: params.maxMarketCap,
+            });
+            coinAmount = calculated.coinAmount;
+            flethAmount = calculated.ethAmount;
+            tickLower = calculated.tickLower;
+            tickUpper = calculated.tickUpper;
+            currentTick = calculated.currentTick;
+        }
+        // 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,
+                    },
+                },
+                // flETH -> permit2
+                {
+                    address: flethAddress,
+                    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],
+                    },
+                },
+                // flETH --permit2--> uni position manager
+                {
+                    address: permit2Address,
+                    abi: Permit2Abi,
+                    fn: "allowance",
+                    args: {
+                        0: userAddress,
+                        1: flethAddress,
+                        2: UniV4PositionManagerAddress[this.chainId],
+                    },
+                },
+                // coin symbol
+                {
+                    address: coinAddress,
+                    abi: viem.erc20Abi,
+                    fn: "symbol",
+                },
+            ],
+        });
+        const coinToPermit2 = results[0].value;
+        const flethToPermit2 = results[1].value;
+        const permit2ToUniPosManagerCoinAllowance = results[2].value;
+        const permit2ToUniPosManagerFlethAllowance = results[3].value;
+        const coinSymbol = results[4].value;
+        const needsCoinApproval = coinToPermit2 < coinAmount;
+        const needsFlethApproval = flethToPermit2 < flethAmount;
+        const currentTime = Math.floor(Date.now() / 1000);
+        const needsCoinPermit2Approval = permit2ToUniPosManagerCoinAllowance.amount < coinAmount ||
+            permit2ToUniPosManagerCoinAllowance.expiration <= currentTime;
+        const needsFlethPermit2Approval = flethAmount > 0n &&
+            (permit2ToUniPosManagerFlethAllowance.amount < flethAmount ||
+                permit2ToUniPosManagerFlethAllowance.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. flETH approval to Permit2 (after wrapping)
+        if (needsFlethApproval) {
+            calls.push({
+                to: flethAddress,
+                description: `Approve flETH for Permit2`,
+                data: viem.encodeFunctionData({
+                    abi: viem.erc20Abi,
+                    functionName: "approve",
+                    args: [permit2Address, flethAmount],
+                }),
+            });
+        }
+        // 3. 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,
+                    ],
+                }),
+            });
+        }
+        // 4. Permit2 approval for flETH to uni position manager
+        if (needsFlethPermit2Approval) {
+            calls.push({
+                to: permit2Address,
+                description: `Permit2 approval for flETH to UniV4PositionManager`,
+                data: viem.encodeFunctionData({
+                    abi: Permit2Abi,
+                    functionName: "approve",
+                    args: [
+                        flethAddress,
+                        UniV4PositionManagerAddress[this.chainId],
+                        flethAmount,
+                        expiration,
+                    ],
+                }),
+            });
+        }
+        // 5. Wrap ETH to flETH
+        if (flethAmount > 0n) {
+            calls.push({
+                to: flethAddress,
+                description: "Wrap ETH to flETH",
+                data: viem.encodeFunctionData({
+                    abi: FLETHAbi,
+                    functionName: "deposit",
+                    args: [0n], // wethAmount = 0, we're only sending ETH
+                }),
+                value: flethAmount,
+            });
+        }
+        // === generate add liquidity call ===
+        // 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 liquidity first using user's input amounts
+        const initialLiquidity = getLiquidityFromAmounts({
+            currentTick,
+            tickLower,
+            tickUpper,
+            amount0,
+            amount1,
+        });
+        // Calculate the actual amounts needed for this liquidity
+        const actualAmounts = getAmountsForLiquidity({
+            currentTick,
+            tickLower,
+            tickUpper,
+            liquidity: initialLiquidity,
+        });
+        // Check if actual amounts exceed user input - if so, constrain them
+        let finalLiquidity = initialLiquidity;
+        let finalAmount0 = actualAmounts.amount0;
+        let finalAmount1 = actualAmounts.amount1;
+        // If actual amounts exceed user input, we need to recalculate with constraints
+        if (actualAmounts.amount0 > amount0 || actualAmounts.amount1 > amount1) {
+            console.log("Actual amounts exceed user input, constraining...");
+            // Calculate liquidity constrained by each amount separately
+            const liquidity0Constrained = getLiquidityFromAmounts({
+                currentTick,
+                tickLower,
+                tickUpper,
+                amount0,
+                amount1: 0n, // Only constrain by amount0
+            });
+            const liquidity1Constrained = getLiquidityFromAmounts({
+                currentTick,
+                tickLower,
+                tickUpper,
+                amount0: 0n, // Only constrain by amount1
+                amount1,
+            });
+            // Use the smaller liquidity to ensure we don't exceed either amount
+            finalLiquidity =
+                liquidity0Constrained < liquidity1Constrained
+                    ? liquidity0Constrained
+                    : liquidity1Constrained;
+            // Recalculate amounts for the constrained liquidity
+            const constrainedAmounts = getAmountsForLiquidity({
+                currentTick,
+                tickLower,
+                tickUpper,
+                liquidity: finalLiquidity,
+            });
+            finalAmount0 = constrainedAmounts.amount0;
+            finalAmount1 = constrainedAmounts.amount1;
+        }
+        // IMPORTANT: Add conservative buffer to account for contract rounding differences
+        // Reduce liquidity by 0.01% to ensure contract calculations stay within user bounds
+        const liquidityBuffer = finalLiquidity / 10000n; // 0.01%
+        const conservativeLiquidity = finalLiquidity - (liquidityBuffer > 1n ? liquidityBuffer : 1n);
+        // Use conservative liquidity but keep user's original amounts as maximums
+        // The conservative liquidity ensures the contract won't need more than user provided
+        if (currentTick !== undefined) {
+            // If pool is already initialized then use conservative liquidity
+            // as a new pool would accept any liquidity amounts given by us
+            finalLiquidity = conservativeLiquidity;
+        }
+        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)
+        const V4PMActions = {
+            MINT_POSITION: "02",
+            SETTLE_PAIR: "0d",
+        };
+        const v4Actions = ("0x" +
+            V4PMActions.MINT_POSITION +
+            V4PMActions.SETTLE_PAIR);
+        // Validate hookData format
+        const validHookData = "0x"; // Empty hook data for now
+        const UniV4PM_MintPositionAbi = [
+            {
+                type: "tuple",
+                components: [
+                    { type: "address", name: "currency0" },
+                    { type: "address", name: "currency1" },
+                    { type: "uint24", name: "fee" },
+                    { type: "int24", name: "tickSpacing" },
+                    { type: "address", name: "hooks" },
+                ],
+            },
+            { type: "int24", name: "tickLower" },
+            { type: "int24", name: "tickUpper" },
+            { type: "uint256", name: "liquidity" },
+            { type: "uint128", name: "amount0Max" },
+            { type: "uint128", name: "amount1Max" },
+            { type: "address", name: "owner" },
+            { type: "bytes", name: "hookData" },
+        ];
+        const UniV4PM_SettlePairAbi = [
+            {
+                type: "tuple",
+                components: [
+                    { type: "address", name: "currency0" },
+                    { type: "address", name: "currency1" },
+                ],
+            },
+        ];
+        const mintPositionParams = viem.encodeAbiParameters(UniV4PM_MintPositionAbi, [
+            poolKey,
+            tickLower,
+            tickUpper,
+            finalLiquidity,
+            finalAmount0,
+            finalAmount1,
+            userAddress,
+            validHookData,
+        ]);
+        const settlePairParams = viem.encodeAbiParameters(UniV4PM_SettlePairAbi, [
+            {
+                currency0: poolKey.currency0,
+                currency1: poolKey.currency1,
+            },
+        ]);
+        // 6. Add liquidity
+        calls.push({
+            to: UniV4PositionManagerAddress[this.chainId],
+            data: viem.encodeFunctionData({
+                abi: [
+                    {
+                        inputs: [
+                            { internalType: "bytes", name: "unlockData", type: "bytes" },
+                            { internalType: "uint256", name: "deadline", type: "uint256" },
+                        ],
+                        name: "modifyLiquidities",
+                        outputs: [],
+                        stateMutability: "payable",
+                        type: "function",
+                    },
+                ],
+                functionName: "modifyLiquidities",
+                args: [
+                    viem.encodeAbiParameters([
+                        { type: "bytes", name: "actions" },
+                        { type: "bytes[]", name: "params" },
+                    ], [v4Actions, [mintPositionParams, settlePairParams]]),
+                    BigInt(Math.floor(Date.now() / 1000) + 3600), // 1 hour deadline
+                ],
+            }),
+            value: 0n,
+            description: "Add Liquidity",
+        });
+        return calls;
+    }
 }
 
 /**
@@ -25804,6 +26565,8 @@ exports.Permit2Abi = Permit2Abi;
 exports.Permit2Address = Permit2Address;
 exports.PoolManagerAbi = PoolManagerAbi;
 exports.PoolManagerAddress = PoolManagerAddress;
+exports.Q192 = Q192;
+exports.Q96 = Q96;
 exports.QuoterAbi = QuoterAbi;
 exports.QuoterAddress = QuoterAddress;
 exports.ReadFlaunchSDK = ReadFlaunchSDK;
@@ -25821,6 +26584,7 @@ exports.TokenImporterAddress = TokenImporterAddress;
 exports.TreasuryManagerFactoryAbi = TreasuryManagerFactoryAbi;
 exports.TreasuryManagerFactoryAddress = TreasuryManagerFactoryAddress;
 exports.USDCETHPoolKeys = USDCETHPoolKeys;
+exports.UniV4PositionManagerAddress = UniV4PositionManagerAddress;
 exports.UniversalRouterAbi = UniversalRouterAbi;
 exports.UniversalRouterAddress = UniversalRouterAddress;
 exports.VirtualsVerifierAddress = VirtualsVerifierAddress;
@@ -25835,14 +26599,20 @@ exports.createFlaunch = createFlaunch;
 exports.ethToMemecoin = ethToMemecoin;
 exports.generateTokenUri = generateTokenUri;
 exports.getAmountWithSlippage = getAmountWithSlippage;
+exports.getAmountsForLiquidity = getAmountsForLiquidity;
+exports.getLiquidityFromAmounts = getLiquidityFromAmounts;
+exports.getNearestUsableTick = getNearestUsableTick;
 exports.getPermissionsAddress = getPermissionsAddress;
 exports.getPermit2TypedData = getPermit2TypedData;
 exports.getPoolId = getPoolId;
 exports.getSqrtPriceX96FromTick = getSqrtPriceX96FromTick;
 exports.getValidTick = getValidTick;
+exports.maxLiquidityForAmount0Precise = maxLiquidityForAmount0Precise;
+exports.maxLiquidityForAmount1 = maxLiquidityForAmount1;
 exports.memecoinToEthWithPermit2 = memecoinToEthWithPermit2;
 exports.orderPoolKey = orderPoolKey;
 exports.parseSwapData = parseSwapData;
+exports.priceRatioToTick = priceRatioToTick;
 exports.resolveIPFS = resolveIPFS;
 exports.uint256ToBytes32 = uint256ToBytes32;
 exports.uploadFileToIPFS = uploadFileToIPFS;