@coinbase/agentkit 0.10.1 → 0.10.3

package/dist/action-providers/erc20/constants.js

@@ -43,8 +43,10 @@ exports.TOKEN_ADDRESSES_BY_SYMBOLS = {
     },
     "arbitrum-mainnet": {
         USDC: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+        WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
     },
     "optimism-mainnet": {
         USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
+        WETH: "0x4200000000000000000000000000000000000006",
     },
 };

package/dist/action-providers/erc20/erc20ActionProvider.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { GetBalanceSchema, TransferSchema, GetTokenAddressSchema } from "./schemas";
+import { GetBalanceSchema, TransferSchema, GetTokenAddressSchema, ApproveSchema, AllowanceSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
 /**
  * ERC20ActionProvider is an action provider for ERC20 tokens.
@@ -27,6 +27,22 @@ export declare class ERC20ActionProvider extends ActionProvider<EvmWalletProvide
      * @returns A message containing the transfer details.
      */
     transfer(walletProvider: EvmWalletProvider, args: z.infer<typeof TransferSchema>): Promise<string>;
+    /**
+     * Approves a spender to transfer a specified amount of tokens.
+     *
+     * @param walletProvider - The wallet provider to approve from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the approval details.
+     */
+    approve(walletProvider: EvmWalletProvider, args: z.infer<typeof ApproveSchema>): Promise<string>;
+    /**
+     * Checks the allowance for a spender of an ERC20 token.
+     *
+     * @param walletProvider - The wallet provider to check the allowance from.
+     * @param args - The input arguments containing tokenAddress and spender.
+     * @returns A message containing the allowance amount for the spender.
+     */
+    getAllowance(walletProvider: EvmWalletProvider, args: z.infer<typeof AllowanceSchema>): Promise<string>;
     /**
      * Gets the contract address for a token symbol on the current network.
      *

package/dist/action-providers/erc20/erc20ActionProvider.js

@@ -117,6 +117,66 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
             return `Error transferring the asset: ${error}`;
         }
     }
+    /**
+     * Approves a spender to transfer a specified amount of tokens.
+     *
+     * @param walletProvider - The wallet provider to approve from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the approval details.
+     */
+    async approve(walletProvider, args) {
+        try {
+            // Get token details for better error messages and validation
+            const tokenAddress = (0, viem_1.getAddress)(args.tokenAddress);
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, args.tokenAddress);
+            if (!tokenDetails) {
+                return `Error: Could not fetch token details for ${args.tokenAddress}. Please verify the token address is correct.`;
+            }
+            // Convert amount to wei using token decimals
+            const amountInWei = (0, viem_1.parseUnits)(String(args.amount), tokenDetails.decimals);
+            const hash = await walletProvider.sendTransaction({
+                to: tokenAddress,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: viem_1.erc20Abi,
+                    functionName: "approve",
+                    args: [args.spenderAddress, amountInWei],
+                }),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Approved ${args.amount} ${tokenDetails.name} (${args.tokenAddress}) for spender ${args.spenderAddress}.\nTransaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error approving tokens: ${error}`;
+        }
+    }
+    /**
+     * Checks the allowance for a spender of an ERC20 token.
+     *
+     * @param walletProvider - The wallet provider to check the allowance from.
+     * @param args - The input arguments containing tokenAddress and spender.
+     * @returns A message containing the allowance amount for the spender.
+     */
+    async getAllowance(walletProvider, args) {
+        try {
+            // Get token details for proper formatting
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, args.tokenAddress);
+            if (!tokenDetails) {
+                return `Error: Could not fetch token details for ${args.tokenAddress}. Please verify the token address is correct.`;
+            }
+            const allowance = await walletProvider.readContract({
+                address: args.tokenAddress,
+                abi: viem_1.erc20Abi,
+                functionName: "allowance",
+                args: [walletProvider.getAddress(), args.spenderAddress],
+            });
+            // Format the allowance using token decimals
+            const formattedAllowance = (0, viem_1.formatUnits)(allowance, tokenDetails.decimals);
+            return `Allowance for ${args.spenderAddress} to spend ${tokenDetails.name} (${args.tokenAddress}) is ${formattedAllowance} tokens`;
+        }
+        catch (error) {
+            return `Error checking allowance: ${error}`;
+        }
+    }
     /**
      * Gets the contract address for a token symbol on the current network.
      *
@@ -166,7 +226,7 @@ __decorate([
 It takes the following inputs:
 - amount: The amount to transfer in whole units (e.g. 10.5 USDC)
 - tokenAddress: The contract address of the token to transfer
-- destinationAddress: Where to send the funds (can be an onchain address, ENS 'example.eth', or Basename 'example.base.eth')
+- destinationAddress: The address to send the funds to
 Important notes:
 - Never assume token or destination addresses, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool to get the token address first
 `,
@@ -176,6 +236,48 @@ Important notes:
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], ERC20ActionProvider.prototype, "transfer", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "approve",
+        description: `
+This tool will approve a spender to transfer ERC20 tokens from the wallet.
+
+It takes the following inputs:
+- amount: The amount to approve in whole units (e.g. 100 for 100 USDC)
+- tokenAddress: The contract address of the token to approve
+- spenderAddress: The spender address to approve
+
+Important notes:
+- This will overwrite any existing allowance
+- To revoke an allowance, set the amount to 0
+- Ensure you trust the spender address before approving
+- Never assume token addresses, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool to get the token address first
+`,
+        schema: schemas_1.ApproveSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "approve", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_allowance",
+        description: `
+This tool will get the allowance amount for a spender of an ERC20 token.
+
+It takes the following inputs:
+- tokenAddress: The contract address of the token to check allowance for
+- spenderAddress: The address to check allowance for
+
+Important notes:
+- Never assume token addresses, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool to get the token address first
+`,
+        schema: schemas_1.AllowanceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "getAllowance", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "get_erc20_token_address",

package/dist/action-providers/erc20/erc20ActionProvider.test.js

@@ -7,6 +7,7 @@ const MOCK_DECIMALS = 6;
 const MOCK_CONTRACT_ADDRESS = "0x1234567890123456789012345678901234567890";
 const MOCK_DESTINATION = "0x9876543210987654321098765432109876543210";
 const MOCK_ADDRESS = "0x1234567890123456789012345678901234567890";
+const MOCK_SPENDER = "0xabcdef1234567890123456789012345678901234";
 describe("Transfer Schema", () => {
     it("should successfully parse valid input", () => {
         const validInput = {
@@ -142,6 +143,206 @@ describe("GetTokenAddress Schema", () => {
         expect(result.success).toBe(false);
     });
 });
+describe("Approve Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const result = schemas_1.ApproveSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.ApproveSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing invalid token address", () => {
+        const invalidInput = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: "invalid-address",
+            spenderAddress: MOCK_SPENDER,
+        };
+        const result = schemas_1.ApproveSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing invalid spender address", () => {
+        const invalidInput = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: "invalid-address",
+        };
+        const result = schemas_1.ApproveSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Allowance Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const result = schemas_1.AllowanceSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.AllowanceSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing invalid token address", () => {
+        const invalidInput = {
+            tokenAddress: "invalid-address",
+            spenderAddress: MOCK_SPENDER,
+        };
+        const result = schemas_1.AllowanceSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing invalid spender address", () => {
+        const invalidInput = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: "invalid-address",
+        };
+        const result = schemas_1.AllowanceSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Approve Action", () => {
+    const TRANSACTION_HASH = "0xapprove123456789";
+    let mockWallet;
+    let mockMulticall;
+    const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();
+    beforeEach(async () => {
+        mockMulticall = jest.fn();
+        const mockPublicClient = {
+            multicall: mockMulticall,
+            getCode: jest.fn().mockResolvedValue("0x"),
+        };
+        mockWallet = {
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            getNetwork: jest.fn().mockReturnValue({
+                networkId: "base-mainnet",
+            }),
+            getPublicClient: jest.fn().mockReturnValue(mockPublicClient),
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+        };
+        mockWallet.sendTransaction.mockResolvedValue(TRANSACTION_HASH);
+        mockWallet.waitForTransactionReceipt.mockResolvedValue({});
+    });
+    it("should successfully approve tokens", async () => {
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
+        const args = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.approve(mockWallet, args);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(mockWallet.sendTransaction).toHaveBeenCalled();
+        expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(TRANSACTION_HASH);
+        expect(response).toContain(`Approved ${MOCK_AMOUNT} MockToken (${MOCK_CONTRACT_ADDRESS}) for spender ${MOCK_SPENDER}`);
+        expect(response).toContain(`Transaction hash: ${TRANSACTION_HASH}`);
+    });
+    it("should fail with an error when token details cannot be fetched", async () => {
+        mockMulticall.mockRejectedValue(new Error("Failed to get token details"));
+        const args = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.approve(mockWallet, args);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(response).toContain("Error: Could not fetch token details");
+    });
+    it("should fail with an error when transaction fails", async () => {
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
+        mockWallet.sendTransaction.mockRejectedValue(new Error("Transaction failed"));
+        const args = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.approve(mockWallet, args);
+        expect(response).toContain("Error approving tokens: Error: Transaction failed");
+    });
+});
+describe("Get Allowance Action", () => {
+    let mockWallet;
+    let mockMulticall;
+    let mockReadContract;
+    const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();
+    beforeEach(async () => {
+        mockMulticall = jest.fn();
+        mockReadContract = jest.fn();
+        const mockPublicClient = {
+            multicall: mockMulticall,
+            getCode: jest.fn().mockResolvedValue("0x"),
+        };
+        mockWallet = {
+            readContract: mockReadContract,
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            getNetwork: jest.fn().mockReturnValue({
+                networkId: "base-mainnet",
+            }),
+            getPublicClient: jest.fn().mockReturnValue(mockPublicClient),
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+        };
+    });
+    it("should successfully get allowance", async () => {
+        const allowanceAmount = BigInt(MOCK_AMOUNT * 10 ** MOCK_DECIMALS);
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
+        mockReadContract.mockResolvedValue(allowanceAmount);
+        const args = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.getAllowance(mockWallet, args);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(mockReadContract).toHaveBeenCalled();
+        expect(response).toContain(`Allowance for ${MOCK_SPENDER} to spend MockToken (${MOCK_CONTRACT_ADDRESS}) is ${MOCK_AMOUNT}`);
+    });
+    it("should fail with an error when token details cannot be fetched", async () => {
+        mockMulticall.mockRejectedValue(new Error("Failed to get token details"));
+        const args = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.getAllowance(mockWallet, args);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(response).toContain("Error: Could not fetch token details");
+    });
+    it("should fail with an error when allowance read fails", async () => {
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
+        mockReadContract.mockRejectedValue(new Error("Allowance read failed"));
+        const args = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.getAllowance(mockWallet, args);
+        expect(response).toContain("Error checking allowance: Error: Allowance read failed");
+    });
+});
 describe("Get Token Address Action", () => {
     let mockWallet;
     const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();

package/dist/action-providers/erc20/schemas.d.ts

@@ -28,6 +28,35 @@ export declare const GetBalanceSchema: z.ZodObject<{
     tokenAddress: string;
     address?: string | undefined;
 }>;
+/**
+ * Input schema for approve action.
+ */
+export declare const ApproveSchema: z.ZodObject<{
+    amount: z.ZodString;
+    tokenAddress: z.ZodString;
+    spenderAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    tokenAddress: string;
+    spenderAddress: string;
+}, {
+    amount: string;
+    tokenAddress: string;
+    spenderAddress: string;
+}>;
+/**
+ * Input schema for allowance action.
+ */
+export declare const AllowanceSchema: z.ZodObject<{
+    tokenAddress: z.ZodString;
+    spenderAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    tokenAddress: string;
+    spenderAddress: string;
+}, {
+    tokenAddress: string;
+    spenderAddress: string;
+}>;
 /**
  * Input schema for get token address action.
  */

package/dist/action-providers/erc20/schemas.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetTokenAddressSchema = exports.GetBalanceSchema = exports.TransferSchema = void 0;
+exports.GetTokenAddressSchema = exports.AllowanceSchema = exports.ApproveSchema = exports.GetBalanceSchema = exports.TransferSchema = void 0;
 const zod_1 = require("zod");
 /**
  * Input schema for transfer action.
@@ -38,6 +38,39 @@ exports.GetBalanceSchema = zod_1.z
 })
     .strip()
     .describe("Instructions for getting wallet balance");
+/**
+ * Input schema for approve action.
+ */
+exports.ApproveSchema = zod_1.z
+    .object({
+    amount: zod_1.z.string().describe("The amount to approve in whole units (e.g. 100 for 100 USDC)"),
+    tokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The contract address of the token"),
+    spenderAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address to approve for spending tokens"),
+})
+    .strip()
+    .describe("Instructions for approving token spending");
+/**
+ * Input schema for allowance action.
+ */
+exports.AllowanceSchema = zod_1.z
+    .object({
+    tokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The contract address of the token"),
+    spenderAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address to check allowance for"),
+})
+    .strip()
+    .describe("Instructions for checking token allowance");
 /**
  * Input schema for get token address action.
  */

package/dist/action-providers/flaunch/client_utils.d.ts

@@ -0,0 +1,25 @@
+import { Address, Hex, TransactionReceipt } from "viem";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * Gets the memecoin address from the transaction receipt
+ *
+ * @param receipt - The transaction receipt
+ * @param chainId - The chain id
+ * @returns The memecoin address
+ */
+export declare function getMemecoinAddressFromReceipt(receipt: TransactionReceipt, chainId: string): Address;
+/**
+ * Calculates the ETH required to flaunch a token, takes into account the ETH for premine and the flaunching fee
+ *
+ * @param walletProvider - The EVM wallet provider
+ * @param params - The flaunch parameters
+ * @param params.premineAmount - The amount to premine
+ * @param params.initialPriceParams - The initial price parameters
+ * @param params.slippagePercent - The slippage percentage (optional, defaults to 5%)
+ * @returns Promise that resolves to the ETH amount required
+ */
+export declare function ethRequiredToFlaunch(walletProvider: EvmWalletProvider, params: {
+    premineAmount: bigint;
+    initialPriceParams: Hex;
+    slippagePercent?: number;
+}): Promise<bigint>;

package/dist/action-providers/flaunch/client_utils.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemecoinAddressFromReceipt = getMemecoinAddressFromReceipt;
+exports.ethRequiredToFlaunch = ethRequiredToFlaunch;
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+/**
+ * Gets the memecoin address from the transaction receipt
+ *
+ * @param receipt - The transaction receipt
+ * @param chainId - The chain id
+ * @returns The memecoin address
+ */
+function getMemecoinAddressFromReceipt(receipt, chainId) {
+    const filteredPoolCreatedEvent = receipt.logs
+        .map(log => {
+        try {
+            if (log.address.toLowerCase() !== constants_1.FlaunchPositionManagerV1_1Address[chainId].toLowerCase()) {
+                return null;
+            }
+            const event = (0, viem_1.decodeEventLog)({
+                abi: constants_1.POSITION_MANAGERV1_1_ABI,
+                data: log.data,
+                topics: log.topics,
+            });
+            return event.eventName === "PoolCreated" ? event.args : null;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((event) => event !== null)[0];
+    if (!filteredPoolCreatedEvent) {
+        throw new Error("Could not find PoolCreated event in transaction receipt");
+    }
+    return filteredPoolCreatedEvent._memecoin;
+}
+/**
+ * Calculates the ETH required to flaunch a token, takes into account the ETH for premine and the flaunching fee
+ *
+ * @param walletProvider - The EVM wallet provider
+ * @param params - The flaunch parameters
+ * @param params.premineAmount - The amount to premine
+ * @param params.initialPriceParams - The initial price parameters
+ * @param params.slippagePercent - The slippage percentage (optional, defaults to 5%)
+ * @returns Promise that resolves to the ETH amount required
+ */
+function ethRequiredToFlaunch(walletProvider, params) {
+    const chainId = walletProvider.getNetwork().chainId;
+    if (!chainId)
+        throw new Error("Chain ID is not set.");
+    return walletProvider.readContract({
+        address: constants_1.FlaunchZapAddress[chainId],
+        abi: constants_1.FLAUNCH_ZAP_ABI,
+        functionName: "calculateFee",
+        args: [
+            params.premineAmount ?? 0n,
+            BigInt(params.slippagePercent ?? 5 * 100),
+            params.initialPriceParams,
+        ],
+    });
+}

package/dist/action-providers/flaunch/constants.d.ts

@@ -1,34 +1,52 @@
 import { Addresses } from "./types";
 import { erc20Abi as ERC20_ABI } from "viem";
 export { ERC20_ABI };
+export declare const TOTAL_SUPPLY: bigint;
 export declare const FastFlaunchZapAddress: Addresses;
-export declare const FlaunchPositionManagerAddress: Addresses;
+export declare const FlaunchZapAddress: Addresses;
+export declare const RevenueManagerAddress: Addresses;
+export declare const AddressFeeSplitManagerAddress: Addresses;
+export declare const FlaunchPositionManagerV1_1Address: Addresses;
 export declare const FLETHAddress: Addresses;
 export declare const FLETHHooksAddress: Addresses;
 export declare const QuoterAddress: Addresses;
 export declare const UniversalRouterAddress: Addresses;
 export declare const Permit2Address: Addresses;
-export declare const FAST_FLAUNCH_ZAP_ABI: {
-    type: string;
-    name: string;
+export declare const FLAUNCH_ZAP_ABI: ({
     inputs: {
+        internalType: string;
         name: string;
         type: string;
+    }[];
+    name: string;
+    outputs: {
         internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+} | {
+    inputs: {
         components: {
+            internalType: string;
             name: string;
             type: string;
-            internalType: string;
         }[];
+        internalType: string;
+        name: string;
+        type: string;
     }[];
+    name: string;
     outputs: {
+        internalType: string;
         name: string;
         type: string;
-        internalType: string;
     }[];
     stateMutability: string;
-}[];
-export declare const POSITION_MANAGER_ABI: readonly [{
+    type: string;
+})[];
+export declare const POSITION_MANAGERV1_1_ABI: readonly [{
     readonly name: "PoolCreated";
     readonly type: "event";
     readonly inputs: readonly [{
@@ -64,6 +82,9 @@ export declare const POSITION_MANAGER_ABI: readonly [{
         }, {
             readonly type: "uint256";
             readonly name: "initialTokenFairLaunch";
+        }, {
+            readonly type: "uint256";
+            readonly name: "fairLaunchDuration";
         }, {
             readonly type: "uint256";
             readonly name: "premineAmount";
@@ -93,41 +114,41 @@ export declare const POSITION_MANAGER_ABI: readonly [{
         readonly name: "poolId";
         readonly indexed: true;
     }, {
-        readonly name: "flAmount0";
         readonly type: "int256";
+        readonly name: "flAmount0";
     }, {
-        readonly name: "flAmount1";
         readonly type: "int256";
+        readonly name: "flAmount1";
     }, {
-        readonly name: "flFee0";
         readonly type: "int256";
+        readonly name: "flFee0";
     }, {
-        readonly name: "flFee1";
         readonly type: "int256";
+        readonly name: "flFee1";
     }, {
-        readonly name: "ispAmount0";
         readonly type: "int256";
+        readonly name: "ispAmount0";
     }, {
-        readonly name: "ispAmount1";
         readonly type: "int256";
+        readonly name: "ispAmount1";
     }, {
-        readonly name: "ispFee0";
         readonly type: "int256";
+        readonly name: "ispFee0";
     }, {
-        readonly name: "ispFee1";
         readonly type: "int256";
+        readonly name: "ispFee1";
     }, {
-        readonly name: "uniAmount0";
         readonly type: "int256";
+        readonly name: "uniAmount0";
     }, {
-        readonly name: "uniAmount1";
         readonly type: "int256";
+        readonly name: "uniAmount1";
     }, {
-        readonly name: "uniFee0";
         readonly type: "int256";
+        readonly name: "uniFee0";
     }, {
-        readonly name: "uniFee1";
         readonly type: "int256";
+        readonly name: "uniFee1";
     }];
 }];
 export declare const QUOTER_ABI: readonly [{