@flaunch/sdk 0.7.1 → 0.8.0

package/dist/index.cjs.js

@@ -5315,6 +5315,7 @@ const sourceId = 5; // goerli
     testnet: true,
 });
 
+// doesn't use FeeEscrow
 const FlaunchPositionManagerAddress = {
     [base.id]: "0x51Bba15255406Cfe7099a42183302640ba7dAFDC",
     [baseSepolia.id]: "0x9A7059cA00dA92843906Cb4bCa1D005cE848AFdC",
@@ -5323,6 +5324,18 @@ const FlaunchPositionManagerV1_1Address = {
     [base.id]: "0xf785bb58059fab6fb19bdda2cb9078d9e546efdc",
     [baseSepolia.id]: "0x24347e0dd16357059abfc1b321df354873552fdc",
 };
+const AnyPositionManagerAddress = {
+    [base.id]: "0x69a96de474521f7c6c0be3ea0498e5cf2f0565dc",
+    [baseSepolia.id]: "0xe999c5676b0e0f83292074441292f4b3b11d65dc",
+};
+const FeeEscrowAddress = {
+    [base.id]: "0x72e6f7948b1B1A343B477F39aAbd2E35E6D27dde",
+    [baseSepolia.id]: "0x73E27908b7d35A9251a54799A8ef4C17e4ED9FF9",
+};
+const ReferralEscrowAddress = {
+    [base.id]: "0xBD39c7Be6D98BD1a3e4Ad482baF99d738947fE55",
+    [baseSepolia.id]: "0x0651cadC51b6a13CB3465C134A22154a2b633779",
+};
 const FLETHAddress = {
     [base.id]: "0x000000000D564D5be76f7f0d28fE52605afC7Cf8",
     [baseSepolia.id]: "0x79FC52701cD4BE6f9Ba9aDC94c207DE37e3314eb",
@@ -7384,9 +7397,7 @@ const ETH = viem.zeroAddress;
 const ethToMemecoin = (params) => {
     const flETH = FLETHAddress[params.chainId];
     const flETHHooks = FLETHHooksAddress[params.chainId];
-    const flaunchHooks = params.isV1Coin
-        ? FlaunchPositionManagerAddress[params.chainId]
-        : FlaunchPositionManagerV1_1Address[params.chainId];
+    const flaunchHooks = params.positionManagerAddress;
     // Determine actions based on swapType
     const v4Actions = ("0x" +
         (params.swapType === "EXACT_IN"
@@ -7521,9 +7532,7 @@ const ethToMemecoin = (params) => {
 const memecoinToEthWithPermit2 = (params) => {
     const flETH = FLETHAddress[params.chainId];
     const flETHHooks = FLETHHooksAddress[params.chainId];
-    const flaunchHooks = params.isV1Coin
-        ? FlaunchPositionManagerAddress[params.chainId]
-        : FlaunchPositionManagerV1_1Address[params.chainId];
+    const flaunchHooks = params.positionManagerAddress;
     const v4Actions = ("0x" +
         V4Actions.SWAP_EXACT_IN +
         V4Actions.SETTLE_ALL +
@@ -7971,6 +7980,13 @@ class ReadInitialPrice {
             _initialPriceParams: params.initialPriceParams,
         });
     }
+    getSqrtPriceX96(params) {
+        return this.contract.read("getSqrtPriceX96", {
+            _flipped: !params.isFLETHZero,
+            _initialPriceParams: params.initialPriceParams,
+            0: viem.zeroAddress, // sender
+        });
+    }
 }
 
 class ReadFlaunchPositionManager {
@@ -7991,6 +8007,16 @@ class ReadFlaunchPositionManager {
         });
         return poolKey.tickSpacing !== 0;
     }
+    /**
+     * Gets the ETH balance for the creator to claim
+     * @param creator - The address of the creator to check
+     * @returns The balance of the creator
+     */
+    creatorBalance(creator) {
+        return this.contract.read("balances", {
+            _recipient: creator,
+        });
+    }
     async getFlaunchingFee(params) {
         const readInitialPrice = new ReadInitialPrice(await this.contract.read("initialPrice"), this.drift);
         const flaunchingFee = await readInitialPrice.getFlaunchingFee(params);
@@ -8188,6 +8214,78 @@ class ReadFlaunchPositionManager {
         };
     }
 }
+class ReadWriteFlaunchPositionManager extends ReadFlaunchPositionManager {
+    constructor(address, drift$1 = drift.createDrift()) {
+        super(address, drift$1);
+    }
+    async flaunch({ name, symbol, tokenUri, fairLaunchPercent, initialMarketCapUSD, creator, creatorFeeAllocationPercent, flaunchAt, }) {
+        const initialMCapInUSDCWei = viem.parseUnits(initialMarketCapUSD.toString(), 6);
+        const initialPriceParams = viem.encodeAbiParameters([
+            {
+                type: "uint256",
+            },
+        ], [initialMCapInUSDCWei]);
+        const fairLaunchInBps = BigInt(fairLaunchPercent * 100);
+        const creatorFeeAllocationInBps = creatorFeeAllocationPercent * 100;
+        let sender = viem.zeroAddress;
+        if (this.drift.adapter.getSignerAddress) {
+            sender = await this.drift.adapter.getSignerAddress();
+        }
+        const flaunchingFee = await this.getFlaunchingFee({
+            sender,
+            initialPriceParams,
+            slippagePercent: 5,
+        });
+        return this.contract.write("flaunch", {
+            _params: {
+                name,
+                symbol,
+                tokenUri,
+                initialTokenFairLaunch: (this.TOTAL_SUPPLY * fairLaunchInBps) / 10000n,
+                premineAmount: 0n,
+                creator,
+                creatorFeeAllocation: creatorFeeAllocationInBps,
+                flaunchAt: flaunchAt ?? 0n,
+                initialPriceParams,
+                feeCalculatorParams: "0x",
+            },
+        }, {
+            value: flaunchingFee,
+            onMined: async () => {
+                if (this.pollPoolCreatedNow) {
+                    await this.pollPoolCreatedNow();
+                }
+            },
+        });
+    }
+    async flaunchIPFS({ name, symbol, fairLaunchPercent, initialMarketCapUSD, creator, creatorFeeAllocationPercent, flaunchAt, metadata, pinataConfig, }) {
+        const tokenUri = await generateTokenUri(name, {
+            metadata,
+            pinataConfig,
+        });
+        return this.flaunch({
+            name,
+            symbol,
+            tokenUri,
+            fairLaunchPercent,
+            initialMarketCapUSD,
+            creator,
+            creatorFeeAllocationPercent,
+            flaunchAt,
+        });
+    }
+    /**
+     * Withdraws the creator's share of the revenue
+     * @param recipient - The address to withdraw the revenue to
+     * @returns Transaction response
+     */
+    withdrawFees(recipient) {
+        return this.contract.write("withdrawFees", {
+            _recipient: recipient,
+            _unwrap: true,
+        });
+    }
+}
 
 const bytes32ToUint256 = (value) => {
     return viem.hexToBigInt(value);
@@ -9501,6 +9599,9 @@ class ReadFairLaunch {
             address,
         });
     }
+    fairLaunchDuration({ poolId }) {
+        return 30 * 60; // 30 minutes
+    }
     /**
      * Gets information about a fair launch for a specific pool
      * @param poolId - The ID of the pool
@@ -9980,137 +10081,6 @@ class ReadBidWall {
     }
 }
 
-const FastFlaunchZapAbi = [
-    {
-        inputs: [
-            {
-                internalType: "contract PositionManager",
-                name: "_positionManager",
-                type: "address",
-            },
-        ],
-        stateMutability: "nonpayable",
-        type: "constructor",
-    },
-    {
-        inputs: [],
-        name: "CREATOR_FEE_ALLOCATION",
-        outputs: [{ internalType: "uint24", name: "", type: "uint24" }],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "FAIR_LAUNCH_SUPPLY",
-        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "USDC_MARKET_CAP",
-        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                components: [
-                    { internalType: "string", name: "name", type: "string" },
-                    { internalType: "string", name: "symbol", type: "string" },
-                    { internalType: "string", name: "tokenUri", type: "string" },
-                    { internalType: "address", name: "creator", type: "address" },
-                ],
-                internalType: "struct FastFlaunchZap.FastFlaunchParams",
-                name: "_params",
-                type: "tuple",
-            },
-        ],
-        name: "flaunch",
-        outputs: [{ internalType: "address", name: "memecoin_", type: "address" }],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "positionManager",
-        outputs: [
-            { internalType: "contract PositionManager", name: "", type: "address" },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-];
-
-/**
- * Base client for interacting with the FastFlaunchZap contract in read-only mode
- * Provides basic contract initialization
- */
-class ReadFastFlaunchZap {
-    /**
-     * Creates a new ReadFastFlaunchZap instance
-     * @param address - The address of the FastFlaunchZap 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: FastFlaunchZapAbi,
-            address,
-        });
-    }
-}
-/**
- * Extended client for interacting with the FastFlaunchZap contract with write capabilities
- * Provides methods to create new fast flaunches with direct URI or IPFS metadata
- */
-class ReadWriteFastFlaunchZap extends ReadFastFlaunchZap {
-    /**
-     * Creates a new ReadWriteFastFlaunchZap instance
-     * @param address - The address of the FastFlaunchZap contract
-     * @param drift - Optional drift instance for contract interactions (creates new instance if not provided)
-     */
-    constructor(address, drift$1 = drift.createDrift()) {
-        super(address, drift$1);
-    }
-    /**
-     * Creates a new fast flaunch with direct token URI
-     * @param params - Parameters for the fast flaunch including name, symbol, tokenUri, and creator
-     * @returns Transaction response for the flaunch creation
-     */
-    fastFlaunch({ name, symbol, tokenUri, creator }) {
-        return this.contract.write("flaunch", {
-            _params: {
-                name,
-                symbol,
-                tokenUri,
-                creator,
-            },
-        });
-    }
-    /**
-     * Creates a new fast flaunch with metadata stored on IPFS
-     * @param params - Parameters for the fast flaunch including name, symbol, creator, metadata, and Pinata config
-     * @returns Promise resolving to the transaction response for the flaunch creation
-     */
-    async fastFlaunchIPFS({ name, symbol, creator, metadata, pinataConfig, }) {
-        const tokenUri = await generateTokenUri(name, {
-            metadata,
-            pinataConfig,
-        });
-        return this.fastFlaunch({
-            name,
-            symbol,
-            tokenUri,
-            creator,
-        });
-    }
-}
-
 const FlaunchZapAbi = [
     {
         inputs: [
@@ -13581,6 +13551,13 @@ class ReadMemecoin {
     tokenURI() {
         return this.contract.read("tokenURI");
     }
+    /**
+     * Gets the total supply of the token
+     * @returns Promise<bigint> - The total supply
+     */
+    totalSupply() {
+        return this.contract.read("totalSupply");
+    }
     /**
      * Gets the token balance of a specific user
      * @param user - The address of the user to check
@@ -13963,10 +13940,10 @@ class ReadQuoter {
      * Gets a quote for selling an exact amount of tokens for ETH
      * @param coinAddress - The address of the token to sell
      * @param amountIn - The exact amount of tokens to sell
-     * @param isV1Coin - Optional flag to specify if token is V1. If not provided, V1.1 is assumed
+     * @param positionManagerAddress - The address of the position manager to use
      * @returns Promise<bigint> - The expected amount of ETH to receive
      */
-    async getSellQuoteExactInput(coinAddress, amountIn, isV1Coin) {
+    async getSellQuoteExactInput(coinAddress, amountIn, positionManagerAddress) {
         const res = await this.contract.simulateWrite("quoteExactInput", {
             params: {
                 exactAmount: amountIn,
@@ -13975,9 +13952,7 @@ class ReadQuoter {
                     {
                         fee: 0,
                         tickSpacing: 60,
-                        hooks: isV1Coin
-                            ? FlaunchPositionManagerAddress[this.chainId]
-                            : FlaunchPositionManagerV1_1Address[this.chainId],
+                        hooks: positionManagerAddress,
                         hookData: "0x",
                         intermediateCurrency: FLETHAddress[this.chainId],
                     },
@@ -13997,10 +13972,10 @@ class ReadQuoter {
      * Gets a quote for buying tokens with an exact amount of ETH
      * @param coinAddress - The address of the token to buy
      * @param ethIn - The exact amount of ETH to spend
-     * @param isV1Coin - Optional flag to specify if token is V1. If not provided, V1.1 is assumed
+     * @param positionManagerAddress - The address of the position manager to use
      * @returns Promise<bigint> - The expected amount of tokens to receive
      */
-    async getBuyQuoteExactInput(coinAddress, ethIn, isV1Coin) {
+    async getBuyQuoteExactInput(coinAddress, ethIn, positionManagerAddress) {
         const res = await this.contract.simulateWrite("quoteExactInput", {
             params: {
                 exactAmount: ethIn,
@@ -14016,9 +13991,7 @@ class ReadQuoter {
                     {
                         fee: 0,
                         tickSpacing: 60,
-                        hooks: isV1Coin
-                            ? FlaunchPositionManagerAddress[this.chainId]
-                            : FlaunchPositionManagerV1_1Address[this.chainId],
+                        hooks: positionManagerAddress,
                         hookData: "0x",
                         intermediateCurrency: coinAddress,
                     },
@@ -14031,10 +14004,10 @@ class ReadQuoter {
      * Gets a quote for buying an exact amount of tokens with ETH
      * @param coinAddress - The address of the token to buy
      * @param coinOut - The exact amount of tokens to receive
-     * @param isV1Coin - Optional flag to specify if token is V1. If not provided, V1.1 is assumed
+     * @param positionManagerAddress - The address of the position manager to use
      * @returns Promise<bigint> - The required amount of ETH to spend
      */
-    async getBuyQuoteExactOutput(coinAddress, coinOut, isV1Coin) {
+    async getBuyQuoteExactOutput(coinAddress, coinOut, positionManagerAddress) {
         const res = await this.contract.simulateWrite("quoteExactOutput", {
             params: {
                 path: [
@@ -14049,9 +14022,7 @@ class ReadQuoter {
                         intermediateCurrency: FLETHAddress[this.chainId],
                         fee: 0,
                         tickSpacing: 60,
-                        hooks: isV1Coin
-                            ? FlaunchPositionManagerAddress[this.chainId]
-                            : FlaunchPositionManagerV1_1Address[this.chainId],
+                        hooks: positionManagerAddress,
                         hookData: "0x",
                     },
                 ],
@@ -14654,31 +14625,2343 @@ class ReadWritePermit2 extends ReadPermit2 {
     }
 }
 
-const BidWallV1_1Abi = [
+const AnyPositionManagerAbi = [
     {
         inputs: [
-            { internalType: "address", name: "_nativeToken", type: "address" },
-            { internalType: "address", name: "_poolManager", type: "address" },
-            { internalType: "address", name: "_protocolOwner", type: "address" },
+            {
+                components: [
+                    { internalType: "address", name: "nativeToken", type: "address" },
+                    {
+                        internalType: "contract IPoolManager",
+                        name: "poolManager",
+                        type: "address",
+                    },
+                    {
+                        components: [
+                            { internalType: "uint24", name: "swapFee", type: "uint24" },
+                            { internalType: "uint24", name: "referrer", type: "uint24" },
+                            { internalType: "uint24", name: "protocol", type: "uint24" },
+                            { internalType: "bool", name: "active", type: "bool" },
+                        ],
+                        internalType: "struct FeeDistributor.FeeDistribution",
+                        name: "feeDistribution",
+                        type: "tuple",
+                    },
+                    {
+                        internalType: "contract IInitialPrice",
+                        name: "initialPrice",
+                        type: "address",
+                    },
+                    { internalType: "address", name: "protocolOwner", type: "address" },
+                    {
+                        internalType: "address",
+                        name: "protocolFeeRecipient",
+                        type: "address",
+                    },
+                    { internalType: "address", name: "flayGovernance", type: "address" },
+                    { internalType: "address", name: "feeEscrow", type: "address" },
+                    {
+                        internalType: "contract FeeExemptions",
+                        name: "feeExemptions",
+                        type: "address",
+                    },
+                    {
+                        internalType: "contract TreasuryActionManager",
+                        name: "actionManager",
+                        type: "address",
+                    },
+                    { internalType: "address", name: "bidWall", type: "address" },
+                ],
+                internalType: "struct AnyPositionManager.ConstructorParams",
+                name: "params",
+                type: "tuple",
+            },
         ],
         stateMutability: "nonpayable",
         type: "constructor",
     },
-    { inputs: [], name: "AccessControlBadConfirmation", type: "error" },
-    {
-        inputs: [
-            { internalType: "address", name: "account", type: "address" },
-            { internalType: "bytes32", name: "neededRole", type: "bytes32" },
-        ],
-        name: "AccessControlUnauthorizedAccount",
-        type: "error",
-    },
+    { inputs: [], name: "AlreadyFlaunched", type: "error" },
     { inputs: [], name: "AlreadyInitialized", type: "error" },
+    { inputs: [], name: "CallerIsNotBidWall", type: "error" },
     { inputs: [], name: "CallerIsNotCreator", type: "error" },
-    { inputs: [], name: "NewOwnerIsZeroAddress", type: "error" },
-    { inputs: [], name: "NoHandoverRequest", type: "error" },
-    { inputs: [], name: "NotPositionManager", type: "error" },
-    { inputs: [], name: "Unauthorized", type: "error" },
+    {
+        inputs: [{ internalType: "address", name: "_caller", type: "address" }],
+        name: "CallerNotCreator",
+        type: "error",
+    },
+    { inputs: [], name: "CannotBeInitializedDirectly", type: "error" },
+    { inputs: [], name: "HookNotImplemented", type: "error" },
+    { inputs: [], name: "InvalidPool", type: "error" },
+    { inputs: [], name: "LockFailure", type: "error" },
+    { inputs: [], name: "NewOwnerIsZeroAddress", type: "error" },
+    { inputs: [], name: "NoHandoverRequest", type: "error" },
+    { inputs: [], name: "NotPoolManager", type: "error" },
+    { inputs: [], name: "NotSelf", type: "error" },
+    { inputs: [], name: "ProtocolFeeInvalid", type: "error" },
+    { inputs: [], name: "RecipientZeroAddress", type: "error" },
+    { inputs: [], name: "ReferrerFeeInvalid", type: "error" },
+    { inputs: [], name: "SwapFeeInvalid", type: "error" },
+    { inputs: [], name: "Unauthorized", type: "error" },
+    {
+        inputs: [{ internalType: "PoolId", name: "_poolId", type: "bytes32" }],
+        name: "UnknownPool",
+        type: "error",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "uint24",
+                name: "_allocation",
+                type: "uint24",
+            },
+        ],
+        name: "CreatorFeeAllocationUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_feeCalculator",
+                type: "address",
+            },
+        ],
+        name: "FairLaunchFeeCalculatorUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_feeCalculator",
+                type: "address",
+            },
+        ],
+        name: "FeeCalculatorUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                components: [
+                    { internalType: "uint24", name: "swapFee", type: "uint24" },
+                    { internalType: "uint24", name: "referrer", type: "uint24" },
+                    { internalType: "uint24", name: "protocol", type: "uint24" },
+                    { internalType: "bool", name: "active", type: "bool" },
+                ],
+                indexed: false,
+                internalType: "struct FeeDistributor.FeeDistribution",
+                name: "_feeDistribution",
+                type: "tuple",
+            },
+        ],
+        name: "FeeDistributionUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "id", type: "bytes32" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "sender",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint128",
+                name: "feeAmount0",
+                type: "uint128",
+            },
+            {
+                indexed: false,
+                internalType: "uint128",
+                name: "feeAmount1",
+                type: "uint128",
+            },
+        ],
+        name: "HookFee",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "bytes32", name: "id", type: "bytes32" },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "sender",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "int128",
+                name: "amount0",
+                type: "int128",
+            },
+            {
+                indexed: false,
+                internalType: "int128",
+                name: "amount1",
+                type: "int128",
+            },
+            {
+                indexed: false,
+                internalType: "uint128",
+                name: "hookLPfeeAmount0",
+                type: "uint128",
+            },
+            {
+                indexed: false,
+                internalType: "uint128",
+                name: "hookLPfeeAmount1",
+                type: "uint128",
+            },
+        ],
+        name: "HookSwap",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_initialPrice",
+                type: "address",
+            },
+        ],
+        name: "InitialPriceUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_memecoin",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_creator",
+                type: "address",
+            },
+        ],
+        name: "MemecoinApproved",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "pendingOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipHandoverCanceled",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "pendingOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipHandoverRequested",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "oldOwner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "newOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipTransferred",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_memecoin",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_memecoinTreasury",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_tokenId",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "bool",
+                name: "_currencyFlipped",
+                type: "bool",
+            },
+            {
+                components: [
+                    { internalType: "address", name: "memecoin", type: "address" },
+                    { internalType: "address", name: "creator", type: "address" },
+                    {
+                        internalType: "uint24",
+                        name: "creatorFeeAllocation",
+                        type: "uint24",
+                    },
+                    { internalType: "bytes", name: "initialPriceParams", type: "bytes" },
+                    { internalType: "bytes", name: "feeCalculatorParams", type: "bytes" },
+                ],
+                indexed: false,
+                internalType: "struct AnyPositionManager.FlaunchParams",
+                name: "_params",
+                type: "tuple",
+            },
+        ],
+        name: "PoolCreated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                components: [
+                    { internalType: "uint24", name: "swapFee", type: "uint24" },
+                    { internalType: "uint24", name: "referrer", type: "uint24" },
+                    { internalType: "uint24", name: "protocol", type: "uint24" },
+                    { internalType: "bool", name: "active", type: "bool" },
+                ],
+                indexed: false,
+                internalType: "struct FeeDistributor.FeeDistribution",
+                name: "_feeDistribution",
+                type: "tuple",
+            },
+        ],
+        name: "PoolFeeDistributionUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_donateAmount",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_creatorAmount",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_bidWallAmount",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_governanceAmount",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_protocolAmount",
+                type: "uint256",
+            },
+        ],
+        name: "PoolFeesDistributed",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount0",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount1",
+                type: "uint256",
+            },
+        ],
+        name: "PoolFeesReceived",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "bool",
+                name: "zeroForOne",
+                type: "bool",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount0",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount1",
+                type: "uint256",
+            },
+        ],
+        name: "PoolFeesSwapped",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "uint160",
+                name: "_sqrtPriceX96",
+                type: "uint160",
+            },
+            { indexed: false, internalType: "int24", name: "_tick", type: "int24" },
+            {
+                indexed: false,
+                internalType: "uint24",
+                name: "_protocolFee",
+                type: "uint24",
+            },
+            {
+                indexed: false,
+                internalType: "uint24",
+                name: "_swapFee",
+                type: "uint24",
+            },
+            {
+                indexed: false,
+                internalType: "uint128",
+                name: "_liquidity",
+                type: "uint128",
+            },
+        ],
+        name: "PoolStateUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "flAmount0",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "flAmount1",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "flFee0",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "flFee1",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "ispAmount0",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "ispAmount1",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "ispFee0",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "ispFee1",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "uniAmount0",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "uniAmount1",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "uniFee0",
+                type: "int256",
+            },
+            {
+                indexed: false,
+                internalType: "int256",
+                name: "uniFee1",
+                type: "int256",
+            },
+        ],
+        name: "PoolSwap",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_referralEscrow",
+                type: "address",
+            },
+        ],
+        name: "ReferralEscrowUpdated",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_recipient",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_token",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount",
+                type: "uint256",
+            },
+        ],
+        name: "ReferrerFeePaid",
+        type: "event",
+    },
+    {
+        inputs: [],
+        name: "MAX_PROTOCOL_ALLOCATION",
+        outputs: [{ internalType: "uint24", name: "", type: "uint24" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "MIN_DISTRIBUTE_THRESHOLD",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "actionManager",
+        outputs: [
+            {
+                internalType: "contract TreasuryActionManager",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_sender", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "_key",
+                type: "tuple",
+            },
+            {
+                components: [
+                    { internalType: "int24", name: "tickLower", type: "int24" },
+                    { internalType: "int24", name: "tickUpper", type: "int24" },
+                    { internalType: "int256", name: "liquidityDelta", type: "int256" },
+                    { internalType: "bytes32", name: "salt", type: "bytes32" },
+                ],
+                internalType: "struct IPoolManager.ModifyLiquidityParams",
+                name: "",
+                type: "tuple",
+            },
+            { internalType: "BalanceDelta", name: "_delta", type: "int256" },
+            { internalType: "BalanceDelta", name: "_feesAccrued", type: "int256" },
+            { internalType: "bytes", name: "", type: "bytes" },
+        ],
+        name: "afterAddLiquidity",
+        outputs: [
+            { internalType: "bytes4", name: "selector_", type: "bytes4" },
+            { internalType: "BalanceDelta", name: "", type: "int256" },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_sender", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "_key",
+                type: "tuple",
+            },
+            { internalType: "uint256", name: "_amount0", type: "uint256" },
+            { internalType: "uint256", name: "_amount1", type: "uint256" },
+            { internalType: "bytes", name: "", type: "bytes" },
+        ],
+        name: "afterDonate",
+        outputs: [{ internalType: "bytes4", name: "selector_", type: "bytes4" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "",
+                type: "tuple",
+            },
+            { internalType: "uint160", name: "", type: "uint160" },
+            { internalType: "int24", name: "", type: "int24" },
+        ],
+        name: "afterInitialize",
+        outputs: [{ internalType: "bytes4", name: "", type: "bytes4" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_sender", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "_key",
+                type: "tuple",
+            },
+            {
+                components: [
+                    { internalType: "int24", name: "tickLower", type: "int24" },
+                    { internalType: "int24", name: "tickUpper", type: "int24" },
+                    { internalType: "int256", name: "liquidityDelta", type: "int256" },
+                    { internalType: "bytes32", name: "salt", type: "bytes32" },
+                ],
+                internalType: "struct IPoolManager.ModifyLiquidityParams",
+                name: "",
+                type: "tuple",
+            },
+            { internalType: "BalanceDelta", name: "_delta", type: "int256" },
+            { internalType: "BalanceDelta", name: "_feesAccrued", type: "int256" },
+            { internalType: "bytes", name: "", type: "bytes" },
+        ],
+        name: "afterRemoveLiquidity",
+        outputs: [
+            { internalType: "bytes4", name: "selector_", type: "bytes4" },
+            { internalType: "BalanceDelta", name: "", type: "int256" },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_sender", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "_key",
+                type: "tuple",
+            },
+            {
+                components: [
+                    { internalType: "bool", name: "zeroForOne", type: "bool" },
+                    { internalType: "int256", name: "amountSpecified", type: "int256" },
+                    {
+                        internalType: "uint160",
+                        name: "sqrtPriceLimitX96",
+                        type: "uint160",
+                    },
+                ],
+                internalType: "struct IPoolManager.SwapParams",
+                name: "_params",
+                type: "tuple",
+            },
+            { internalType: "BalanceDelta", name: "_delta", type: "int256" },
+            { internalType: "bytes", name: "_hookData", type: "bytes" },
+        ],
+        name: "afterSwap",
+        outputs: [
+            { internalType: "bytes4", name: "selector_", type: "bytes4" },
+            { internalType: "int128", name: "hookDeltaUnspecified_", type: "int128" },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_memecoin", type: "address" },
+            { internalType: "address", name: "_creator", type: "address" },
+        ],
+        name: "approveMemecoin",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "_memecoin", type: "address" }],
+        name: "approvedMemecoinToCreator",
+        outputs: [{ internalType: "address", name: "_creator", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "",
+                type: "tuple",
+            },
+            {
+                components: [
+                    { internalType: "int24", name: "tickLower", type: "int24" },
+                    { internalType: "int24", name: "tickUpper", type: "int24" },
+                    { internalType: "int256", name: "liquidityDelta", type: "int256" },
+                    { internalType: "bytes32", name: "salt", type: "bytes32" },
+                ],
+                internalType: "struct IPoolManager.ModifyLiquidityParams",
+                name: "",
+                type: "tuple",
+            },
+            { internalType: "bytes", name: "", type: "bytes" },
+        ],
+        name: "beforeAddLiquidity",
+        outputs: [{ internalType: "bytes4", name: "", type: "bytes4" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "",
+                type: "tuple",
+            },
+            { internalType: "uint256", name: "", type: "uint256" },
+            { internalType: "uint256", name: "", type: "uint256" },
+            { internalType: "bytes", name: "", type: "bytes" },
+        ],
+        name: "beforeDonate",
+        outputs: [{ internalType: "bytes4", name: "", type: "bytes4" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "",
+                type: "tuple",
+            },
+            { internalType: "uint160", name: "", type: "uint160" },
+        ],
+        name: "beforeInitialize",
+        outputs: [{ internalType: "bytes4", name: "", type: "bytes4" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "",
+                type: "tuple",
+            },
+            {
+                components: [
+                    { internalType: "int24", name: "tickLower", type: "int24" },
+                    { internalType: "int24", name: "tickUpper", type: "int24" },
+                    { internalType: "int256", name: "liquidityDelta", type: "int256" },
+                    { internalType: "bytes32", name: "salt", type: "bytes32" },
+                ],
+                internalType: "struct IPoolManager.ModifyLiquidityParams",
+                name: "",
+                type: "tuple",
+            },
+            { internalType: "bytes", name: "", type: "bytes" },
+        ],
+        name: "beforeRemoveLiquidity",
+        outputs: [{ internalType: "bytes4", name: "", type: "bytes4" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_sender", type: "address" },
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "_key",
+                type: "tuple",
+            },
+            {
+                components: [
+                    { internalType: "bool", name: "zeroForOne", type: "bool" },
+                    { internalType: "int256", name: "amountSpecified", type: "int256" },
+                    {
+                        internalType: "uint160",
+                        name: "sqrtPriceLimitX96",
+                        type: "uint160",
+                    },
+                ],
+                internalType: "struct IPoolManager.SwapParams",
+                name: "_params",
+                type: "tuple",
+            },
+            { internalType: "bytes", name: "_hookData", type: "bytes" },
+        ],
+        name: "beforeSwap",
+        outputs: [
+            { internalType: "bytes4", name: "selector_", type: "bytes4" },
+            {
+                internalType: "BeforeSwapDelta",
+                name: "beforeSwapDelta_",
+                type: "int256",
+            },
+            { internalType: "uint24", name: "", type: "uint24" },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "bidWall",
+        outputs: [{ internalType: "contract BidWall", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "cancelOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "_key",
+                type: "tuple",
+            },
+        ],
+        name: "closeBidWall",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "pendingOwner", type: "address" },
+        ],
+        name: "completeOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "fairLaunchFeeCalculator",
+        outputs: [
+            { internalType: "contract IFeeCalculator", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "feeCalculator",
+        outputs: [
+            { internalType: "contract IFeeCalculator", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "feeEscrow",
+        outputs: [
+            { internalType: "contract FeeEscrow", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "feeExemptions",
+        outputs: [
+            { internalType: "contract FeeExemptions", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "PoolId", name: "_poolId", type: "bytes32" },
+            { internalType: "uint256", name: "_amount", type: "uint256" },
+        ],
+        name: "feeSplit",
+        outputs: [
+            { internalType: "uint256", name: "bidWall_", type: "uint256" },
+            { internalType: "uint256", name: "creator_", type: "uint256" },
+            { internalType: "uint256", name: "protocol_", type: "uint256" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "address", name: "memecoin", type: "address" },
+                    { internalType: "address", name: "creator", type: "address" },
+                    {
+                        internalType: "uint24",
+                        name: "creatorFeeAllocation",
+                        type: "uint24",
+                    },
+                    { internalType: "bytes", name: "initialPriceParams", type: "bytes" },
+                    { internalType: "bytes", name: "feeCalculatorParams", type: "bytes" },
+                ],
+                internalType: "struct AnyPositionManager.FlaunchParams",
+                name: "_params",
+                type: "tuple",
+            },
+        ],
+        name: "flaunch",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "flaunchContract",
+        outputs: [
+            { internalType: "contract IAnyFlaunch", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "flayGovernance",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "bool", name: "_isFairLaunch", type: "bool" }],
+        name: "getFeeCalculator",
+        outputs: [
+            { internalType: "contract IFeeCalculator", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "bytes", name: "_initialPriceParams", type: "bytes" },
+        ],
+        name: "getFlaunchingMarketCap",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getHookPermissions",
+        outputs: [
+            {
+                components: [
+                    { internalType: "bool", name: "beforeInitialize", type: "bool" },
+                    { internalType: "bool", name: "afterInitialize", type: "bool" },
+                    { internalType: "bool", name: "beforeAddLiquidity", type: "bool" },
+                    { internalType: "bool", name: "afterAddLiquidity", type: "bool" },
+                    { internalType: "bool", name: "beforeRemoveLiquidity", type: "bool" },
+                    { internalType: "bool", name: "afterRemoveLiquidity", type: "bool" },
+                    { internalType: "bool", name: "beforeSwap", type: "bool" },
+                    { internalType: "bool", name: "afterSwap", type: "bool" },
+                    { internalType: "bool", name: "beforeDonate", type: "bool" },
+                    { internalType: "bool", name: "afterDonate", type: "bool" },
+                    { internalType: "bool", name: "beforeSwapReturnDelta", type: "bool" },
+                    { internalType: "bool", name: "afterSwapReturnDelta", type: "bool" },
+                    {
+                        internalType: "bool",
+                        name: "afterAddLiquidityReturnDelta",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bool",
+                        name: "afterRemoveLiquidityReturnDelta",
+                        type: "bool",
+                    },
+                ],
+                internalType: "struct Hooks.Permissions",
+                name: "",
+                type: "tuple",
+            },
+        ],
+        stateMutability: "pure",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "PoolId", name: "_poolId", type: "bytes32" }],
+        name: "getPoolFeeDistribution",
+        outputs: [
+            {
+                components: [
+                    { internalType: "uint24", name: "swapFee", type: "uint24" },
+                    { internalType: "uint24", name: "referrer", type: "uint24" },
+                    { internalType: "uint24", name: "protocol", type: "uint24" },
+                    { internalType: "bool", name: "active", type: "bool" },
+                ],
+                internalType: "struct FeeDistributor.FeeDistribution",
+                name: "feeDistribution_",
+                type: "tuple",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "initialPrice",
+        outputs: [
+            { internalType: "contract IInitialPrice", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "nativeToken",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "notifier",
+        outputs: [{ internalType: "contract Notifier", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "owner",
+        outputs: [{ internalType: "address", name: "result", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "pendingOwner", type: "address" },
+        ],
+        name: "ownershipHandoverExpiresAt",
+        outputs: [{ internalType: "uint256", name: "result", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "_poolKey",
+                type: "tuple",
+            },
+        ],
+        name: "poolFees",
+        outputs: [
+            {
+                components: [
+                    { internalType: "uint256", name: "amount0", type: "uint256" },
+                    { internalType: "uint256", name: "amount1", type: "uint256" },
+                ],
+                internalType: "struct InternalSwapPool.ClaimableFees",
+                name: "",
+                type: "tuple",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "_token", type: "address" }],
+        name: "poolKey",
+        outputs: [
+            {
+                components: [
+                    { internalType: "Currency", name: "currency0", type: "address" },
+                    { internalType: "Currency", name: "currency1", type: "address" },
+                    { internalType: "uint24", name: "fee", type: "uint24" },
+                    { internalType: "int24", name: "tickSpacing", type: "int24" },
+                    { internalType: "contract IHooks", name: "hooks", type: "address" },
+                ],
+                internalType: "struct PoolKey",
+                name: "",
+                type: "tuple",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "poolManager",
+        outputs: [
+            { internalType: "contract IPoolManager", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "referralEscrow",
+        outputs: [
+            { internalType: "contract ReferralEscrow", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "renounceOwnership",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "requestOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "contract IFeeCalculator",
+                name: "_feeCalculator",
+                type: "address",
+            },
+        ],
+        name: "setFairLaunchFeeCalculator",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "contract IFeeCalculator",
+                name: "_feeCalculator",
+                type: "address",
+            },
+        ],
+        name: "setFeeCalculator",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "uint24", name: "swapFee", type: "uint24" },
+                    { internalType: "uint24", name: "referrer", type: "uint24" },
+                    { internalType: "uint24", name: "protocol", type: "uint24" },
+                    { internalType: "bool", name: "active", type: "bool" },
+                ],
+                internalType: "struct FeeDistributor.FeeDistribution",
+                name: "_feeDistribution",
+                type: "tuple",
+            },
+        ],
+        name: "setFeeDistribution",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_flaunchContract", type: "address" },
+        ],
+        name: "setFlaunch",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_initialPrice", type: "address" },
+        ],
+        name: "setInitialPrice",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "PoolId", name: "_poolId", type: "bytes32" },
+            {
+                components: [
+                    { internalType: "uint24", name: "swapFee", type: "uint24" },
+                    { internalType: "uint24", name: "referrer", type: "uint24" },
+                    { internalType: "uint24", name: "protocol", type: "uint24" },
+                    { internalType: "bool", name: "active", type: "bool" },
+                ],
+                internalType: "struct FeeDistributor.FeeDistribution",
+                name: "_feeDistribution",
+                type: "tuple",
+            },
+        ],
+        name: "setPoolFeeDistribution",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint24", name: "_protocol", type: "uint24" }],
+        name: "setProtocolFeeDistribution",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address payable",
+                name: "_referralEscrow",
+                type: "address",
+            },
+        ],
+        name: "setReferralEscrow",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+        name: "transferOwnership",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
+        name: "unlockCallback",
+        outputs: [{ internalType: "bytes", name: "", type: "bytes" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    { stateMutability: "payable", type: "receive" },
+];
+
+class ReadAnyPositionManager {
+    constructor(address, drift$1 = drift.createDrift()) {
+        this.TOTAL_SUPPLY = 100n * 10n ** 27n; // 100 Billion tokens in wei
+        this.drift = drift$1;
+        if (!address) {
+            throw new Error("Address is required");
+        }
+        this.contract = drift$1.contract({
+            abi: AnyPositionManagerAbi,
+            address,
+        });
+    }
+    async isValidCoin(coinAddress) {
+        const poolKey = await this.contract.read("poolKey", {
+            _token: coinAddress,
+        });
+        return poolKey.tickSpacing !== 0;
+    }
+    async getFlaunchingFee(params) {
+        return 0n;
+    }
+    async watchPoolCreated({ onPoolCreated, startBlockNumber, }) {
+        let intervalId;
+        if (startBlockNumber !== undefined) {
+            onPoolCreated({
+                logs: [],
+                isFetchingFromStart: true,
+            });
+        }
+        let lastBlockNumber = startBlockNumber
+            ? startBlockNumber - 1n
+            : await this.drift.getBlockNumber();
+        const pollEvents = async () => {
+            try {
+                const currentBlockNumber = await this.drift.getBlockNumber();
+                if (currentBlockNumber > lastBlockNumber) {
+                    const _logs = await this.contract.getEvents("PoolCreated", {
+                        fromBlock: lastBlockNumber + 1n,
+                        toBlock: currentBlockNumber,
+                    });
+                    // Get timestamps for each log
+                    const logsWithTimestamps = await Promise.all([..._logs].reverse().map(async (log) => {
+                        const block = await this.drift.getBlock(log.blockNumber);
+                        return {
+                            ...log,
+                            timestamp: Number(block?.timestamp) * 1000, // convert to ms for js
+                        };
+                    }));
+                    if (logsWithTimestamps.length > 0) {
+                        onPoolCreated({
+                            logs: logsWithTimestamps,
+                            isFetchingFromStart: false,
+                        });
+                    }
+                    else {
+                        onPoolCreated({
+                            logs: [],
+                            isFetchingFromStart: false,
+                        });
+                    }
+                    lastBlockNumber = currentBlockNumber;
+                }
+            }
+            catch (error) {
+                console.error("Error polling events:", error);
+            }
+        };
+        intervalId = setInterval(pollEvents, 5000);
+        this.pollPoolCreatedNow = pollEvents;
+        // Return both cleanup function and immediate poll function
+        return {
+            cleanup: () => {
+                if (intervalId) {
+                    clearInterval(intervalId);
+                }
+                // Clear the pollNow function when cleaning up
+                this.pollPoolCreatedNow = undefined;
+            },
+            pollPoolCreatedNow: pollEvents,
+        };
+    }
+    async watchPoolSwap({ onPoolSwap, flETHIsCurrencyZero, startBlockNumber, filterByPoolId, }) {
+        let intervalId;
+        if (startBlockNumber !== undefined) {
+            onPoolSwap({
+                logs: [],
+                isFetchingFromStart: true,
+            });
+        }
+        let lastBlockNumber = startBlockNumber
+            ? startBlockNumber - 1n
+            : await this.drift.getBlockNumber();
+        const pollEvents = async () => {
+            try {
+                const currentBlockNumber = await this.drift.getBlockNumber();
+                if (currentBlockNumber > lastBlockNumber) {
+                    const _logs = await this.contract.getEvents("PoolSwap", {
+                        fromBlock: lastBlockNumber + 1n,
+                        toBlock: currentBlockNumber,
+                        filter: {
+                            poolId: filterByPoolId,
+                        },
+                    });
+                    // Get timestamps for each log
+                    const logsWithTimestamps = await Promise.all([..._logs].reverse().map(async (log) => {
+                        const block = await this.drift.getBlock(log.blockNumber);
+                        const timestamp = Number(block?.timestamp) * 1000; // convert to ms for js
+                        if (flETHIsCurrencyZero === undefined) {
+                            return {
+                                ...log,
+                                timestamp,
+                            };
+                        }
+                        const { flAmount0, flAmount1, flFee0, flFee1, ispAmount0, ispAmount1, ispFee0, ispFee1, uniAmount0, uniAmount1, uniFee0, uniFee1, } = log.args;
+                        const currency0Delta = flAmount0 + ispAmount0 + uniAmount0;
+                        const currency1Delta = flAmount1 + ispAmount1 + uniAmount1;
+                        const currency0Fees = flFee0 + ispFee0 + uniFee0;
+                        const currency1Fees = flFee1 + ispFee1 + uniFee1;
+                        let feesIsInFLETH;
+                        let swapType;
+                        if (flETHIsCurrencyZero) {
+                            swapType = currency0Delta < 0 ? "BUY" : "SELL";
+                            feesIsInFLETH = currency0Fees < 0;
+                        }
+                        else {
+                            swapType = currency1Delta < 0 ? "BUY" : "SELL";
+                            feesIsInFLETH = currency1Fees < 0;
+                        }
+                        const absCurrency0Delta = currency0Delta < 0 ? -currency0Delta : currency0Delta;
+                        const absCurrency1Delta = currency1Delta < 0 ? -currency1Delta : currency1Delta;
+                        const absCurrency0Fees = currency0Fees < 0 ? -currency0Fees : currency0Fees;
+                        const absCurrency1Fees = currency1Fees < 0 ? -currency1Fees : currency1Fees;
+                        const fees = {
+                            isInFLETH: feesIsInFLETH,
+                            amount: flETHIsCurrencyZero
+                                ? feesIsInFLETH
+                                    ? absCurrency0Fees
+                                    : absCurrency1Fees
+                                : feesIsInFLETH
+                                    ? absCurrency1Fees
+                                    : absCurrency0Fees,
+                        };
+                        if (swapType === "BUY") {
+                            return {
+                                ...log,
+                                timestamp,
+                                type: swapType,
+                                delta: {
+                                    coinsBought: flETHIsCurrencyZero
+                                        ? absCurrency1Delta - (!fees.isInFLETH ? fees.amount : 0n)
+                                        : absCurrency0Delta -
+                                            (!fees.isInFLETH ? fees.amount : 0n),
+                                    flETHSold: flETHIsCurrencyZero
+                                        ? absCurrency0Delta - (fees.isInFLETH ? fees.amount : 0n)
+                                        : absCurrency1Delta - (fees.isInFLETH ? fees.amount : 0n),
+                                    fees,
+                                },
+                            };
+                        }
+                        else {
+                            return {
+                                ...log,
+                                timestamp,
+                                type: swapType,
+                                delta: {
+                                    coinsSold: flETHIsCurrencyZero
+                                        ? absCurrency1Delta - (!fees.isInFLETH ? fees.amount : 0n)
+                                        : absCurrency0Delta -
+                                            (!fees.isInFLETH ? fees.amount : 0n),
+                                    flETHBought: flETHIsCurrencyZero
+                                        ? absCurrency0Delta - (fees.isInFLETH ? fees.amount : 0n)
+                                        : absCurrency1Delta - (fees.isInFLETH ? fees.amount : 0n),
+                                    fees,
+                                },
+                            };
+                        }
+                    }));
+                    if (logsWithTimestamps.length > 0) {
+                        onPoolSwap({
+                            logs: logsWithTimestamps,
+                            isFetchingFromStart: false,
+                        });
+                    }
+                    else {
+                        onPoolSwap({
+                            logs: [],
+                            isFetchingFromStart: false,
+                        });
+                    }
+                    lastBlockNumber = currentBlockNumber;
+                }
+            }
+            catch (error) {
+                console.error("Error polling events:", error);
+            }
+        };
+        intervalId = setInterval(pollEvents, 5000);
+        this.pollPoolSwapNow = pollEvents;
+        // Return both cleanup function and immediate poll function
+        return {
+            cleanup: () => {
+                if (intervalId) {
+                    clearInterval(intervalId);
+                }
+                // Clear the pollNow function when cleaning up
+                this.pollPoolSwapNow = undefined;
+            },
+            pollPoolSwapNow: pollEvents,
+        };
+    }
+}
+class ReadWriteAnyPositionManager extends ReadAnyPositionManager {
+    constructor(address, drift$1 = drift.createDrift()) {
+        super(address, drift$1);
+    }
+    async flaunch({ memecoin, initialMarketCapUSD, creator, creatorFeeAllocationPercent, }) {
+        const initialMCapInUSDCWei = viem.parseUnits(initialMarketCapUSD.toString(), 6);
+        const initialPriceParams = viem.encodeAbiParameters([
+            {
+                type: "uint256",
+            },
+        ], [initialMCapInUSDCWei]);
+        const creatorFeeAllocationInBps = creatorFeeAllocationPercent * 100;
+        return this.contract.write("flaunch", {
+            _params: {
+                memecoin,
+                creator,
+                creatorFeeAllocation: creatorFeeAllocationInBps,
+                initialPriceParams,
+                feeCalculatorParams: "0x",
+            },
+        }, {
+            onMined: async () => {
+                if (this.pollPoolCreatedNow) {
+                    await this.pollPoolCreatedNow();
+                }
+            },
+        });
+    }
+}
+
+const FeeEscrowAbi = [
+    {
+        inputs: [
+            { internalType: "address", name: "_nativeToken", type: "address" },
+            { internalType: "address", name: "_indexer", type: "address" },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    { inputs: [], name: "AlreadyInitialized", type: "error" },
+    { inputs: [], name: "InvalidRecipient", type: "error" },
+    { inputs: [], name: "NewOwnerIsZeroAddress", type: "error" },
+    { inputs: [], name: "NoHandoverRequest", type: "error" },
+    { inputs: [], name: "PoolIdNotIndexed", type: "error" },
+    { inputs: [], name: "RecipientZeroAddress", type: "error" },
+    { inputs: [], name: "Unauthorized", type: "error" },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_payee",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_token",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount",
+                type: "uint256",
+            },
+        ],
+        name: "Deposit",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "pendingOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipHandoverCanceled",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "pendingOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipHandoverRequested",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "oldOwner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "newOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipTransferred",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_sender",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_recipient",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_token",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount",
+                type: "uint256",
+            },
+        ],
+        name: "Withdrawal",
+        type: "event",
+    },
+    {
+        inputs: [
+            { internalType: "PoolId", name: "_poolId", type: "bytes32" },
+            { internalType: "address", name: "_recipient", type: "address" },
+            { internalType: "uint256", name: "_amount", type: "uint256" },
+        ],
+        name: "allocateFees",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "_recipient", type: "address" }],
+        name: "balances",
+        outputs: [{ internalType: "uint256", name: "_amount", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "cancelOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "pendingOwner", type: "address" },
+        ],
+        name: "completeOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "indexer",
+        outputs: [
+            { internalType: "contract IndexerSubscriber", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "nativeToken",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "owner",
+        outputs: [{ internalType: "address", name: "result", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "pendingOwner", type: "address" },
+        ],
+        name: "ownershipHandoverExpiresAt",
+        outputs: [{ internalType: "uint256", name: "result", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "renounceOwnership",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "requestOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "_indexer", type: "address" }],
+        name: "setIndexer",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "PoolId", name: "_poolId", type: "bytes32" }],
+        name: "totalFeesAllocated",
+        outputs: [{ internalType: "uint256", name: "_amount", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+        name: "transferOwnership",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_recipient", type: "address" },
+            { internalType: "bool", name: "_unwrap", type: "bool" },
+        ],
+        name: "withdrawFees",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    { stateMutability: "payable", type: "receive" },
+];
+
+/**
+ * Client for interacting with the FeeEscrow contract in read-only mode
+ * Provides methods to query fee balances and withdraw fees
+ */
+class ReadFeeEscrow {
+    /**
+     * Creates a new ReadFeeEscrow instance
+     * @param address - The address of the FeeEscrow 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: FeeEscrowAbi,
+            address,
+        });
+    }
+    /**
+     * Gets the claimable balance of fees for a creator
+     * @param creator - The address of the creator to check
+     * @returns Promise<bigint> - The claimable balance of fees
+     */
+    balances(creator) {
+        return this.contract.read("balances", {
+            _recipient: creator,
+        });
+    }
+}
+/**
+ * Extended client for interacting with the FeeEscrow contract with write capabilities
+ * Provides methods to withdraw fees
+ */
+class ReadWriteFeeEscrow extends ReadFeeEscrow {
+    constructor(address, drift$1 = drift.createDrift()) {
+        super(address, drift$1);
+    }
+    /**
+     * Withdraws fees as ETH to a recipient
+     * @param recipient - The address to receive the fees
+     * @param unwrap - Whether to unwrap the native token before sending
+     * @returns Promise<void>
+     */
+    withdrawFees(recipient) {
+        return this.contract.write("withdrawFees", {
+            _recipient: recipient,
+            _unwrap: true,
+        });
+    }
+}
+
+const ReferralEscrowAbi = [
+    {
+        inputs: [
+            { internalType: "address", name: "_nativeToken", type: "address" },
+            { internalType: "address", name: "_positionManager", type: "address" },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    { inputs: [], name: "AlreadyInitialized", type: "error" },
+    { inputs: [], name: "MismatchedTokensAndLimits", type: "error" },
+    { inputs: [], name: "NewOwnerIsZeroAddress", type: "error" },
+    { inputs: [], name: "NoHandoverRequest", type: "error" },
+    { inputs: [], name: "Unauthorized", type: "error" },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "pendingOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipHandoverCanceled",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "pendingOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipHandoverRequested",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "oldOwner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "newOwner",
+                type: "address",
+            },
+        ],
+        name: "OwnershipTransferred",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "PoolId",
+                name: "_poolId",
+                type: "bytes32",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "_user",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "_token",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount",
+                type: "uint256",
+            },
+        ],
+        name: "TokensAssigned",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "_user",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "_recipient",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "_token",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_amount",
+                type: "uint256",
+            },
+        ],
+        name: "TokensClaimed",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "_user",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "_token",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_tokenIn",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "_ethOut",
+                type: "uint256",
+            },
+        ],
+        name: "TokensSwapped",
+        type: "event",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_user", type: "address" },
+            { internalType: "address", name: "_token", type: "address" },
+        ],
+        name: "allocations",
+        outputs: [{ internalType: "uint256", name: "_amount", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "PoolId", name: "_poolId", type: "bytes32" },
+            { internalType: "address", name: "_user", type: "address" },
+            { internalType: "address", name: "_token", type: "address" },
+            { internalType: "uint256", name: "_amount", type: "uint256" },
+        ],
+        name: "assignTokens",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "cancelOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address[]", name: "_tokens", type: "address[]" },
+            {
+                internalType: "uint160[]",
+                name: "_sqrtPriceX96Limits",
+                type: "uint160[]",
+            },
+            { internalType: "address payable", name: "_recipient", type: "address" },
+        ],
+        name: "claimAndSwap",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address[]", name: "_tokens", type: "address[]" },
+            { internalType: "address payable", name: "_recipient", type: "address" },
+        ],
+        name: "claimTokens",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "pendingOwner", type: "address" },
+        ],
+        name: "completeOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "nativeToken",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "owner",
+        outputs: [{ internalType: "address", name: "result", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "pendingOwner", type: "address" },
+        ],
+        name: "ownershipHandoverExpiresAt",
+        outputs: [{ internalType: "uint256", name: "result", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "poolSwap",
+        outputs: [{ internalType: "contract PoolSwap", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "positionManager",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "renounceOwnership",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "requestOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "_poolSwap", type: "address" }],
+        name: "setPoolSwap",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+        name: "transferOwnership",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    { stateMutability: "payable", type: "receive" },
+];
+
+/**
+ * Client for interacting with the ReferralEscrow contract in read-only mode
+ * Provides methods to query token allocations
+ */
+class ReadReferralEscrow {
+    /**
+     * Creates a new ReadReferralEscrow instance
+     * @param address - The address of the ReferralEscrow 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: ReferralEscrowAbi,
+            address,
+        });
+    }
+    /**
+     * Gets the token allocation for a specific user and token
+     * @param user - The address of the user to check
+     * @param token - The address of the token
+     * @returns Promise<bigint> - The allocated token amount
+     */
+    allocations(user, token) {
+        return this.contract.read("allocations", {
+            _user: user,
+            _token: token,
+        });
+    }
+}
+/**
+ * Extended client for interacting with the ReferralEscrow contract with write capabilities
+ * Provides methods to claim tokens
+ */
+class ReadWriteReferralEscrow extends ReadReferralEscrow {
+    constructor(address, drift$1 = drift.createDrift()) {
+        super(address, drift$1);
+    }
+    /**
+     * Claims tokens for a recipient
+     * @param tokens - Array of token addresses to claim
+     * @param recipient - The address to receive the claimed tokens
+     * @returns Promise<void>
+     */
+    claimTokens(tokens, recipient) {
+        return this.contract.write("claimTokens", {
+            _tokens: tokens,
+            _recipient: recipient,
+        });
+    }
+}
+
+const BidWallV1_1Abi = [
+    {
+        inputs: [
+            { internalType: "address", name: "_nativeToken", type: "address" },
+            { internalType: "address", name: "_poolManager", type: "address" },
+            { internalType: "address", name: "_protocolOwner", type: "address" },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    { inputs: [], name: "AccessControlBadConfirmation", type: "error" },
+    {
+        inputs: [
+            { internalType: "address", name: "account", type: "address" },
+            { internalType: "bytes32", name: "neededRole", type: "bytes32" },
+        ],
+        name: "AccessControlUnauthorizedAccount",
+        type: "error",
+    },
+    { inputs: [], name: "AlreadyInitialized", type: "error" },
+    { inputs: [], name: "CallerIsNotCreator", type: "error" },
+    { inputs: [], name: "NewOwnerIsZeroAddress", type: "error" },
+    { inputs: [], name: "NoHandoverRequest", type: "error" },
+    { inputs: [], name: "NotPositionManager", type: "error" },
+    { inputs: [], name: "Unauthorized", type: "error" },
     {
         anonymous: false,
         inputs: [
@@ -17919,6 +20202,17 @@ class ReadWriteRevenueManager extends ReadRevenueManager {
     }
 }
 
+/**
+ * Enumeration of Flaunch contract versions
+ */
+exports.FlaunchVersion = void 0;
+(function (FlaunchVersion) {
+    FlaunchVersion["V1"] = "V1";
+    FlaunchVersion["V1_1"] = "V1_1";
+    FlaunchVersion["V1_1_1"] = "V1_1_1";
+    FlaunchVersion["ANY"] = "ANY";
+})(exports.FlaunchVersion || (exports.FlaunchVersion = {}));
+
 // our min/max tick range that is valid for the tick spacing (60)
 const TickFinder = {
     MIN_TICK: -887220,
@@ -18015,6 +20309,69 @@ const chainIdToChain = {
     [baseSepolia.id]: baseSepolia,
 };
 
+const FastFlaunchZapAbi = [
+    {
+        inputs: [
+            {
+                internalType: "contract PositionManager",
+                name: "_positionManager",
+                type: "address",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        inputs: [],
+        name: "CREATOR_FEE_ALLOCATION",
+        outputs: [{ internalType: "uint24", name: "", type: "uint24" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "FAIR_LAUNCH_SUPPLY",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "USDC_MARKET_CAP",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "string", name: "name", type: "string" },
+                    { internalType: "string", name: "symbol", type: "string" },
+                    { internalType: "string", name: "tokenUri", type: "string" },
+                    { internalType: "address", name: "creator", type: "address" },
+                ],
+                internalType: "struct FastFlaunchZap.FastFlaunchParams",
+                name: "_params",
+                type: "tuple",
+            },
+        ],
+        name: "flaunch",
+        outputs: [{ internalType: "address", name: "memecoin_", type: "address" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "positionManager",
+        outputs: [
+            { internalType: "contract PositionManager", name: "", type: "address" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+
 /**
  * Base class for interacting with Flaunch protocol in read-only mode
  */
@@ -18026,6 +20383,9 @@ class ReadFlaunchSDK {
         this.resolveIPFS = resolveIPFS;
         this.readPositionManager = new ReadFlaunchPositionManager(FlaunchPositionManagerAddress[this.chainId], drift$1);
         this.readPositionManagerV1_1 = new ReadFlaunchPositionManagerV1_1(FlaunchPositionManagerV1_1Address[this.chainId], drift$1);
+        this.readAnyPositionManager = new ReadAnyPositionManager(AnyPositionManagerAddress[this.chainId], drift$1);
+        this.readFeeEscrow = new ReadFeeEscrow(FeeEscrowAddress[this.chainId], drift$1);
+        this.readReferralEscrow = new ReadReferralEscrow(ReferralEscrowAddress[this.chainId], drift$1);
         this.readFlaunchZap = new ReadFlaunchZap(this.chainId, FlaunchZapAddress[this.chainId], drift$1);
         this.readPoolManager = new ReadPoolManager(PoolManagerAddress[this.chainId], drift$1);
         this.readStateView = new ReadStateView(StateViewAddress[this.chainId], drift$1);
@@ -18039,21 +20399,89 @@ class ReadFlaunchSDK {
         this.readPermit2 = new ReadPermit2(Permit2Address[this.chainId], drift$1);
     }
     /**
-     * Checks if a given coin address is a valid Flaunch coin (either V1 or V1.1)
+     * Checks if a given coin address is a valid Flaunch coin (supports all versions)
      * @param coinAddress - The address of the coin to check
      * @returns Promise<boolean> - True if the coin is valid, false otherwise
      */
     async isValidCoin(coinAddress) {
         return ((await this.readPositionManagerV1_1.isValidCoin(coinAddress)) ||
-            (await this.readPositionManager.isValidCoin(coinAddress)));
+            (await this.readPositionManager.isValidCoin(coinAddress)) ||
+            (await this.readAnyPositionManager.isValidCoin(coinAddress)));
     }
     /**
-     * Checks if a given coin address is a V1 Flaunch coin
+     * Determines the version of a Flaunch coin
      * @param coinAddress - The address of the coin to check
-     * @returns Promise<boolean> - True if the coin is V1, false if V1.1
+     * @returns Promise<FlaunchVersion> - The version of the coin
+     */
+    async getCoinVersion(coinAddress) {
+        if (await this.readPositionManager.isValidCoin(coinAddress)) {
+            return exports.FlaunchVersion.V1;
+        }
+        else if (await this.readPositionManagerV1_1.isValidCoin(coinAddress)) {
+            return exports.FlaunchVersion.V1_1;
+        }
+        else if (await this.readAnyPositionManager.isValidCoin(coinAddress)) {
+            return exports.FlaunchVersion.ANY;
+        }
+        throw new Error(`Unknown coin version for address: ${coinAddress}`);
+    }
+    // TODO: update these get functions to support V1.1.1 and new AnyPositionManager
+    /**
+     * Gets the position manager address for a given version
+     * @param version - The version to get the position manager address for
+     */
+    getPositionManager(version) {
+        switch (version) {
+            case exports.FlaunchVersion.V1:
+                return this.readPositionManager;
+            case exports.FlaunchVersion.V1_1:
+                return this.readPositionManagerV1_1;
+            case exports.FlaunchVersion.ANY:
+                return this.readAnyPositionManager;
+            default:
+                return this.readPositionManagerV1_1;
+        }
+    }
+    /**
+     * Gets the fair launch address for a given version
+     * @param version - The version to get the fair launch address for
+     */
+    getFairLaunch(version) {
+        switch (version) {
+            case exports.FlaunchVersion.V1:
+                return this.readFairLaunch;
+            case exports.FlaunchVersion.V1_1:
+                return this.readFairLaunchV1_1;
+            case exports.FlaunchVersion.ANY:
+                return this.readFairLaunchV1_1;
+            default:
+                return this.readFairLaunchV1_1;
+        }
+    }
+    /**
+     * Gets the bid wall address for a given version
+     * @param version - The version to get the bid wall address for
      */
-    async isV1Coin(coinAddress) {
-        return this.readPositionManager.isValidCoin(coinAddress);
+    getBidWall(version) {
+        switch (version) {
+            case exports.FlaunchVersion.V1:
+                return this.readBidWall;
+            case exports.FlaunchVersion.V1_1:
+                return this.readBidWallV1_1;
+            case exports.FlaunchVersion.ANY:
+                return this.readBidWallV1_1;
+            default:
+                return this.readBidWallV1_1;
+        }
+    }
+    getPositionManagerAddress(version) {
+        return this.getPositionManager(version).contract.address;
+    }
+    getFairLaunchAddress(version) {
+        return this.getFairLaunch(version).contract.address;
+    }
+    getBidWallAddress(version) {
+        return this.getBidWall(version).contract.address;
     }
     /**
      * Retrieves metadata for a given Flaunch coin
@@ -18177,69 +20605,45 @@ class ReadFlaunchSDK {
         return processedResults;
     }
     /**
-     * Watches for pool creation events on V1 contracts
-     * @param params - Parameters for watching pool creation
-     * @returns Subscription to pool creation events
-     */
-    watchPoolCreatedV1(params) {
-        return this.readPositionManager.watchPoolCreated(params);
-    }
-    /**
-     * Watches for pool creation events on V1.1 contracts
+     * Watches for pool creation events
      * @param params - Parameters for watching pool creation
+     * @param version - Version of Flaunch to use (defaults to V1_1)
      * @returns Subscription to pool creation events
      */
-    watchPoolCreated(params) {
-        return this.readPositionManagerV1_1.watchPoolCreated(params);
-    }
-    /**
-     * Polls for current pool creation events on V1 contracts
-     * @returns Current pool creation events or undefined if polling is not available
-     */
-    pollPoolCreatedNowV1() {
-        const poll = this.readPositionManager.pollPoolCreatedNow;
-        if (!poll) {
-            return undefined;
-        }
-        return poll();
+    watchPoolCreated(params, version = exports.FlaunchVersion.V1_1) {
+        return version === exports.FlaunchVersion.V1
+            ? this.readPositionManager.watchPoolCreated(params)
+            : this.readPositionManagerV1_1.watchPoolCreated(params);
     }
     /**
-     * Polls for current pool creation events on V1.1 contracts
+     * Polls for current pool creation events
+     * @param version - Version of Flaunch to use (defaults to V1_1)
      * @returns Current pool creation events or undefined if polling is not available
      */
-    pollPoolCreatedNow() {
-        const poll = this.readPositionManagerV1_1.pollPoolCreatedNow;
+    pollPoolCreatedNow(version = exports.FlaunchVersion.V1_1) {
+        const positionManager = version === exports.FlaunchVersion.V1
+            ? this.readPositionManager
+            : this.readPositionManagerV1_1;
+        const poll = positionManager.pollPoolCreatedNow;
         if (!poll) {
             return undefined;
         }
         return poll();
     }
     /**
-     * Watches for pool swap events on V1 contracts
-     * @param params - Parameters for watching pool swaps including optional coin filter
-     * @returns Subscription to pool swap events
-     */
-    async watchPoolSwapV1(params) {
-        return this.readPositionManager.watchPoolSwap({
-            ...params,
-            filterByPoolId: params.filterByCoin
-                ? await this.poolId(params.filterByCoin, true)
-                : undefined,
-            flETHIsCurrencyZero: params.filterByCoin
-                ? this.flETHIsCurrencyZero(params.filterByCoin)
-                : undefined,
-        });
-    }
-    /**
-     * Watches for pool swap events on V1.1 contracts
+     * Watches for pool swap events
      * @param params - Parameters for watching pool swaps including optional coin filter
+     * @param version - Version of Flaunch to use (defaults to V1_1)
      * @returns Subscription to pool swap events
      */
-    async watchPoolSwap(params) {
-        return this.readPositionManagerV1_1.watchPoolSwap({
+    async watchPoolSwap(params, version = exports.FlaunchVersion.V1_1) {
+        const positionManager = version === exports.FlaunchVersion.V1
+            ? this.readPositionManager
+            : this.readPositionManagerV1_1;
+        return positionManager.watchPoolSwap({
             ...params,
             filterByPoolId: params.filterByCoin
-                ? await this.poolId(params.filterByCoin)
+                ? await this.poolId(params.filterByCoin, version)
                 : undefined,
             flETHIsCurrencyZero: params.filterByCoin
                 ? this.flETHIsCurrencyZero(params.filterByCoin)
@@ -18247,22 +20651,15 @@ class ReadFlaunchSDK {
         });
     }
     /**
-     * Polls for current pool swap events on V1 contracts
-     * @returns Current pool swap events or undefined if polling is not available
-     */
-    pollPoolSwapNowV1() {
-        const poll = this.readPositionManager.pollPoolSwapNow;
-        if (!poll) {
-            return undefined;
-        }
-        return poll();
-    }
-    /**
-     * Polls for current pool swap events on V1.1 contracts
+     * Polls for current pool swap events
+     * @param version - Version of Flaunch to use (defaults to V1_1)
      * @returns Current pool swap events or undefined if polling is not available
      */
-    pollPoolSwapNow() {
-        const poll = this.readPositionManagerV1_1.pollPoolSwapNow;
+    pollPoolSwapNow(version = exports.FlaunchVersion.V1_1) {
+        const positionManager = version === exports.FlaunchVersion.V1
+            ? this.readPositionManager
+            : this.readPositionManagerV1_1;
+        const poll = positionManager.pollPoolSwapNow;
         if (!poll) {
             return undefined;
         }
@@ -18279,29 +20676,25 @@ class ReadFlaunchSDK {
     /**
      * Gets the current tick for a given coin's pool
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Promise<number> - The current tick of the pool
      */
-    async currentTick(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        const poolId = await this.poolId(coinAddress, isV1Coin);
+    async currentTick(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const poolId = await this.poolId(coinAddress, coinVersion);
         const poolState = await this.readStateView.poolSlot0({ poolId });
         return poolState.tick;
     }
     /**
      * Calculates the coin price in ETH based on the current tick
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Promise<string> - The price of the coin in ETH with 18 decimals precision
      */
-    async coinPriceInETH(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
+    async coinPriceInETH(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
         const isFLETHZero = this.flETHIsCurrencyZero(coinAddress);
-        const currentTick = await this.currentTick(coinAddress, isV1Coin);
+        const currentTick = await this.currentTick(coinAddress, coinVersion);
         const price = Math.pow(1.0001, currentTick);
         let ethPerCoin = 0;
         if (isFLETHZero) {
@@ -18312,6 +20705,27 @@ class ReadFlaunchSDK {
         }
         return ethPerCoin.toFixed(18);
     }
+    /**
+     * Calculates the coin price in USD based on the current ETH/USDC price
+     * @param coinAddress - The address of the coin
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
+     * @returns Promise<string> - The price of the coin in USD with 2 decimal precision
+     */
+    async coinPriceInUSD({ coinAddress, version, drift, }) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const ethPerCoin = await this.coinPriceInETH(coinAddress, coinVersion);
+        const ethPrice = await this.getETHUSDCPrice(drift);
+        return (parseFloat(ethPerCoin) * ethPrice).toFixed(2);
+    }
+    async coinMarketCapInUSD({ coinAddress, version, drift, }) {
+        const totalSupply = 100000000000; // 100 Billion tokens
+        const priceInUSD = await this.coinPriceInUSD({
+            coinAddress,
+            version,
+            drift,
+        });
+        return (parseFloat(priceInUSD) * totalSupply).toFixed(2);
+    }
     /**
      * Gets the current ETH/USDC price
      * @param drift - Optional drift instance to get price from Base Mainnet
@@ -18325,81 +20739,76 @@ class ReadFlaunchSDK {
         }
         return this.readQuoter.getETHUSDCPrice();
     }
+    async initialSqrtPriceX96(params) {
+        const initialMCapInUSDCWei = viem.parseUnits(params.initialMarketCapUSD.toString(), 6);
+        const initialPriceParams = viem.encodeAbiParameters([
+            {
+                type: "uint256",
+            },
+        ], [initialMCapInUSDCWei]);
+        const isFLETHZero = this.flETHIsCurrencyZero(params.coinAddress);
+        const initialPrice = new ReadInitialPrice(await this.readPositionManagerV1_1.initialPrice(), this.drift);
+        return initialPrice.getSqrtPriceX96({
+            isFLETHZero,
+            initialPriceParams,
+        });
+    }
     /**
      * Gets information about a fair launch for a given coin
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Fair launch information from the appropriate contract version
      */
-    async fairLaunchInfo(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        const poolId = await this.poolId(coinAddress, isV1Coin);
-        return isV1Coin
-            ? this.readFairLaunch.fairLaunchInfo({ poolId })
-            : this.readFairLaunchV1_1.fairLaunchInfo({ poolId });
+    async fairLaunchInfo(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const poolId = await this.poolId(coinAddress, coinVersion);
+        return this.getFairLaunch(coinVersion).fairLaunchInfo({ poolId });
     }
     /**
      * Checks if a fair launch is currently active for a given coin
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Promise<boolean> - True if fair launch is active, false otherwise
      */
-    async isFairLaunchActive(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        const poolId = await this.poolId(coinAddress, isV1Coin);
-        return isV1Coin
-            ? this.readFairLaunch.isFairLaunchActive({ poolId })
-            : this.readFairLaunchV1_1.isFairLaunchActive({ poolId });
+    async isFairLaunchActive(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const poolId = await this.poolId(coinAddress, coinVersion);
+        return this.getFairLaunch(coinVersion).isFairLaunchActive({ poolId });
     }
     /**
      * Gets the duration of a fair launch for a given coin
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Promise<number> - The duration in seconds (30 minutes for V1, variable for V1.1)
      */
-    async fairLaunchDuration(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        if (isV1Coin) {
-            return 30 * 60; // 30 minutes
-        }
-        const poolId = await this.poolId(coinAddress, isV1Coin);
-        return this.readFairLaunchV1_1.fairLaunchDuration({ poolId });
+    async fairLaunchDuration(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const poolId = await this.poolId(coinAddress, coinVersion);
+        return this.getFairLaunch(coinVersion).fairLaunchDuration({ poolId });
     }
     /**
      * Gets the initial tick for a fair launch
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Promise<number> - The initial tick value
      */
-    async initialTick(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        const poolId = await this.poolId(coinAddress, isV1Coin);
-        const fairLaunchInfo = isV1Coin
-            ? await this.readFairLaunch.fairLaunchInfo({ poolId })
-            : await this.readFairLaunchV1_1.fairLaunchInfo({ poolId });
+    async initialTick(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const poolId = await this.poolId(coinAddress, coinVersion);
+        const fairLaunchInfo = await this.getFairLaunch(coinVersion).fairLaunchInfo({ poolId });
         return fairLaunchInfo.initialTick;
     }
     /**
      * Gets information about the ETH-only position in a fair launch
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Promise<{flETHAmount: bigint, coinAmount: bigint, tickLower: number, tickUpper: number}> - Position details
      */
-    async fairLaunchETHOnlyPosition(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        const poolId = await this.poolId(coinAddress, isV1Coin);
-        const initialTick = await this.initialTick(coinAddress, isV1Coin);
-        const currentTick = await this.currentTick(coinAddress, isV1Coin);
+    async fairLaunchETHOnlyPosition(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const poolId = await this.poolId(coinAddress, coinVersion);
+        const initialTick = await this.initialTick(coinAddress, coinVersion);
+        const currentTick = await this.currentTick(coinAddress, coinVersion);
         const isFLETHZero = this.flETHIsCurrencyZero(coinAddress);
         let tickLower;
         let tickUpper;
@@ -18421,9 +20830,7 @@ class ReadFlaunchSDK {
         }
         const { liquidity } = await this.readStateView.positionInfo({
             poolId,
-            owner: isV1Coin
-                ? FairLaunchAddress[this.chainId]
-                : FairLaunchV1_1Address[this.chainId],
+            owner: this.getFairLaunchAddress(coinVersion),
             tickLower,
             tickUpper,
             salt: "",
@@ -18442,16 +20849,14 @@ class ReadFlaunchSDK {
     /**
      * Gets information about the coin-only position in a fair launch
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Promise<{flETHAmount: bigint, coinAmount: bigint, tickLower: number, tickUpper: number}> - Position details
      */
-    async fairLaunchCoinOnlyPosition(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        const poolId = await this.poolId(coinAddress, isV1Coin);
-        const initialTick = await this.initialTick(coinAddress, isV1Coin);
-        const currentTick = await this.currentTick(coinAddress, isV1Coin);
+    async fairLaunchCoinOnlyPosition(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const poolId = await this.poolId(coinAddress, coinVersion);
+        const initialTick = await this.initialTick(coinAddress, coinVersion);
+        const currentTick = await this.currentTick(coinAddress, coinVersion);
         const isFLETHZero = this.flETHIsCurrencyZero(coinAddress);
         let tickLower;
         let tickUpper;
@@ -18473,9 +20878,7 @@ class ReadFlaunchSDK {
         }
         const { liquidity } = await this.readStateView.positionInfo({
             poolId,
-            owner: isV1Coin
-                ? FairLaunchAddress[this.chainId]
-                : FairLaunchV1_1Address[this.chainId],
+            owner: this.getFairLaunchAddress(coinVersion),
             tickLower,
             tickUpper,
             salt: "",
@@ -18494,21 +20897,15 @@ class ReadFlaunchSDK {
     /**
      * Gets information about the bid wall position for a coin
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will be determined automatically
      * @returns Promise<{flETHAmount: bigint, coinAmount: bigint, pendingEth: bigint, tickLower: number, tickUpper: number}> - Bid wall position details
      */
-    async bidWallPosition(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        const poolId = await this.poolId(coinAddress, isV1Coin);
+    async bidWallPosition(coinAddress, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        const poolId = await this.poolId(coinAddress, coinVersion);
         const isFLETHZero = this.flETHIsCurrencyZero(coinAddress);
-        const { amount0_: amount0, amount1_: amount1, pendingEth_: pendingEth, } = isV1Coin
-            ? await this.readBidWall.position({ poolId })
-            : await this.readBidWallV1_1.position({ poolId });
-        const { tickLower, tickUpper } = isV1Coin
-            ? await this.readBidWall.poolInfo({ poolId })
-            : await this.readBidWallV1_1.poolInfo({ poolId });
+        const { amount0_: amount0, amount1_: amount1, pendingEth_: pendingEth, } = await this.getBidWall(coinVersion).position({ poolId });
+        const { tickLower, tickUpper } = await this.getBidWall(coinVersion).poolInfo({ poolId });
         const [flETHAmount, coinAmount] = isFLETHZero
             ? [amount0, amount1]
             : [amount1, amount0];
@@ -18520,6 +20917,29 @@ class ReadFlaunchSDK {
             tickUpper,
         };
     }
+    /**
+     * Gets the ETH balance for the creator to claim
+     * @param creator - The address of the creator to check
+     * @param isV1 - Optional boolean to check the balance for V1. V1.1 & AnyPositionManager use the same FeeEscrow contract
+     * @returns The balance of the creator
+     */
+    creatorRevenue(creator, isV1) {
+        if (isV1) {
+            return this.readPositionManager.creatorBalance(creator);
+        }
+        else {
+            return this.readFeeEscrow.balances(creator);
+        }
+    }
+    /**
+     * Gets the balance of a recipient for a given coin
+     * @param recipient - The address of the recipient to check
+     * @param coinAddress - The address of the coin
+     * @returns Promise<bigint> - The balance of the recipient
+     */
+    referralBalance(recipient, coinAddress) {
+        return this.readReferralEscrow.allocations(recipient, coinAddress);
+    }
     /**
      * Gets the claimable balance of ETH for the recipient from a revenue manager
      * @param params - Parameters for checking the balance
@@ -18576,21 +20996,24 @@ class ReadFlaunchSDK {
     /**
      * Gets the pool ID for a given coin
      * @param coinAddress - The address of the coin
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use
      * @returns Promise<string> - The pool ID
      */
-    async poolId(coinAddress, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
+    async poolId(coinAddress, version) {
+        let hookAddress;
+        if (version) {
+            hookAddress = this.getPositionManagerAddress(version);
+        }
+        else {
+            const coinVersion = await this.getCoinVersion(coinAddress);
+            hookAddress = this.getPositionManagerAddress(coinVersion);
         }
         return getPoolId(orderPoolKey({
             currency0: FLETHAddress[this.chainId],
             currency1: coinAddress,
             fee: 0,
             tickSpacing: 60,
-            hooks: isV1Coin
-                ? FlaunchPositionManagerAddress[this.chainId]
-                : FlaunchPositionManagerV1_1Address[this.chainId],
+            hooks: hookAddress,
         }));
     }
     /**
@@ -18637,40 +21060,34 @@ class ReadFlaunchSDK {
      * Gets a quote for selling an exact amount of tokens for ETH
      * @param coinAddress - The address of the token to sell
      * @param amountIn - The exact amount of tokens to sell
-     * @param isV1Coin - Optional flag to specify if token is V1. If not provided, V1.1 is assumed
+     * @param version - Optional specific version to use
      * @returns Promise<bigint> - The expected amount of ETH to receive
      */
-    async getSellQuoteExactInput(coinAddress, amountIn, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        return this.readQuoter.getSellQuoteExactInput(coinAddress, amountIn, isV1Coin);
+    async getSellQuoteExactInput(coinAddress, amountIn, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        return this.readQuoter.getSellQuoteExactInput(coinAddress, amountIn, this.getPositionManagerAddress(coinVersion));
     }
     /**
      * Gets a quote for buying tokens with an exact amount of ETH
      * @param coinAddress - The address of the token to buy
      * @param ethIn - The exact amount of ETH to spend
-     * @param isV1Coin - Optional flag to specify if token is V1. If not provided, V1.1 is assumed
+     * @param version - Optional specific version to use
      * @returns Promise<bigint> - The expected amount of tokens to receive
      */
-    async getBuyQuoteExactInput(coinAddress, amountIn, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        return this.readQuoter.getBuyQuoteExactInput(coinAddress, amountIn, isV1Coin);
+    async getBuyQuoteExactInput(coinAddress, amountIn, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        return this.readQuoter.getBuyQuoteExactInput(coinAddress, amountIn, this.getPositionManagerAddress(coinVersion));
     }
     /**
      * Gets a quote for buying an exact amount of tokens with ETH
      * @param coinAddress - The address of the token to buy
      * @param coinOut - The exact amount of tokens to receive
-     * @param isV1Coin - Optional flag to specify if token is V1. If not provided, V1.1 is assumed
+     * @param version - Optional specific version to use
      * @returns Promise<bigint> - The required amount of ETH to spend
      */
-    async getBuyQuoteExactOutput(coinAddress, amountOut, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(coinAddress);
-        }
-        return this.readQuoter.getBuyQuoteExactOutput(coinAddress, amountOut, isV1Coin);
+    async getBuyQuoteExactOutput(coinAddress, amountOut, version) {
+        const coinVersion = version || (await this.getCoinVersion(coinAddress));
+        return this.readQuoter.getBuyQuoteExactOutput(coinAddress, amountOut, this.getPositionManagerAddress(coinVersion));
     }
     /**
      * Determines if flETH is currency0 in the pool
@@ -18693,8 +21110,11 @@ class ReadFlaunchSDK {
 class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
     constructor(chainId, drift$1 = drift.createDrift()) {
         super(chainId, drift$1);
-        this.readWritePositionManagerV1_1 = new ReadWriteFlaunchPositionManagerV1_1(FlaunchPositionManagerAddress[this.chainId], drift$1);
-        this.readWriteFastFlaunchZap = new ReadWriteFastFlaunchZap(FastFlaunchZapAddress[this.chainId], drift$1);
+        this.readWritePositionManager = new ReadWriteFlaunchPositionManager(FlaunchPositionManagerAddress[this.chainId], drift$1);
+        this.readWritePositionManagerV1_1 = new ReadWriteFlaunchPositionManagerV1_1(FlaunchPositionManagerV1_1Address[this.chainId], drift$1);
+        this.readWriteAnyPositionManager = new ReadWriteAnyPositionManager(AnyPositionManagerAddress[this.chainId], drift$1);
+        this.readWriteFeeEscrow = new ReadWriteFeeEscrow(FeeEscrowAddress[this.chainId], drift$1);
+        this.readWriteReferralEscrow = new ReadWriteReferralEscrow(ReferralEscrowAddress[this.chainId], drift$1);
         this.readWriteFlaunchZap = new ReadWriteFlaunchZap(this.chainId, FlaunchZapAddress[this.chainId], drift$1);
         this.readWriteTreasuryManagerFactory = new ReadWriteTreasuryManagerFactory(this.chainId, TreasuryManagerFactoryAddress[this.chainId], drift$1);
         this.readWritePermit2 = new ReadWritePermit2(Permit2Address[this.chainId], drift$1);
@@ -18731,7 +21151,7 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         return event.args._manager;
     }
     /**
-     * Creates a new Flaunch on V1.1
+     * Creates a new Flaunch on the specified version
      * @param params - Parameters for creating the Flaunch
      * @returns Transaction response
      */
@@ -18739,37 +21159,13 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         return this.readWriteFlaunchZap.flaunch(params);
     }
     /**
-     * Creates a new Flaunch on V1.1 with IPFS metadata
+     * Creates a new Flaunch with IPFS metadata and optional version specification
      * @param params - Parameters for creating the Flaunch with IPFS data
      * @returns Transaction response
      */
     flaunchIPFS(params) {
         return this.readWriteFlaunchZap.flaunchIPFS(params);
     }
-    /**
-     * Creates a new fast Flaunch on V1.1
-     * @param params - Parameters for creating the fast Flaunch
-     * @throws Error if FastFlaunchZap is not deployed on the current chain
-     * @returns Transaction response
-     */
-    fastFlaunch(params) {
-        if (this.readWriteFastFlaunchZap.contract.address === viem.zeroAddress) {
-            throw new Error(`FastFlaunchZap is not deployed at chainId: ${this.chainId}`);
-        }
-        return this.readWriteFastFlaunchZap.fastFlaunch(params);
-    }
-    /**
-     * Creates a new fast Flaunch on V1.1 with IPFS metadata
-     * @param params - Parameters for creating the fast Flaunch with IPFS data
-     * @throws Error if FastFlaunchZap is not deployed on the current chain
-     * @returns Transaction response
-     */
-    fastFlaunchIPFS(params) {
-        if (this.readWriteFastFlaunchZap.contract.address === viem.zeroAddress) {
-            throw new Error(`FastFlaunchZap is not deployed at chainId: ${this.chainId}`);
-        }
-        return this.readWriteFastFlaunchZap.fastFlaunchIPFS(params);
-    }
     /**
      * Creates a new Flaunch with revenue manager configuration
      * @param params - Parameters for creating the Flaunch with revenue manager
@@ -18794,6 +21190,14 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         }
         return this.readWriteFlaunchZap.flaunchIPFSWithRevenueManager(params);
     }
+    /**
+     * Creates a new Flaunch with AnyPositionManager for external coins
+     * @param params - Parameters for creating the Flaunch with AnyPositionManager
+     * @returns Transaction response
+     */
+    anyFlaunch(params) {
+        return this.readWriteAnyPositionManager.flaunch(params);
+    }
     /**
      * Gets the balance of a specific coin for the connected wallet
      * @param coinAddress - The address of the coin to check
@@ -18808,13 +21212,11 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
     /**
      * Buys a coin with ETH
      * @param params - Parameters for buying the coin including amount, slippage, and referrer
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will determine automatically
      * @returns Transaction response for the buy operation
      */
-    async buyCoin(params, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(params.coinAddress);
-        }
+    async buyCoin(params, version) {
+        const coinVersion = version || (await this.getCoinVersion(params.coinAddress));
         const sender = await this.drift.getSignerAddress();
         let amountIn;
         let amountOutMin;
@@ -18824,7 +21226,8 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         if (params.swapType === "EXACT_IN") {
             amountIn = params.amountIn;
             if (params.amountOutMin === undefined) {
-                amountOutMin = getAmountWithSlippage(await this.readQuoter.getBuyQuoteExactInput(params.coinAddress, amountIn, isV1Coin), (params.slippagePercent / 100).toFixed(18).toString(), params.swapType);
+                // Currently only V1 and V1.1 are supported in the Quoter
+                amountOutMin = getAmountWithSlippage(await this.readQuoter.getBuyQuoteExactInput(params.coinAddress, amountIn, this.getPositionManagerAddress(coinVersion)), (params.slippagePercent / 100).toFixed(18).toString(), params.swapType);
             }
             else {
                 amountOutMin = params.amountOutMin;
@@ -18833,12 +21236,14 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         else {
             amountOut = params.amountOut;
             if (params.amountInMax === undefined) {
-                amountInMax = getAmountWithSlippage(await this.readQuoter.getBuyQuoteExactOutput(params.coinAddress, amountOut, isV1Coin), (params.slippagePercent / 100).toFixed(18).toString(), params.swapType);
+                // Currently only V1 and V1.1 are supported in the Quoter
+                amountInMax = getAmountWithSlippage(await this.readQuoter.getBuyQuoteExactOutput(params.coinAddress, amountOut, this.getPositionManagerAddress(coinVersion)), (params.slippagePercent / 100).toFixed(18).toString(), params.swapType);
             }
             else {
                 amountInMax = params.amountInMax;
             }
         }
+        // When UniversalRouter supports isAny parameter, add it here
         const { commands, inputs } = ethToMemecoin({
             sender: sender,
             memecoin: params.coinAddress,
@@ -18849,7 +21254,7 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
             amountOutMin: amountOutMin,
             amountOut: amountOut,
             amountInMax: amountInMax,
-            isV1Coin: isV1Coin,
+            positionManagerAddress: this.getPositionManagerAddress(coinVersion),
         });
         return this.drift.adapter.write({
             abi: UniversalRouterAbi,
@@ -18865,22 +21270,22 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
     /**
      * Sells a coin for ETH
      * @param params - Parameters for selling the coin including amount, slippage, permit data, and referrer
-     * @param isV1Coin - Optional flag to specify if coin is V1. If not provided, will be determined automatically
+     * @param version - Optional specific version to use. If not provided, will determine automatically
      * @returns Transaction response for the sell operation
      */
-    async sellCoin(params, isV1Coin) {
-        if (isV1Coin === undefined) {
-            isV1Coin = await this.isV1Coin(params.coinAddress);
-        }
+    async sellCoin(params, version) {
+        const coinVersion = version || (await this.getCoinVersion(params.coinAddress));
         let ethOutMin;
         await this.readQuoter.contract.cache.clear();
         if (params.ethOutMin === undefined) {
-            ethOutMin = getAmountWithSlippage(await this.readQuoter.getSellQuoteExactInput(params.coinAddress, params.amountIn, isV1Coin), (params.slippagePercent / 100).toFixed(18).toString(), "EXACT_IN");
+            // Currently only V1 and V1.1 are supported in the Quoter
+            ethOutMin = getAmountWithSlippage(await this.readQuoter.getSellQuoteExactInput(params.coinAddress, params.amountIn, this.getPositionManagerAddress(coinVersion)), (params.slippagePercent / 100).toFixed(18).toString(), "EXACT_IN");
         }
         else {
             ethOutMin = params.ethOutMin;
         }
         await this.readPermit2.contract.cache.clear();
+        // When UniversalRouter supports isAny parameter, add it here
         const { commands, inputs } = memecoinToEthWithPermit2({
             chainId: this.chainId,
             memecoin: params.coinAddress,
@@ -18889,7 +21294,7 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
             permitSingle: params.permitSingle,
             signature: params.signature,
             referrer: params.referrer ?? null,
-            isV1Coin: isV1Coin,
+            positionManagerAddress: this.getPositionManagerAddress(coinVersion),
         });
         return this.drift.write({
             abi: UniversalRouterAbi,
@@ -18930,6 +21335,31 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
             nonce,
         };
     }
+    /**
+     * Withdraws the creator's share of the revenue
+     * @param params - Parameters for withdrawing the creator's share of the revenue
+     * @param params.recipient - The address to withdraw the revenue to. Defaults to the connected wallet
+     * @param params.isV1 - Optional boolean to withdraw from V1. V1.1 & AnyPositionManager use the same FeeEscrow contract
+     * @returns Transaction response
+     */
+    async withdrawCreatorRevenue(params) {
+        const recipient = params.recipient ?? (await this.drift.getSignerAddress());
+        if (params.isV1) {
+            return this.readWritePositionManager.withdrawFees(recipient);
+        }
+        else {
+            return this.readWriteFeeEscrow.withdrawFees(recipient);
+        }
+    }
+    /**
+     * Claims the referral balance for a given recipient
+     * @param coins - The addresses of the coins to claim
+     * @param recipient - The address of the recipient to claim the balance for
+     * @returns Transaction response
+     */
+    claimReferralBalance(coins, recipient) {
+        return this.readWriteReferralEscrow.claimTokens(coins, recipient);
+    }
     /**
      * Claims the protocol's share of the revenue
      * @param params - Parameters for claiming the protocol's share of the revenue
@@ -18959,6 +21389,26 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
     }
 }
 
+/**
+ * Creates a Drift instance with the provided clients
+ * @param params - Parameters for creating the Drift instance
+ * @returns Drift instance configured with the appropriate clients
+ * @throws Error if publicClient.chain is not configured
+ */
+function createDrift(params) {
+    const { publicClient, walletClient } = params;
+    if (!publicClient.chain) {
+        throw new Error("publicClient must be configured with a chain");
+    }
+    return walletClient
+        ? drift.createDrift({
+            adapter: driftViem.viemAdapter({ publicClient, walletClient }),
+        })
+        : drift.createDrift({
+            adapter: driftViem.viemAdapter({ publicClient }),
+        });
+}
+
 /**
  * Creates a Flaunch SDK instance with the provided clients
  * @param params - Parameters for creating the SDK
@@ -18973,12 +21423,8 @@ function createFlaunch(params) {
     const chainId = publicClient.chain.id;
     // Return appropriate SDK type based on whether walletClient is provided
     return walletClient
-        ? new ReadWriteFlaunchSDK(chainId, drift.createDrift({
-            adapter: driftViem.viemAdapter({ publicClient, walletClient }),
-        }))
-        : new ReadFlaunchSDK(chainId, drift.createDrift({
-            adapter: driftViem.viemAdapter({ publicClient }),
-        }));
+        ? new ReadWriteFlaunchSDK(chainId, createDrift({ publicClient, walletClient }))
+        : new ReadFlaunchSDK(chainId, createDrift({ publicClient }));
 }
 
 const FlaunchSDK = {
@@ -18986,39 +21432,61 @@ const FlaunchSDK = {
     ReadWriteFlaunchSDK,
 };
 
+exports.AnyPositionManagerAbi = AnyPositionManagerAbi;
+exports.AnyPositionManagerAddress = AnyPositionManagerAddress;
 exports.BidWallAddress = BidWallAddress;
+exports.BidWallV1_1Abi = BidWallV1_1Abi;
 exports.BidWallV1_1Address = BidWallV1_1Address;
+exports.BidwallAbi = BidwallAbi;
 exports.FLETHAddress = FLETHAddress;
 exports.FLETHHooksAddress = FLETHHooksAddress;
 exports.FairLaunchAbi = FairLaunchAbi;
 exports.FairLaunchAddress = FairLaunchAddress;
+exports.FairLaunchV1_1Abi = FairLaunchV1_1Abi;
 exports.FairLaunchV1_1Address = FairLaunchV1_1Address;
 exports.FastFlaunchZapAbi = FastFlaunchZapAbi;
 exports.FastFlaunchZapAddress = FastFlaunchZapAddress;
+exports.FeeEscrowAbi = FeeEscrowAbi;
+exports.FeeEscrowAddress = FeeEscrowAddress;
+exports.FlaunchAbi = FlaunchAbi;
 exports.FlaunchAddress = FlaunchAddress;
 exports.FlaunchPositionManagerAbi = FlaunchPositionManagerAbi;
 exports.FlaunchPositionManagerAddress = FlaunchPositionManagerAddress;
+exports.FlaunchPositionManagerV1_1Abi = FlaunchPositionManagerV1_1Abi;
 exports.FlaunchPositionManagerV1_1Address = FlaunchPositionManagerV1_1Address;
 exports.FlaunchSDK = FlaunchSDK;
+exports.FlaunchV1_1Abi = FlaunchV1_1Abi;
 exports.FlaunchV1_1Address = FlaunchV1_1Address;
+exports.FlaunchZapAbi = FlaunchZapAbi;
 exports.FlaunchZapAddress = FlaunchZapAddress;
+exports.InitialPriceAbi = InitialPriceAbi;
 exports.MemecoinAbi = MemecoinAbi;
+exports.MulticallAbi = MulticallAbi;
+exports.Permit2Abi = Permit2Abi;
 exports.Permit2Address = Permit2Address;
 exports.PoolManagerAbi = PoolManagerAbi;
 exports.PoolManagerAddress = PoolManagerAddress;
+exports.QuoterAbi = QuoterAbi;
 exports.QuoterAddress = QuoterAddress;
 exports.ReadFlaunchSDK = ReadFlaunchSDK;
 exports.ReadWriteFlaunchSDK = ReadWriteFlaunchSDK;
+exports.ReferralEscrowAbi = ReferralEscrowAbi;
+exports.ReferralEscrowAddress = ReferralEscrowAddress;
+exports.RevenueManagerAbi = RevenueManagerAbi;
 exports.RevenueManagerAddress = RevenueManagerAddress;
+exports.StateViewAbi = StateViewAbi;
 exports.StateViewAddress = StateViewAddress;
 exports.TICK_SPACING = TICK_SPACING;
 exports.TickFinder = TickFinder;
+exports.TreasuryManagerFactoryAbi = TreasuryManagerFactoryAbi;
 exports.TreasuryManagerFactoryAddress = TreasuryManagerFactoryAddress;
 exports.USDCETHPoolKeys = USDCETHPoolKeys;
+exports.UniversalRouterAbi = UniversalRouterAbi;
 exports.UniversalRouterAddress = UniversalRouterAddress;
 exports.bytes32ToUint256 = bytes32ToUint256;
 exports.calculateUnderlyingTokenBalances = calculateUnderlyingTokenBalances;
 exports.chainIdToChain = chainIdToChain;
+exports.createDrift = createDrift;
 exports.createFlaunch = createFlaunch;
 exports.generateTokenUri = generateTokenUri;
 exports.getPoolId = getPoolId;