@flaunch/sdk 0.9.8 → 0.9.10

package/dist/index.cjs.js

@@ -5761,6 +5761,10 @@ const StakingManagerAddress = {
     [base.id]: "0xec0069F8DBbbC94058dc895000dd38ef40b3125d",
     [baseSepolia.id]: "0xB8f1cb6B4Ff8f07149276bbfA617aed7bd32d20D",
 };
+const BuyBackManagerAddress = {
+    [base.id]: "0x3AAF3b1D8cD5b61C77f99bA7cdf41E9eC0Ba8a3f",
+    [baseSepolia.id]: "0xc3947EC9d687053bBA72b36Fd6b2567e775E82C7",
+};
 /** Verifiers */
 const TokenImporterAddress = {
     [base.id]: "0xb47af90ae61bc916ea4b4bacffae4570e7435842",
@@ -13777,195 +13781,485 @@ class ReadWriteFlaunchPositionManagerV1_1 extends ReadFlaunchPositionManagerV1_1
     }
 }
 
-/**
- * Base client for interacting with the FlaunchZap contract in read-only mode
- * Provides basic contract initialization
- */
-class ReadFlaunchZap {
-    /**
-     * Creates a new ReadFlaunchZap instance
-     * @param chainId - The chain ID of the contract
-     * @param address - The address of the FlaunchZap contract
-     * @param drift - Optional drift instance for contract interactions (creates new instance if not provided)
-     * @throws Error if address is not provided
-     */
-    constructor(chainId, address, drift$1 = drift.createDrift()) {
-        this.TOTAL_SUPPLY = 100n * 10n ** 27n; // 100 Billion tokens in wei
-        this.chainId = chainId;
-        this.drift = drift$1;
-        if (!address) {
-            throw new Error("Address is required");
-        }
-        this.contract = drift$1.contract({
-            abi: FlaunchZapAbi,
-            address,
-        });
-        this.readPositionManagerV1_1 = new ReadFlaunchPositionManagerV1_1(FlaunchPositionManagerV1_1Address[this.chainId], drift$1);
-    }
-    async getPremineCostInWei(params) {
-        const mcapInWei = await this.readPositionManagerV1_1.getFlaunchingMarketCap(params.initialPriceParams);
-        const premineCostInWei = (mcapInWei * params.premineAmount) / this.TOTAL_SUPPLY;
-        // increase the premine cost by the slippage percent
-        const premineCostInWeiWithSlippage = getAmountWithSlippage({
-            amount: premineCostInWei,
-            slippage: (params.slippagePercent ?? 0 / 100).toFixed(18).toString(),
-            swapType: "EXACT_OUT", // as we know the output premine amount
-        });
-        return premineCostInWeiWithSlippage;
+// our min/max tick range that is valid for the tick spacing (60)
+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
+    const packed = viem.concat([
+        viem.pad(poolKey.currency0, { size: 32 }), // address padded to 32 bytes
+        viem.pad(poolKey.currency1, { size: 32 }), // address padded to 32 bytes
+        viem.pad(viem.toHex(poolKey.fee), { size: 32 }), // uint24 padded to 32 bytes
+        viem.pad(viem.toHex(poolKey.tickSpacing), { size: 32 }), // int24 padded to 32 bytes
+        viem.pad(poolKey.hooks, { size: 32 }), // address padded to 32 bytes
+    ]);
+    return viem.keccak256(packed);
+};
+const orderPoolKey = (poolKey) => {
+    const [currency0, currency1] = poolKey.currency0 < poolKey.currency1
+        ? [poolKey.currency0, poolKey.currency1]
+        : [poolKey.currency1, poolKey.currency0];
+    return {
+        ...poolKey,
+        currency0,
+        currency1,
+    };
+};
+const getValidTick = ({ tick, tickSpacing, roundDown = true, }) => {
+    // If the tick is already valid, exit early
+    if (tick % tickSpacing === 0) {
+        return tick;
     }
-    async getFlaunchingFee(params) {
-        const readInitialPrice = new ReadInitialPrice(await this.readPositionManagerV1_1.initialPrice(), this.drift);
-        const flaunchingFee = await readInitialPrice.getFlaunchingFee(params);
-        // increase the flaunching fee by the slippage percent
-        const flaunchingFeeWithSlippage = getAmountWithSlippage({
-            amount: flaunchingFee,
-            slippage: (params.slippagePercent ?? 0 / 100).toFixed(18).toString(),
-            swapType: "EXACT_OUT",
-        });
-        return flaunchingFeeWithSlippage;
+    // Division that rounds towards zero (like Solidity)
+    let validTick = Math.trunc(tick / tickSpacing) * tickSpacing;
+    // Handle negative ticks (Solidity behavior)
+    if (tick < 0 && tick % tickSpacing !== 0) {
+        validTick -= tickSpacing;
     }
-    /**
-     * Calculates the ETH required to flaunch a token, takes into account the ETH for premine and the flaunching fee
-     */
-    ethRequiredToFlaunch(params) {
-        return this.contract.read("calculateFee", {
-            _premineAmount: params.premineAmount ?? 0n,
-            _slippage: params.slippagePercent
-                ? BigInt(params.slippagePercent * 100)
-                : 0n,
-            _initialPriceParams: params.initialPriceParams,
-        });
+    // If not rounding down, add TICK_SPACING to get the upper tick
+    if (!roundDown) {
+        validTick += tickSpacing;
     }
-}
-/**
- * Extended client for interacting with the FlaunchZap contract with write capabilities
- */
-class ReadWriteFlaunchZap extends ReadFlaunchZap {
-    constructor(chainId, address, drift$1 = drift.createDrift()) {
-        super(chainId, address, drift$1);
+    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) {
+        [sqrtRatioA, sqrtRatioB] = [sqrtRatioB, sqrtRatioA];
     }
-    /**
-     * Flaunches a new token, supports premine
-     * @param params - Parameters for the flaunch
-     * @returns Transaction response for the flaunch creation
-     */
-    async flaunch(params) {
-        const initialMCapInUSDCWei = viem.parseUnits(params.initialMarketCapUSD.toString(), 6);
-        const initialPriceParams = viem.encodeAbiParameters([
-            {
-                type: "uint256",
-            },
-        ], [initialMCapInUSDCWei]);
-        const fairLaunchInBps = BigInt(params.fairLaunchPercent * 100);
-        const creatorFeeAllocationInBps = params.creatorFeeAllocationPercent * 100;
-        const ethRequired = await this.ethRequiredToFlaunch({
-            premineAmount: params.premineAmount ?? 0n,
-            initialPriceParams,
-            slippagePercent: 5,
-        });
-        const _treasuryManagerParams = params.treasuryManagerParams
-            ? {
-                manager: params.treasuryManagerParams.manager ?? viem.zeroAddress,
-                permissions: params.treasuryManagerParams.permissions ?? exports.Permissions.OPEN,
-                initializeData: params.treasuryManagerParams.initializeData ?? "0x",
-                depositData: params.treasuryManagerParams.depositData ?? "0x",
-            }
-            : {
-                manager: viem.zeroAddress,
-                permissions: exports.Permissions.OPEN,
-                initializeData: "0x",
-                depositData: "0x",
-            };
-        const feeCalculatorParams = params.trustedSignerSettings
-            ? viem.encodeAbiParameters([
-                { type: "bool", name: "enabled" },
-                { type: "uint256", name: "walletCap" },
-                { type: "uint256", name: "txCap" },
-            ], [
-                params.trustedSignerSettings.enabled,
-                params.trustedSignerSettings.walletCap ?? 0n,
-                params.trustedSignerSettings.txCap ?? 0n,
-            ])
-            : "0x";
-        const _premineSwapHookData = params.trustedSignerSettings?.enabled
-            ? viem.encodeAbiParameters([
-                { type: "address", name: "referrer" },
-                {
-                    type: "tuple",
-                    components: [
-                        { type: "uint256", name: "deadline" },
-                        { type: "bytes", name: "signature" },
-                    ],
-                },
-            ], [
-                viem.zeroAddress,
-                {
-                    deadline: BigInt(params.trustedSignerSettings.premineSignedMessage?.deadline ?? 0),
-                    signature: params.trustedSignerSettings.premineSignedMessage?.signature ??
-                        "0x",
-                },
-            ])
-            : "0x";
-        return this.contract.write("flaunch", {
-            _flaunchParams: {
-                name: params.name,
-                symbol: params.symbol,
-                tokenUri: params.tokenUri,
-                initialTokenFairLaunch: (this.TOTAL_SUPPLY * fairLaunchInBps) / 10000n,
-                fairLaunchDuration: BigInt(params.fairLaunchDuration),
-                premineAmount: params.premineAmount ?? 0n,
-                creator: params.creator,
-                creatorFeeAllocation: creatorFeeAllocationInBps,
-                flaunchAt: params.flaunchAt ?? 0n,
-                initialPriceParams,
-                feeCalculatorParams,
-            },
-            _trustedFeeSigner: params.trustedSignerSettings?.trustedFeeSigner ?? viem.zeroAddress,
-            _premineSwapHookData,
-            _treasuryManagerParams: {
-                ..._treasuryManagerParams,
-                permissions: getPermissionsAddress(_treasuryManagerParams.permissions, this.chainId),
-            },
-            _whitelistParams: {
-                merkleRoot: viem.zeroHash,
-                merkleIPFSHash: "",
-                maxTokens: 0n,
-            },
-            _airdropParams: {
-                airdropIndex: 0n,
-                airdropAmount: 0n,
-                airdropEndTime: 0n,
-                merkleRoot: viem.zeroHash,
-                merkleIPFSHash: "",
-            },
-        }, {
-            value: ethRequired,
-        });
+    const leftShiftedLiquidity = liquidity << 96n;
+    const sqrtDiff = sqrtRatioB - sqrtRatioA;
+    const multipliedRes = leftShiftedLiquidity * sqrtDiff;
+    const numerator = multipliedRes / sqrtRatioB;
+    const amount0 = numerator / sqrtRatioA;
+    return amount0;
+};
+const getAmount1ForLiquidity = (sqrtRatioAX96, sqrtRatioBX96, liquidity) => {
+    let [sqrtRatioA, sqrtRatioB] = [sqrtRatioAX96, sqrtRatioBX96];
+    if (sqrtRatioA > sqrtRatioB) {
+        [sqrtRatioA, sqrtRatioB] = [sqrtRatioB, sqrtRatioA];
     }
-    async flaunchIPFS(params) {
-        const tokenUri = await generateTokenUri(params.name, params.symbol, {
-            metadata: params.metadata,
-            pinataConfig: params.pinataConfig,
-        });
-        return this.flaunch({
-            ...params,
-            tokenUri,
-        });
+    const sqrtDiff = sqrtRatioB - sqrtRatioA;
+    const multipliedRes = liquidity * sqrtDiff;
+    const amount1 = multipliedRes / 2n ** 96n;
+    return amount1;
+};
+const getSqrtPriceX96FromTick = (tick) => {
+    const absTick = tick < 0 ? BigInt(-tick) : BigInt(tick);
+    if (absTick > TickFinder.MAX_TICK) {
+        throw new Error("Tick out of range");
     }
-    /**
-     * Flaunches a new token for a revenue manager
-     * @param params - Parameters for the flaunch with revenue manager
-     * @param params.name - The name of the token
-     * @param params.symbol - The symbol of the token
-     * @param params.tokenUri - The URI containing the token metadata
-     * @param params.fairLaunchPercent - Percentage of total supply to be used in fair launch (0-100)
-     * @param params.fairLaunchDuration - Duration of fair launch in seconds
-     * @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.protocolRecipient - Address to receive protocol fees
-     * @param params.protocolFeePercent - Percentage of fees allocated to protocol (0-100)
-     * @param params.flaunchAt - Optional timestamp when the flaunch should start
+    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);
+    const sqrtPriceLowerX96 = getSqrtPriceX96FromTick(tickLower);
+    const sqrtPriceUpperX96 = getSqrtPriceX96FromTick(tickUpper);
+    let amount0 = 0n;
+    let amount1 = 0n;
+    if (sqrtPriceCurrentX96 <= sqrtPriceLowerX96) {
+        // Current price is below the position range
+        amount0 = getAmount0ForLiquidity(sqrtPriceLowerX96, sqrtPriceUpperX96, liquidity);
+    }
+    else if (sqrtPriceCurrentX96 < sqrtPriceUpperX96) {
+        // Current price is within the position range
+        amount0 = getAmount0ForLiquidity(sqrtPriceCurrentX96, sqrtPriceUpperX96, liquidity);
+        amount1 = getAmount1ForLiquidity(sqrtPriceLowerX96, sqrtPriceCurrentX96, liquidity);
+    }
+    else {
+        // Current price is above the position range
+        amount1 = getAmount1ForLiquidity(sqrtPriceLowerX96, sqrtPriceUpperX96, liquidity);
+    }
+    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];
+    }
+    // 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);
+    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];
+    }
+    // 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);
+}
+/**
+ * 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 };
+};
+
+/**
+ * Base client for interacting with the FlaunchZap contract in read-only mode
+ * Provides basic contract initialization
+ */
+class ReadFlaunchZap {
+    /**
+     * Creates a new ReadFlaunchZap instance
+     * @param chainId - The chain ID of the contract
+     * @param address - The address of the FlaunchZap contract
+     * @param drift - Optional drift instance for contract interactions (creates new instance if not provided)
+     * @throws Error if address is not provided
+     */
+    constructor(chainId, address, drift$1 = drift.createDrift()) {
+        this.TOTAL_SUPPLY = 100n * 10n ** 27n; // 100 Billion tokens in wei
+        this.chainId = chainId;
+        this.drift = drift$1;
+        if (!address) {
+            throw new Error("Address is required");
+        }
+        this.contract = drift$1.contract({
+            abi: FlaunchZapAbi,
+            address,
+        });
+        this.readPositionManagerV1_1 = new ReadFlaunchPositionManagerV1_1(FlaunchPositionManagerV1_1Address[this.chainId], drift$1);
+    }
+    async getPremineCostInWei(params) {
+        const mcapInWei = await this.readPositionManagerV1_1.getFlaunchingMarketCap(params.initialPriceParams);
+        const premineCostInWei = (mcapInWei * params.premineAmount) / this.TOTAL_SUPPLY;
+        // increase the premine cost by the slippage percent
+        const premineCostInWeiWithSlippage = getAmountWithSlippage({
+            amount: premineCostInWei,
+            slippage: (params.slippagePercent ?? 0 / 100).toFixed(18).toString(),
+            swapType: "EXACT_OUT", // as we know the output premine amount
+        });
+        return premineCostInWeiWithSlippage;
+    }
+    async getFlaunchingFee(params) {
+        const readInitialPrice = new ReadInitialPrice(await this.readPositionManagerV1_1.initialPrice(), this.drift);
+        const flaunchingFee = await readInitialPrice.getFlaunchingFee(params);
+        // increase the flaunching fee by the slippage percent
+        const flaunchingFeeWithSlippage = getAmountWithSlippage({
+            amount: flaunchingFee,
+            slippage: (params.slippagePercent ?? 0 / 100).toFixed(18).toString(),
+            swapType: "EXACT_OUT",
+        });
+        return flaunchingFeeWithSlippage;
+    }
+    /**
+     * Calculates the ETH required to flaunch a token, takes into account the ETH for premine and the flaunching fee
+     */
+    ethRequiredToFlaunch(params) {
+        return this.contract.read("calculateFee", {
+            _premineAmount: params.premineAmount ?? 0n,
+            _slippage: params.slippagePercent
+                ? BigInt(params.slippagePercent * 100)
+                : 0n,
+            _initialPriceParams: params.initialPriceParams,
+        });
+    }
+}
+/**
+ * Extended client for interacting with the FlaunchZap contract with write capabilities
+ */
+class ReadWriteFlaunchZap extends ReadFlaunchZap {
+    constructor(chainId, address, drift$1 = drift.createDrift()) {
+        super(chainId, address, drift$1);
+    }
+    /**
+     * Flaunches a new token, supports premine
+     * @param params - Parameters for the flaunch
+     * @returns Transaction response for the flaunch creation
+     */
+    async flaunch(params) {
+        const initialMCapInUSDCWei = viem.parseUnits(params.initialMarketCapUSD.toString(), 6);
+        const initialPriceParams = viem.encodeAbiParameters([
+            {
+                type: "uint256",
+            },
+        ], [initialMCapInUSDCWei]);
+        const fairLaunchInBps = BigInt(params.fairLaunchPercent * 100);
+        const creatorFeeAllocationInBps = params.creatorFeeAllocationPercent * 100;
+        const ethRequired = await this.ethRequiredToFlaunch({
+            premineAmount: params.premineAmount ?? 0n,
+            initialPriceParams,
+            slippagePercent: 5,
+        });
+        const _treasuryManagerParams = params.treasuryManagerParams
+            ? {
+                manager: params.treasuryManagerParams.manager ?? viem.zeroAddress,
+                permissions: params.treasuryManagerParams.permissions ?? exports.Permissions.OPEN,
+                initializeData: params.treasuryManagerParams.initializeData ?? "0x",
+                depositData: params.treasuryManagerParams.depositData ?? "0x",
+            }
+            : {
+                manager: viem.zeroAddress,
+                permissions: exports.Permissions.OPEN,
+                initializeData: "0x",
+                depositData: "0x",
+            };
+        const feeCalculatorParams = params.trustedSignerSettings
+            ? viem.encodeAbiParameters([
+                { type: "bool", name: "enabled" },
+                { type: "uint256", name: "walletCap" },
+                { type: "uint256", name: "txCap" },
+            ], [
+                params.trustedSignerSettings.enabled,
+                params.trustedSignerSettings.walletCap ?? 0n,
+                params.trustedSignerSettings.txCap ?? 0n,
+            ])
+            : "0x";
+        const _premineSwapHookData = params.trustedSignerSettings?.enabled
+            ? viem.encodeAbiParameters([
+                { type: "address", name: "referrer" },
+                {
+                    type: "tuple",
+                    components: [
+                        { type: "uint256", name: "deadline" },
+                        { type: "bytes", name: "signature" },
+                    ],
+                },
+            ], [
+                viem.zeroAddress,
+                {
+                    deadline: BigInt(params.trustedSignerSettings.premineSignedMessage?.deadline ?? 0),
+                    signature: params.trustedSignerSettings.premineSignedMessage?.signature ??
+                        "0x",
+                },
+            ])
+            : "0x";
+        return this.contract.write("flaunch", {
+            _flaunchParams: {
+                name: params.name,
+                symbol: params.symbol,
+                tokenUri: params.tokenUri,
+                initialTokenFairLaunch: (this.TOTAL_SUPPLY * fairLaunchInBps) / 10000n,
+                fairLaunchDuration: BigInt(params.fairLaunchDuration),
+                premineAmount: params.premineAmount ?? 0n,
+                creator: params.creator,
+                creatorFeeAllocation: creatorFeeAllocationInBps,
+                flaunchAt: params.flaunchAt ?? 0n,
+                initialPriceParams,
+                feeCalculatorParams,
+            },
+            _trustedFeeSigner: params.trustedSignerSettings?.trustedFeeSigner ?? viem.zeroAddress,
+            _premineSwapHookData,
+            _treasuryManagerParams: {
+                ..._treasuryManagerParams,
+                permissions: getPermissionsAddress(_treasuryManagerParams.permissions, this.chainId),
+            },
+            _whitelistParams: {
+                merkleRoot: viem.zeroHash,
+                merkleIPFSHash: "",
+                maxTokens: 0n,
+            },
+            _airdropParams: {
+                airdropIndex: 0n,
+                airdropAmount: 0n,
+                airdropEndTime: 0n,
+                merkleRoot: viem.zeroHash,
+                merkleIPFSHash: "",
+            },
+        }, {
+            value: ethRequired,
+        });
+    }
+    async flaunchIPFS(params) {
+        const tokenUri = await generateTokenUri(params.name, params.symbol, {
+            metadata: params.metadata,
+            pinataConfig: params.pinataConfig,
+        });
+        return this.flaunch({
+            ...params,
+            tokenUri,
+        });
+    }
+    /**
+     * Flaunches a new token for a revenue manager
+     * @param params - Parameters for the flaunch with revenue manager
+     * @param params.name - The name of the token
+     * @param params.symbol - The symbol of the token
+     * @param params.tokenUri - The URI containing the token metadata
+     * @param params.fairLaunchPercent - Percentage of total supply to be used in fair launch (0-100)
+     * @param params.fairLaunchDuration - Duration of fair launch in seconds
+     * @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.protocolRecipient - Address to receive protocol fees
+     * @param params.protocolFeePercent - Percentage of fees allocated to protocol (0-100)
+     * @param params.flaunchAt - Optional timestamp when the flaunch should start
      * @param params.premineAmount - Optional amount of tokens to premine
      * @returns Transaction response for the flaunch creation
      */
@@ -14152,6 +14446,66 @@ class ReadWriteFlaunchZap extends ReadFlaunchZap {
             _permissions: permissionsAddress,
         });
     }
+    /**
+     * Deploys a new BuyBack manager
+     * @param params - Parameters for deploying the BuyBack manager
+     * @param params.managerOwner - The address of the manager owner
+     * @param params.creatorSharePercent - The % share that a creator will earn from their token (0-100)
+     * @param params.ownerSharePercent - The % share that the manager owner will earn from their token (0-100)
+     * @param params.buyBackPoolKey - The Uniswap V4 pool key configuration for the buyback pool
+     * @param params.buyBackPoolKey.currency0 - The lower currency of the pool (sorted numerically)
+     * @param params.buyBackPoolKey.currency1 - The higher currency of the pool (sorted numerically)
+     * @param params.buyBackPoolKey.fee - The pool LP fee, capped at 1_000_000
+     * @param params.buyBackPoolKey.tickSpacing - Tick spacing for the pool
+     * @param params.buyBackPoolKey.hooks - The hooks address of the pool
+     * @param params.permissions - The permissions for the BuyBack manager
+     * @returns Transaction response
+     */
+    deployBuyBackManager(params) {
+        const permissionsAddress = getPermissionsAddress(params.permissions ?? exports.Permissions.OPEN, this.chainId);
+        const VALID_SHARE_TOTAL = 10000000n; // 5 decimals as BigInt
+        const buyBackManagerAddress = BuyBackManagerAddress[this.chainId];
+        if (buyBackManagerAddress === viem.zeroAddress) {
+            throw new Error(`BuyBackManager not deployed on chainId: ${this.chainId}`);
+        }
+        return this.contract.write("deployAndInitializeManager", {
+            _managerImplementation: buyBackManagerAddress,
+            _owner: params.managerOwner,
+            _data: viem.encodeAbiParameters([
+                {
+                    type: "tuple",
+                    components: [
+                        { type: "uint256", name: "creatorShare" },
+                        { type: "uint256", name: "ownerShare" },
+                        {
+                            type: "tuple",
+                            name: "buyBackPoolKey",
+                            components: [
+                                { type: "address", name: "currency0" },
+                                { type: "address", name: "currency1" },
+                                { type: "uint24", name: "fee" },
+                                { type: "int24", name: "tickSpacing" },
+                                { type: "address", name: "hooks" },
+                            ],
+                        },
+                    ],
+                },
+            ], [
+                {
+                    creatorShare: (BigInt(params.creatorSharePercent) * VALID_SHARE_TOTAL) / 100n,
+                    ownerShare: (BigInt(params.ownerSharePercent) * VALID_SHARE_TOTAL) / 100n,
+                    buyBackPoolKey: orderPoolKey({
+                        currency0: params.buyBackPoolKey.currency0,
+                        currency1: params.buyBackPoolKey.currency1,
+                        fee: params.buyBackPoolKey.fee,
+                        tickSpacing: params.buyBackPoolKey.tickSpacing,
+                        hooks: params.buyBackPoolKey.hooks,
+                    }),
+                },
+            ]),
+            _permissions: permissionsAddress,
+        });
+    }
 }
 
 const FlaunchAbi = [
@@ -24729,803 +25083,513 @@ const MulticallAbi = [
                 type: "uint256",
             },
         ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getChainId",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "chainid",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getCurrentBlockCoinbase",
-        outputs: [
-            {
-                internalType: "address",
-                name: "coinbase",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getCurrentBlockDifficulty",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "difficulty",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getCurrentBlockGasLimit",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "gaslimit",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getCurrentBlockTimestamp",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "timestamp",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "addr",
-                type: "address",
-            },
-        ],
-        name: "getEthBalance",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "balance",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getLastBlockHash",
-        outputs: [
-            {
-                internalType: "bytes32",
-                name: "blockHash",
-                type: "bytes32",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bool",
-                name: "requireSuccess",
-                type: "bool",
-            },
-            {
-                components: [
-                    {
-                        internalType: "address",
-                        name: "target",
-                        type: "address",
-                    },
-                    {
-                        internalType: "bytes",
-                        name: "callData",
-                        type: "bytes",
-                    },
-                ],
-                internalType: "struct Multicall3.Call[]",
-                name: "calls",
-                type: "tuple[]",
-            },
-        ],
-        name: "tryAggregate",
-        outputs: [
-            {
-                components: [
-                    {
-                        internalType: "bool",
-                        name: "success",
-                        type: "bool",
-                    },
-                    {
-                        internalType: "bytes",
-                        name: "returnData",
-                        type: "bytes",
-                    },
-                ],
-                internalType: "struct Multicall3.Result[]",
-                name: "returnData",
-                type: "tuple[]",
-            },
-        ],
-        stateMutability: "payable",
+        stateMutability: "view",
         type: "function",
     },
     {
-        inputs: [
+        inputs: [],
+        name: "getChainId",
+        outputs: [
             {
-                internalType: "bool",
-                name: "requireSuccess",
-                type: "bool",
+                internalType: "uint256",
+                name: "chainid",
+                type: "uint256",
             },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCurrentBlockCoinbase",
+        outputs: [
             {
-                components: [
-                    {
-                        internalType: "address",
-                        name: "target",
-                        type: "address",
-                    },
-                    {
-                        internalType: "bytes",
-                        name: "callData",
-                        type: "bytes",
-                    },
-                ],
-                internalType: "struct Multicall3.Call[]",
-                name: "calls",
-                type: "tuple[]",
+                internalType: "address",
+                name: "coinbase",
+                type: "address",
             },
         ],
-        name: "tryBlockAndAggregate",
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCurrentBlockDifficulty",
         outputs: [
             {
                 internalType: "uint256",
-                name: "blockNumber",
+                name: "difficulty",
                 type: "uint256",
             },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCurrentBlockGasLimit",
+        outputs: [
             {
-                internalType: "bytes32",
-                name: "blockHash",
-                type: "bytes32",
-            },
-            {
-                components: [
-                    {
-                        internalType: "bool",
-                        name: "success",
-                        type: "bool",
-                    },
-                    {
-                        internalType: "bytes",
-                        name: "returnData",
-                        type: "bytes",
-                    },
-                ],
-                internalType: "struct Multicall3.Result[]",
-                name: "returnData",
-                type: "tuple[]",
+                internalType: "uint256",
+                name: "gaslimit",
+                type: "uint256",
             },
         ],
-        stateMutability: "payable",
+        stateMutability: "view",
         type: "function",
     },
-];
-
-class ReadMulticall {
-    constructor(drift) {
-        // same address across all chains
-        this.address = "0xcA11bde05977b3631167028862bE2a173976CA11";
-        this.contract = drift.contract({
-            abi: MulticallAbi,
-            address: this.address,
-        });
-    }
-    aggregate3(calls) {
-        return this.contract.simulateWrite("aggregate3", {
-            calls: calls.map((call) => ({
-                target: call.target,
-                allowFailure: true,
-                callData: call.callData,
-            })),
-        });
-    }
-}
-
-class ReadRevenueManager {
-    constructor(address, drift$1 = drift.createDrift()) {
-        this.drift = drift$1;
-        this.contract = drift$1.contract({
-            abi: RevenueManagerAbi,
-            address,
-        });
-    }
-    /**
-     * Gets the claimable balance of ETH for the recipient
-     * @param recipient - The address of the recipient to check
-     * @returns Promise<bigint> - The claimable balance of ETH
-     */
-    balances(address) {
-        return this.contract.read("balances", {
-            _recipient: address,
-        });
-    }
-    /**
-     * Gets the protocol recipient address
-     * @returns Promise<Address> - The protocol recipient address
-     */
-    protocolRecipient() {
-        return this.contract.read("protocolRecipient");
-    }
-    /**
-     * Gets the total number of tokens managed by the revenue manager
-     * @returns Promise<bigint> - The total count of tokens
-     */
-    async tokensCount() {
-        const nextInternalId = await this.contract.read("nextInternalId");
-        return nextInternalId - 1n;
-    }
-    /**
-     * Gets all tokens created by a specific creator address
-     * @param creator - The address of the creator to query tokens for
-     * @param sortByDesc - Optional boolean to sort tokens in descending order (default: false)
-     * @returns Promise<Array<{flaunch: Address, tokenId: bigint}>> - Array of token objects containing flaunch address and token ID
-     */
-    async allTokensByCreator(creator, sortByDesc = false) {
-        const tokens = await this.contract.read("tokens", {
-            _creator: creator,
-        });
-        if (sortByDesc) {
-            return [...tokens].reverse();
-        }
-        return tokens;
-    }
-    /**
-     * Gets all tokens currently managed by the revenue manager contract
-     * @dev Uses multicall to batch requests for better performance
-     * @param sortByDesc - Optional boolean to sort tokens in descending order (default: false)
-     * @returns Promise<Array<{flaunch: Address, tokenId: bigint}>> - Array of token objects containing flaunch address and token ID
-     */
-    async allTokensInManager(sortByDesc = false) {
-        const count = await this.tokensCount();
-        const multicall = new ReadMulticall(this.drift);
-        let calldatas = Array.from({ length: Number(count) }, (_, i) => this.contract.encodeFunctionData("internalIds", {
-            _internalId: BigInt(i + 1),
-        }));
-        // Reverse the array if sortByDesc is true
-        if (sortByDesc) {
-            calldatas = calldatas.reverse();
-        }
-        const result = await multicall.aggregate3(calldatas.map((calldata) => ({
-            target: this.contract.address,
-            callData: calldata,
-        })));
-        return result.map((r) => this.contract.decodeFunctionReturn("internalIds", r.returnData));
-    }
-}
-class ReadWriteRevenueManager extends ReadRevenueManager {
-    constructor(address, drift$1 = drift.createDrift()) {
-        super(address, drift$1);
-    }
-    /**
-     * Allows the protocol recipient to claim the protocol's share of the revenue
-     * @returns Promise<TransactionResponse> - The transaction response
-     */
-    protocolClaim() {
-        return this.contract.write("claim", {});
-    }
-    /**
-     * Allows the creator to claim their total share of the revenue from a revenue manager
-     * @returns Promise<TransactionResponse> - The transaction response
-     */
-    creatorClaim() {
-        return this.contract.write("claim", {});
-    }
-    /**
-     * Allows the creator to claim their share of the revenue from specific flaunch tokens
-     * @param flaunchTokens - The flaunch token ids to claim the revenue for
-     * @returns Promise<TransactionResponse> - The transaction response
-     */
-    creatorClaimForTokens(flaunchTokens) {
-        return this.contract.write("claim", {
-            _flaunchToken: flaunchTokens,
-        });
-    }
-}
-
-const TreasuryManagerAbi = [
     {
-        type: "function",
-        name: "deposit",
-        inputs: [
+        inputs: [],
+        name: "getCurrentBlockTimestamp",
+        outputs: [
             {
-                name: "_flaunchToken",
-                type: "tuple",
-                internalType: "struct ITreasuryManager.FlaunchToken",
-                components: [
-                    {
-                        name: "flaunch",
-                        type: "address",
-                        internalType: "contract Flaunch",
-                    },
-                    { name: "tokenId", type: "uint256", internalType: "uint256" },
-                ],
+                internalType: "uint256",
+                name: "timestamp",
+                type: "uint256",
             },
-            { name: "_creator", type: "address", internalType: "address" },
-            { name: "_data", type: "bytes", internalType: "bytes" },
         ],
-        outputs: [],
-        stateMutability: "nonpayable",
+        stateMutability: "view",
+        type: "function",
     },
     {
-        type: "function",
-        name: "initialize",
         inputs: [
-            { name: "_owner", type: "address", internalType: "address" },
-            { name: "_data", type: "bytes", internalType: "bytes" },
+            {
+                internalType: "address",
+                name: "addr",
+                type: "address",
+            },
+        ],
+        name: "getEthBalance",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "balance",
+                type: "uint256",
+            },
         ],
-        outputs: [],
-        stateMutability: "nonpayable",
-    },
-    {
-        type: "function",
-        name: "managerOwner",
-        inputs: [],
-        outputs: [{ name: "", type: "address", internalType: "address" }],
         stateMutability: "view",
+        type: "function",
     },
     {
-        type: "function",
-        name: "permissions",
         inputs: [],
+        name: "getLastBlockHash",
         outputs: [
             {
-                name: "",
-                type: "address",
-                internalType: "contract IManagerPermissions",
+                internalType: "bytes32",
+                name: "blockHash",
+                type: "bytes32",
             },
         ],
         stateMutability: "view",
+        type: "function",
     },
     {
-        type: "function",
-        name: "rescue",
         inputs: [
             {
-                name: "_flaunchToken",
-                type: "tuple",
-                internalType: "struct ITreasuryManager.FlaunchToken",
+                internalType: "bool",
+                name: "requireSuccess",
+                type: "bool",
+            },
+            {
                 components: [
                     {
-                        name: "flaunch",
+                        internalType: "address",
+                        name: "target",
                         type: "address",
-                        internalType: "contract Flaunch",
                     },
-                    { name: "tokenId", type: "uint256", internalType: "uint256" },
+                    {
+                        internalType: "bytes",
+                        name: "callData",
+                        type: "bytes",
+                    },
                 ],
+                internalType: "struct Multicall3.Call[]",
+                name: "calls",
+                type: "tuple[]",
             },
-            { name: "_recipient", type: "address", internalType: "address" },
         ],
-        outputs: [],
-        stateMutability: "nonpayable",
-    },
-    {
-        type: "function",
-        name: "setPermissions",
-        inputs: [
-            { name: "_permissions", type: "address", internalType: "address" },
+        name: "tryAggregate",
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: "bool",
+                        name: "success",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "returnData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Result[]",
+                name: "returnData",
+                type: "tuple[]",
+            },
         ],
-        outputs: [],
-        stateMutability: "nonpayable",
+        stateMutability: "payable",
+        type: "function",
     },
     {
-        type: "function",
-        name: "transferManagerOwnership",
         inputs: [
             {
-                name: "_newManagerOwner",
-                type: "address",
-                internalType: "address",
+                internalType: "bool",
+                name: "requireSuccess",
+                type: "bool",
+            },
+            {
+                components: [
+                    {
+                        internalType: "address",
+                        name: "target",
+                        type: "address",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "callData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Call[]",
+                name: "calls",
+                type: "tuple[]",
             },
         ],
-        outputs: [],
-        stateMutability: "nonpayable",
-    },
-];
-
-/**
- * Client for interacting with the TreasuryManager contract in read-only mode
- * Provides methods to query permissions and manager owner
- */
-class ReadTreasuryManager {
-    /**
-     * Creates a new ReadTreasuryManager instance
-     * @param address - The address of the TreasuryManager contract
-     * @param drift - Optional drift instance for contract interactions (creates new instance if not provided)
-     * @throws Error if address is not provided
-     */
-    constructor(address, drift$1 = drift.createDrift()) {
-        if (!address) {
-            throw new Error("Address is required");
-        }
-        this.contract = drift$1.contract({
-            abi: TreasuryManagerAbi,
-            address,
-        });
-    }
-    /**
-     * Gets the permissions contract address
-     * @returns Promise<Address> - The address of the permissions contract
-     */
-    permissions() {
-        return this.contract.read("permissions");
-    }
-    /**
-     * Gets the manager owner address
-     * @returns Promise<Address> - The address of the manager owner
-     */
-    managerOwner() {
-        return this.contract.read("managerOwner");
-    }
-}
-/**
- * Extended client for interacting with the TreasuryManager contract with write capabilities
- * Provides methods to deposit tokens, set permissions, and transfer ownership
- */
-class ReadWriteTreasuryManager extends ReadTreasuryManager {
-    constructor(address, drift$1 = drift.createDrift()) {
-        super(address, drift$1);
-    }
-    /**
-     * Deposits a flaunch token to the treasury
-     * @param flaunchToken - The flaunch token to deposit
-     * @param creator - The address of the creator
-     * @param data - Additional data for the deposit
-     * @returns Promise<void>
-     */
-    deposit(flaunchToken, creator, data) {
-        return this.contract.write("deposit", {
-            _flaunchToken: flaunchToken,
-            _creator: creator,
-            _data: data,
-        });
-    }
-    /**
-     * Sets the permissions contract address
-     * @param permissions - The address of the new permissions contract
-     * @returns Promise<void>
-     */
-    setPermissions(permissions) {
-        return this.contract.write("setPermissions", {
-            _permissions: permissions,
-        });
-    }
-    /**
-     * Transfers the manager ownership to a new address
-     * @param newManagerOwner - The address of the new manager owner
-     * @returns Promise<void>
-     */
-    transferManagerOwnership(newManagerOwner) {
-        return this.contract.write("transferManagerOwnership", {
-            _newManagerOwner: newManagerOwner,
-        });
-    }
-}
-
-// our min/max tick range that is valid for the tick spacing (60)
-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
-    const packed = viem.concat([
-        viem.pad(poolKey.currency0, { size: 32 }), // address padded to 32 bytes
-        viem.pad(poolKey.currency1, { size: 32 }), // address padded to 32 bytes
-        viem.pad(viem.toHex(poolKey.fee), { size: 32 }), // uint24 padded to 32 bytes
-        viem.pad(viem.toHex(poolKey.tickSpacing), { size: 32 }), // int24 padded to 32 bytes
-        viem.pad(poolKey.hooks, { size: 32 }), // address padded to 32 bytes
-    ]);
-    return viem.keccak256(packed);
-};
-const orderPoolKey = (poolKey) => {
-    const [currency0, currency1] = poolKey.currency0 < poolKey.currency1
-        ? [poolKey.currency0, poolKey.currency1]
-        : [poolKey.currency1, poolKey.currency0];
-    return {
-        ...poolKey,
-        currency0,
-        currency1,
-    };
-};
-const getValidTick = ({ tick, tickSpacing, roundDown = true, }) => {
-    // If the tick is already valid, exit early
-    if (tick % tickSpacing === 0) {
-        return tick;
-    }
-    // Division that rounds towards zero (like Solidity)
-    let validTick = Math.trunc(tick / tickSpacing) * tickSpacing;
-    // Handle negative ticks (Solidity behavior)
-    if (tick < 0 && tick % tickSpacing !== 0) {
-        validTick -= tickSpacing;
-    }
-    // If not rounding down, add TICK_SPACING to get the upper tick
-    if (!roundDown) {
-        validTick += tickSpacing;
-    }
-    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) {
-        [sqrtRatioA, sqrtRatioB] = [sqrtRatioB, sqrtRatioA];
-    }
-    const leftShiftedLiquidity = liquidity << 96n;
-    const sqrtDiff = sqrtRatioB - sqrtRatioA;
-    const multipliedRes = leftShiftedLiquidity * sqrtDiff;
-    const numerator = multipliedRes / sqrtRatioB;
-    const amount0 = numerator / sqrtRatioA;
-    return amount0;
-};
-const getAmount1ForLiquidity = (sqrtRatioAX96, sqrtRatioBX96, liquidity) => {
-    let [sqrtRatioA, sqrtRatioB] = [sqrtRatioAX96, sqrtRatioBX96];
-    if (sqrtRatioA > sqrtRatioB) {
-        [sqrtRatioA, sqrtRatioB] = [sqrtRatioB, sqrtRatioA];
-    }
-    const sqrtDiff = sqrtRatioB - sqrtRatioA;
-    const multipliedRes = liquidity * sqrtDiff;
-    const amount1 = multipliedRes / 2n ** 96n;
-    return amount1;
-};
-const getSqrtPriceX96FromTick = (tick) => {
-    const absTick = tick < 0 ? BigInt(-tick) : BigInt(tick);
-    if (absTick > TickFinder.MAX_TICK) {
-        throw new Error("Tick out of range");
+        name: "tryBlockAndAggregate",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "blockNumber",
+                type: "uint256",
+            },
+            {
+                internalType: "bytes32",
+                name: "blockHash",
+                type: "bytes32",
+            },
+            {
+                components: [
+                    {
+                        internalType: "bool",
+                        name: "success",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "returnData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Result[]",
+                name: "returnData",
+                type: "tuple[]",
+            },
+        ],
+        stateMutability: "payable",
+        type: "function",
+    },
+];
+
+class ReadMulticall {
+    constructor(drift) {
+        // same address across all chains
+        this.address = "0xcA11bde05977b3631167028862bE2a173976CA11";
+        this.contract = drift.contract({
+            abi: MulticallAbi,
+            address: this.address,
+        });
     }
-    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;
+    aggregate3(calls) {
+        return this.contract.simulateWrite("aggregate3", {
+            calls: calls.map((call) => ({
+                target: call.target,
+                allowFailure: true,
+                callData: call.callData,
+            })),
+        });
     }
-    // Convert from Q128.128 to Q128.96
-    const resultShifted = ratio >> 32n;
-    if (ratio % (1n << 32n) === 0n) {
-        return resultShifted;
+}
+
+class ReadRevenueManager {
+    constructor(address, drift$1 = drift.createDrift()) {
+        this.drift = drift$1;
+        this.contract = drift$1.contract({
+            abi: RevenueManagerAbi,
+            address,
+        });
     }
-    return resultShifted + 1n;
-};
-const calculateUnderlyingTokenBalances = (liquidity, tickLower, tickUpper, tickCurrent) => {
-    const sqrtPriceCurrentX96 = getSqrtPriceX96FromTick(tickCurrent);
-    const sqrtPriceLowerX96 = getSqrtPriceX96FromTick(tickLower);
-    const sqrtPriceUpperX96 = getSqrtPriceX96FromTick(tickUpper);
-    let amount0 = 0n;
-    let amount1 = 0n;
-    if (sqrtPriceCurrentX96 <= sqrtPriceLowerX96) {
-        // Current price is below the position range
-        amount0 = getAmount0ForLiquidity(sqrtPriceLowerX96, sqrtPriceUpperX96, liquidity);
+    /**
+     * Gets the claimable balance of ETH for the recipient
+     * @param recipient - The address of the recipient to check
+     * @returns Promise<bigint> - The claimable balance of ETH
+     */
+    balances(address) {
+        return this.contract.read("balances", {
+            _recipient: address,
+        });
     }
-    else if (sqrtPriceCurrentX96 < sqrtPriceUpperX96) {
-        // Current price is within the position range
-        amount0 = getAmount0ForLiquidity(sqrtPriceCurrentX96, sqrtPriceUpperX96, liquidity);
-        amount1 = getAmount1ForLiquidity(sqrtPriceLowerX96, sqrtPriceCurrentX96, liquidity);
+    /**
+     * Gets the protocol recipient address
+     * @returns Promise<Address> - The protocol recipient address
+     */
+    protocolRecipient() {
+        return this.contract.read("protocolRecipient");
     }
-    else {
-        // Current price is above the position range
-        amount1 = getAmount1ForLiquidity(sqrtPriceLowerX96, sqrtPriceUpperX96, liquidity);
+    /**
+     * Gets the total number of tokens managed by the revenue manager
+     * @returns Promise<bigint> - The total count of tokens
+     */
+    async tokensCount() {
+        const nextInternalId = await this.contract.read("nextInternalId");
+        return nextInternalId - 1n;
     }
-    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);
+    /**
+     * Gets all tokens created by a specific creator address
+     * @param creator - The address of the creator to query tokens for
+     * @param sortByDesc - Optional boolean to sort tokens in descending order (default: false)
+     * @returns Promise<Array<{flaunch: Address, tokenId: bigint}>> - Array of token objects containing flaunch address and token ID
+     */
+    async allTokensByCreator(creator, sortByDesc = false) {
+        const tokens = await this.contract.read("tokens", {
+            _creator: creator,
+        });
+        if (sortByDesc) {
+            return [...tokens].reverse();
         }
+        return tokens;
     }
-    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;
+    /**
+     * Gets all tokens currently managed by the revenue manager contract
+     * @dev Uses multicall to batch requests for better performance
+     * @param sortByDesc - Optional boolean to sort tokens in descending order (default: false)
+     * @returns Promise<Array<{flaunch: Address, tokenId: bigint}>> - Array of token objects containing flaunch address and token ID
+     */
+    async allTokensInManager(sortByDesc = false) {
+        const count = await this.tokensCount();
+        const multicall = new ReadMulticall(this.drift);
+        let calldatas = Array.from({ length: Number(count) }, (_, i) => this.contract.encodeFunctionData("internalIds", {
+            _internalId: BigInt(i + 1),
+        }));
+        // Reverse the array if sortByDesc is true
+        if (sortByDesc) {
+            calldatas = calldatas.reverse();
         }
+        const result = await multicall.aggregate3(calldatas.map((calldata) => ({
+            target: this.contract.address,
+            callData: calldata,
+        })));
+        return result.map((r) => this.contract.decodeFunctionReturn("internalIds", r.returnData));
     }
-};
-/**
- * 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);
+}
+class ReadWriteRevenueManager extends ReadRevenueManager {
+    constructor(address, drift$1 = drift.createDrift()) {
+        super(address, drift$1);
     }
-};
-/**
- * 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];
+    /**
+     * Allows the protocol recipient to claim the protocol's share of the revenue
+     * @returns Promise<TransactionResponse> - The transaction response
+     */
+    protocolClaim() {
+        return this.contract.write("claim", {});
     }
-    // Handle edge case where sqrt ratios are equal (division by zero)
-    if (sqrtRatioAX96 === sqrtRatioBX96) {
-        return 0n;
+    /**
+     * Allows the creator to claim their total share of the revenue from a revenue manager
+     * @returns Promise<TransactionResponse> - The transaction response
+     */
+    creatorClaim() {
+        return this.contract.write("claim", {});
+    }
+    /**
+     * Allows the creator to claim their share of the revenue from specific flaunch tokens
+     * @param flaunchTokens - The flaunch token ids to claim the revenue for
+     * @returns Promise<TransactionResponse> - The transaction response
+     */
+    creatorClaimForTokens(flaunchTokens) {
+        return this.contract.write("claim", {
+            _flaunchToken: flaunchTokens,
+        });
     }
-    const Q96 = 2n ** 96n;
-    const numerator = amount0 * sqrtRatioAX96 * sqrtRatioBX96;
-    const denominator = Q96 * (sqrtRatioBX96 - sqrtRatioAX96);
-    return numerator / denominator;
 }
+
+const TreasuryManagerAbi = [
+    {
+        type: "function",
+        name: "deposit",
+        inputs: [
+            {
+                name: "_flaunchToken",
+                type: "tuple",
+                internalType: "struct ITreasuryManager.FlaunchToken",
+                components: [
+                    {
+                        name: "flaunch",
+                        type: "address",
+                        internalType: "contract Flaunch",
+                    },
+                    { name: "tokenId", type: "uint256", internalType: "uint256" },
+                ],
+            },
+            { name: "_creator", type: "address", internalType: "address" },
+            { name: "_data", type: "bytes", internalType: "bytes" },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "initialize",
+        inputs: [
+            { name: "_owner", type: "address", internalType: "address" },
+            { name: "_data", type: "bytes", internalType: "bytes" },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "managerOwner",
+        inputs: [],
+        outputs: [{ name: "", type: "address", internalType: "address" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        name: "permissions",
+        inputs: [],
+        outputs: [
+            {
+                name: "",
+                type: "address",
+                internalType: "contract IManagerPermissions",
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        name: "rescue",
+        inputs: [
+            {
+                name: "_flaunchToken",
+                type: "tuple",
+                internalType: "struct ITreasuryManager.FlaunchToken",
+                components: [
+                    {
+                        name: "flaunch",
+                        type: "address",
+                        internalType: "contract Flaunch",
+                    },
+                    { name: "tokenId", type: "uint256", internalType: "uint256" },
+                ],
+            },
+            { name: "_recipient", type: "address", internalType: "address" },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "setPermissions",
+        inputs: [
+            { name: "_permissions", type: "address", internalType: "address" },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "transferManagerOwnership",
+        inputs: [
+            {
+                name: "_newManagerOwner",
+                type: "address",
+                internalType: "address",
+            },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+];
+
 /**
- * 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
+ * Client for interacting with the TreasuryManager contract in read-only mode
+ * Provides methods to query permissions and manager owner
  */
-function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
-    if (sqrtRatioAX96 > sqrtRatioBX96) {
-        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+class ReadTreasuryManager {
+    /**
+     * Creates a new ReadTreasuryManager instance
+     * @param address - The address of the TreasuryManager contract
+     * @param drift - Optional drift instance for contract interactions (creates new instance if not provided)
+     * @throws Error if address is not provided
+     */
+    constructor(address, drift$1 = drift.createDrift()) {
+        if (!address) {
+            throw new Error("Address is required");
+        }
+        this.contract = drift$1.contract({
+            abi: TreasuryManagerAbi,
+            address,
+        });
     }
-    // Handle edge case where sqrt ratios are equal (division by zero)
-    if (sqrtRatioAX96 === sqrtRatioBX96) {
-        return 0n;
+    /**
+     * Gets the permissions contract address
+     * @returns Promise<Address> - The address of the permissions contract
+     */
+    permissions() {
+        return this.contract.read("permissions");
+    }
+    /**
+     * Gets the manager owner address
+     * @returns Promise<Address> - The address of the manager owner
+     */
+    managerOwner() {
+        return this.contract.read("managerOwner");
     }
-    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
+ * Extended client for interacting with the TreasuryManager contract with write capabilities
+ * Provides methods to deposit tokens, set permissions, and transfer ownership
  */
-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];
+class ReadWriteTreasuryManager extends ReadTreasuryManager {
+    constructor(address, drift$1 = drift.createDrift()) {
+        super(address, drift$1);
     }
-    let amount0 = 0n;
-    let amount1 = 0n;
-    if (sqrtRatioCurrentX96 <= sqrtRatioAX96) {
-        // Current price is below the range, only token0 needed
-        amount0 = getAmount0ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, params.liquidity);
+    /**
+     * Deposits a flaunch token to the treasury
+     * @param flaunchToken - The flaunch token to deposit
+     * @param creator - The address of the creator
+     * @param data - Additional data for the deposit
+     * @returns Promise<void>
+     */
+    deposit(flaunchToken, creator, data) {
+        return this.contract.write("deposit", {
+            _flaunchToken: flaunchToken,
+            _creator: creator,
+            _data: data,
+        });
     }
-    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);
+    /**
+     * Sets the permissions contract address
+     * @param permissions - The address of the new permissions contract
+     * @returns Promise<void>
+     */
+    setPermissions(permissions) {
+        return this.contract.write("setPermissions", {
+            _permissions: permissions,
+        });
     }
-    else {
-        // Current price is above the range, only token1 needed
-        amount1 = getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, params.liquidity);
+    /**
+     * Transfers the manager ownership to a new address
+     * @param newManagerOwner - The address of the new manager owner
+     * @returns Promise<void>
+     */
+    transferManagerOwnership(newManagerOwner) {
+        return this.contract.write("transferManagerOwnership", {
+            _newManagerOwner: newManagerOwner,
+        });
     }
-    return { amount0, amount1 };
-};
+}
 
 const chainIdToChain = {
     [base.id]: base,
@@ -26352,6 +26416,50 @@ class ReadFlaunchSDK {
         }
         return poll();
     }
+    /**
+     * Parses a transaction to extract PoolCreated event data
+     * @param txHash - The transaction hash to parse
+     * @returns PoolCreated event parameters or null if not found
+     */
+    async getPoolCreatedFromTx(txHash) {
+        if (!this.publicClient) {
+            throw new Error("Public client is required to fetch transaction data");
+        }
+        // Get transaction receipt
+        const receipt = await this.publicClient.getTransactionReceipt({
+            hash: txHash,
+        });
+        if (!receipt) {
+            throw new Error(`Transaction not found: ${txHash}`);
+        }
+        // Find PoolCreated event in logs by trying to decode each log
+        // Using V1_2 ABI which is compatible with all versions (V1_2 has extra fields that are optional)
+        for (const log of receipt.logs) {
+            try {
+                const decodedLog = viem.decodeEventLog({
+                    abi: FlaunchPositionManagerV1_2Abi,
+                    data: log.data,
+                    topics: log.topics,
+                });
+                if (decodedLog.eventName === "PoolCreated") {
+                    return {
+                        poolId: decodedLog.args._poolId,
+                        memecoin: decodedLog.args._memecoin,
+                        memecoinTreasury: decodedLog.args._memecoinTreasury,
+                        tokenId: decodedLog.args._tokenId,
+                        currencyFlipped: decodedLog.args._currencyFlipped,
+                        flaunchFee: decodedLog.args._flaunchFee,
+                        params: decodedLog.args._params,
+                    };
+                }
+            }
+            catch (error) {
+                // Not a PoolCreated event or decoding failed, continue to next log
+                continue;
+            }
+        }
+        return null;
+    }
     /**
      * Watches for pool swap events
      * @param params - Parameters for watching pool swaps including optional coin filter
@@ -27373,6 +27481,25 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         const hash = await this.readWriteFlaunchZap.deployStakingManager(params);
         return await this.readWriteTreasuryManagerFactory.getManagerDeployedAddressFromTx(hash);
     }
+    /**
+     * Deploys a new BuyBack manager
+     * @param params - Parameters for deploying the BuyBack manager
+     * @param params.managerOwner - The address of the manager owner
+     * @param params.creatorSharePercent - The % share that a creator will earn from their token (0-100)
+     * @param params.ownerSharePercent - The % share that the manager owner will earn from their token (0-100)
+     * @param params.buyBackPoolKey - The Uniswap V4 pool key configuration for the buyback pool
+     * @param params.buyBackPoolKey.currency0 - The lower currency of the pool (sorted numerically)
+     * @param params.buyBackPoolKey.currency1 - The higher currency of the pool (sorted numerically)
+     * @param params.buyBackPoolKey.fee - The pool LP fee, capped at 1_000_000
+     * @param params.buyBackPoolKey.tickSpacing - Tick spacing for the pool
+     * @param params.buyBackPoolKey.hooks - The hooks address of the pool
+     * @param params.permissions - The permissions for the BuyBack manager
+     * @returns Address of the deployed BuyBack manager
+     */
+    async deployBuyBackManager(params) {
+        const hash = await this.readWriteFlaunchZap.deployBuyBackManager(params);
+        return await this.readWriteTreasuryManagerFactory.getManagerDeployedAddressFromTx(hash);
+    }
     /**
      * Creates a new Flaunch on the specified version
      * @param params - Parameters for creating the Flaunch
@@ -32016,6 +32143,7 @@ exports.BidWallAddress = BidWallAddress;
 exports.BidWallV1_1Abi = BidWallV1_1Abi;
 exports.BidWallV1_1Address = BidWallV1_1Address;
 exports.BidwallAbi = BidwallAbi;
+exports.BuyBackManagerAddress = BuyBackManagerAddress;
 exports.ClankerWorldVerifierAddress = ClankerWorldVerifierAddress;
 exports.ClosedPermissionsAddress = ClosedPermissionsAddress;
 exports.DopplerVerifierAddress = DopplerVerifierAddress;