@coinbase/agentkit 0.10.1 → 0.10.2

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

@@ -1,12 +1,4 @@
 "use strict";
-/**
- * Flaunch Action Provider
- *
- * This file contains the implementation of the FlaunchActionProvider,
- * which provides actions for flaunch operations.
- *
- * @module flaunch
- */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -26,7 +18,9 @@ const wallet_providers_1 = require("../../wallet-providers");
 const viem_1 = require("viem");
 const chains_1 = require("viem/chains");
 const schemas_1 = require("./schemas");
-const utils_1 = require("./utils");
+const metadata_utils_1 = require("./metadata_utils");
+const client_utils_1 = require("./client_utils");
+const swap_utils_1 = require("./swap_utils");
 const constants_1 = require("./constants");
 const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
 /**
@@ -34,33 +28,21 @@ const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
  *
  * @description
  * This provider is designed to work with EvmWalletProvider for blockchain interactions.
- * It supports all evm networks.
  */
 class FlaunchActionProvider extends actionProvider_1.ActionProvider {
     /**
      * Constructor for the FlaunchActionProvider.
      *
-     * @param config - The configuration options for the FlaunchActionProvider.
      */
-    constructor(config = {}) {
+    constructor() {
         super("flaunch", []);
-        const pinataJwt = config.pinataJwt || process.env.PINATA_JWT;
-        if (!pinataJwt) {
-            throw new Error("PINATA_JWT is not configured.");
-        }
-        this.pinataJwt = pinataJwt;
     }
     /**
-     * Example action implementation.
-     * Replace or modify this with your actual action.
-     *
-     * @description
-     * This is a template action that demonstrates the basic structure.
-     * Replace it with your actual implementation.
+     * Launches a new memecoin using the flaunch protocol.
      *
      * @param walletProvider - The wallet provider instance for blockchain interactions
      * @param args - Arguments defined by FlaunchSchema
-     * @returns A promise that resolves to a string describing the action result
+     * @returns A promise that resolves to a string describing the transaction result
      */
     async flaunch(walletProvider, args) {
         try {
@@ -70,11 +52,34 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
             if (!chainId || !networkId) {
                 throw new Error("Chain ID is not set.");
             }
-            // upload image & token uri to ipfs
-            const tokenUri = await (0, utils_1.generateTokenUri)(args.name, {
-                pinataConfig: { jwt: this.pinataJwt },
+            // Validate that premineAmount does not exceed fairLaunchPercent
+            if (args.preminePercent > args.fairLaunchPercent) {
+                throw new Error(`premineAmount (${args.preminePercent}%) cannot exceed fairLaunchPercent (${args.fairLaunchPercent}%)`);
+            }
+            // Prepare launch parameters
+            const initialMCapInUSDCWei = (0, viem_1.parseUnits)(args.initialMarketCapUSD.toString(), 6);
+            const initialPriceParams = (0, viem_1.encodeAbiParameters)([{ type: "uint256" }], [initialMCapInUSDCWei]);
+            const fairLaunchInBps = BigInt(args.fairLaunchPercent * 100);
+            // Convert premine percentage to token amount and calculate ETH required
+            const premineAmount = (constants_1.TOTAL_SUPPLY * BigInt(Math.floor(args.preminePercent * 100))) / 10000n;
+            const ethRequired = args.preminePercent > 0
+                ? await (0, client_utils_1.ethRequiredToFlaunch)(walletProvider, {
+                    premineAmount,
+                    initialPriceParams,
+                    slippagePercent: 5,
+                })
+                : 0n;
+            // Check ETH balance
+            if (ethRequired > 0n) {
+                const ethBalance = await walletProvider.getBalance();
+                if (ethBalance < ethRequired) {
+                    throw new Error(`Insufficient ETH balance. Required: ${(0, viem_1.formatEther)(ethRequired)} ETH, Available: ${(0, viem_1.formatEther)(ethBalance)} ETH`);
+                }
+            }
+            // Upload image & token uri to ipfs
+            const tokenUri = await (0, metadata_utils_1.generateTokenUri)(args.name, args.symbol, {
                 metadata: {
-                    imageUrl: args.imageUrl,
+                    image: args.image,
                     description: args.description,
                     websiteUrl: args.websiteUrl,
                     discordUrl: args.discordUrl,
@@ -82,42 +87,92 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
                     telegramUrl: args.telegramUrl,
                 },
             });
+            // Fee split configuration
+            const creatorFeeAllocationInBps = args.creatorFeeAllocationPercent * 100;
+            let creatorShare = 10000000n;
+            let recipientShares = [];
+            if (args.creatorSplitPercent !== undefined && args.splitReceivers !== undefined) {
+                const VALID_SHARE_TOTAL = 10000000n; // 5 decimals as BigInt, 100 * 10^5
+                creatorShare = (BigInt(args.creatorSplitPercent) * VALID_SHARE_TOTAL) / 100n;
+                recipientShares = args.splitReceivers.map(receiver => {
+                    return {
+                        recipient: receiver.address,
+                        share: (BigInt(receiver.percent) * VALID_SHARE_TOTAL) / 100n,
+                    };
+                });
+                const totalRecipientShares = recipientShares.reduce((acc, curr) => acc + curr.share, 0n);
+                const totalRecipientPercent = (totalRecipientShares * 100n) / VALID_SHARE_TOTAL;
+                // Check that recipient shares add up to 100%
+                if (totalRecipientPercent !== 100n) {
+                    throw new Error(`Recipient shares must add up to exactly 100%, but they add up to ${totalRecipientPercent}%`);
+                }
+                const remainderShares = VALID_SHARE_TOTAL - totalRecipientShares;
+                creatorShare += remainderShares;
+            }
+            const initializeData = (0, viem_1.encodeAbiParameters)([
+                {
+                    type: "tuple",
+                    name: "params",
+                    components: [
+                        { type: "uint256", name: "creatorShare" },
+                        {
+                            type: "tuple[]",
+                            name: "recipientShares",
+                            components: [
+                                { type: "address", name: "recipient" },
+                                { type: "uint256", name: "share" },
+                            ],
+                        },
+                    ],
+                },
+            ], [
+                {
+                    creatorShare,
+                    recipientShares,
+                },
+            ]);
+            const flaunchParams = {
+                name: args.name,
+                symbol: args.symbol,
+                tokenUri,
+                initialTokenFairLaunch: (constants_1.TOTAL_SUPPLY * fairLaunchInBps) / 10000n,
+                fairLaunchDuration: BigInt(args.fairLaunchDuration * 60),
+                premineAmount,
+                creator: walletProvider.getAddress(),
+                creatorFeeAllocation: creatorFeeAllocationInBps,
+                flaunchAt: 0n,
+                initialPriceParams,
+                feeCalculatorParams: "0x",
+            };
+            const treasuryManagerParams = {
+                manager: constants_1.AddressFeeSplitManagerAddress[chainId],
+                initializeData,
+                depositData: "0x",
+            };
+            const whitelistParams = {
+                merkleRoot: viem_1.zeroHash,
+                merkleIPFSHash: "",
+                maxTokens: 0n,
+            };
+            const airdropParams = {
+                airdropIndex: 0n,
+                airdropAmount: 0n,
+                airdropEndTime: 0n,
+                merkleRoot: viem_1.zeroHash,
+                merkleIPFSHash: "",
+            };
             const data = (0, viem_1.encodeFunctionData)({
-                abi: constants_1.FAST_FLAUNCH_ZAP_ABI,
+                abi: constants_1.FLAUNCH_ZAP_ABI,
                 functionName: "flaunch",
-                args: [
-                    {
-                        name: args.name,
-                        symbol: args.symbol,
-                        tokenUri,
-                        creator: walletProvider.getAddress(),
-                    },
-                ],
+                args: [flaunchParams, whitelistParams, airdropParams, treasuryManagerParams],
             });
             const hash = await walletProvider.sendTransaction({
-                to: constants_1.FastFlaunchZapAddress[chainId],
+                to: constants_1.FlaunchZapAddress[chainId],
                 data,
+                value: ethRequired,
             });
             const receipt = await walletProvider.waitForTransactionReceipt(hash);
-            const filteredPoolCreatedEvent = receipt.logs
-                .map(log => {
-                try {
-                    if (log.address.toLowerCase() !== constants_1.FlaunchPositionManagerAddress[chainId].toLowerCase()) {
-                        return null;
-                    }
-                    const event = (0, viem_1.decodeEventLog)({
-                        abi: constants_1.POSITION_MANAGER_ABI,
-                        data: log.data,
-                        topics: log.topics,
-                    });
-                    return event.eventName === "PoolCreated" ? event.args : null;
-                }
-                catch {
-                    return null;
-                }
-            })
-                .filter((event) => event !== null)[0];
-            const memecoinAddress = filteredPoolCreatedEvent._memecoin;
+            const memecoinAddress = (0, client_utils_1.getMemecoinAddressFromReceipt)(receipt, chainId);
             const chainSlug = Number(chainId) === chains_1.base.id ? "base" : "base-sepolia";
             return `Flaunched\n ${JSON.stringify({
                 coinSymbol: `$${args.symbol}`,
@@ -140,7 +195,7 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
      * @returns A promise that resolves to a string describing the transaction result
      */
     async buyCoinWithETHInput(walletProvider, args) {
-        return this._buyFlaunchCoin(walletProvider, args.coinAddress, "EXACT_IN", { amountIn: args.amountIn }, args.slippagePercent);
+        return (0, swap_utils_1.buyFlaunchCoin)(walletProvider, args.coinAddress, "EXACT_IN", { amountIn: args.amountIn }, args.slippagePercent);
     }
     /**
      * Buys a flaunch coin using Coin input.
@@ -150,7 +205,7 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
      * @returns A promise that resolves to a string describing the transaction result
      */
     async buyCoinWithCoinInput(walletProvider, args) {
-        return this._buyFlaunchCoin(walletProvider, args.coinAddress, "EXACT_OUT", { amountOut: args.amountOut }, args.slippagePercent);
+        return (0, swap_utils_1.buyFlaunchCoin)(walletProvider, args.coinAddress, "EXACT_OUT", { amountOut: args.amountOut }, args.slippagePercent);
     }
     /**
      * Sells a flaunch coin into ETH.
@@ -221,7 +276,7 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
                             {
                                 fee: 0,
                                 tickSpacing: 60,
-                                hooks: constants_1.FlaunchPositionManagerAddress[chainId],
+                                hooks: constants_1.FlaunchPositionManagerV1_1Address[chainId],
                                 hookData: "0x",
                                 intermediateCurrency: constants_1.FLETHAddress[chainId],
                             },
@@ -236,9 +291,9 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
                     },
                 ],
             });
-            const ethOutMin = (0, utils_1.getAmountWithSlippage)(quoteResult.result[0], // amountOut
+            const ethOutMin = (0, swap_utils_1.getAmountWithSlippage)(quoteResult.result[0], // amountOut
             (args.slippagePercent / 100).toFixed(18).toString(), "EXACT_IN");
-            const { commands, inputs } = (0, utils_1.memecoinToEthWithPermit2)({
+            const { commands, inputs } = (0, swap_utils_1.memecoinToEthWithPermit2)({
                 chainId: Number(chainId),
                 memecoin: args.coinAddress,
                 amountIn,
@@ -257,7 +312,7 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
                 data,
             });
             const receipt = await walletProvider.waitForTransactionReceipt(hash);
-            const swapAmounts = (0, utils_1.getSwapAmountsFromReceipt)({
+            const swapAmounts = (0, swap_utils_1.getSwapAmountsFromReceipt)({
                 receipt,
                 coinAddress: args.coinAddress,
                 chainId: Number(chainId),
@@ -284,134 +339,6 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
         // all protocol networks
         return network.protocolFamily === "evm" && SUPPORTED_NETWORKS.includes(network.networkId);
     }
-    /**
-     * Handles the process of buying a flaunch coin with ETH.
-     *
-     * @param walletProvider - The wallet provider instance
-     * @param coinAddress - The address of the flaunch coin
-     * @param swapType - The type of swap (EXACT_IN or EXACT_OUT)
-     * @param swapParams - Parameters specific to the swap type
-     * @param swapParams.amountIn - The amount of ETH to spend (for EXACT_IN)
-     * @param swapParams.amountOut - The amount of coins to buy (for EXACT_OUT)
-     * @param slippagePercent - The slippage percentage
-     * @returns A promise that resolves to a string describing the transaction result
-     */
-    async _buyFlaunchCoin(walletProvider, coinAddress, swapType, swapParams, slippagePercent) {
-        const network = walletProvider.getNetwork();
-        const chainId = network.chainId;
-        const networkId = network.networkId;
-        if (!chainId || !networkId) {
-            throw new Error("Chain ID is not set.");
-        }
-        try {
-            let amountIn;
-            let amountOutMin;
-            let amountOut;
-            let amountInMax;
-            if (swapType === "EXACT_IN") {
-                amountIn = (0, viem_1.parseEther)(swapParams.amountIn);
-                const quoteResult = await walletProvider.getPublicClient().simulateContract({
-                    address: constants_1.QuoterAddress[chainId],
-                    abi: constants_1.QUOTER_ABI,
-                    functionName: "quoteExactInput",
-                    args: [
-                        {
-                            exactAmount: amountIn,
-                            exactCurrency: viem_1.zeroAddress, // ETH
-                            path: [
-                                {
-                                    fee: 0,
-                                    tickSpacing: 60,
-                                    hookData: "0x",
-                                    hooks: constants_1.FLETHHooksAddress[chainId],
-                                    intermediateCurrency: constants_1.FLETHAddress[chainId],
-                                },
-                                {
-                                    fee: 0,
-                                    tickSpacing: 60,
-                                    hooks: constants_1.FlaunchPositionManagerAddress[chainId],
-                                    hookData: "0x",
-                                    intermediateCurrency: coinAddress,
-                                },
-                            ],
-                        },
-                    ],
-                });
-                amountOutMin = (0, utils_1.getAmountWithSlippage)(quoteResult.result[0], // amountOut
-                (slippagePercent / 100).toFixed(18).toString(), swapType);
-            }
-            else {
-                // EXACT_OUT
-                amountOut = (0, viem_1.parseEther)(swapParams.amountOut);
-                const quoteResult = await walletProvider.getPublicClient().simulateContract({
-                    address: constants_1.QuoterAddress[chainId],
-                    abi: constants_1.QUOTER_ABI,
-                    functionName: "quoteExactOutput",
-                    args: [
-                        {
-                            path: [
-                                {
-                                    intermediateCurrency: viem_1.zeroAddress,
-                                    fee: 0,
-                                    tickSpacing: 60,
-                                    hookData: "0x",
-                                    hooks: constants_1.FLETHHooksAddress[chainId],
-                                },
-                                {
-                                    intermediateCurrency: constants_1.FLETHAddress[chainId],
-                                    fee: 0,
-                                    tickSpacing: 60,
-                                    hooks: constants_1.FlaunchPositionManagerAddress[chainId],
-                                    hookData: "0x",
-                                },
-                            ],
-                            exactCurrency: coinAddress,
-                            exactAmount: amountOut,
-                        },
-                    ],
-                });
-                amountInMax = (0, utils_1.getAmountWithSlippage)(quoteResult.result[0], // amountIn
-                (slippagePercent / 100).toFixed(18).toString(), swapType);
-            }
-            const { commands, inputs } = (0, utils_1.ethToMemecoin)({
-                sender: walletProvider.getAddress(),
-                memecoin: coinAddress,
-                chainId: Number(chainId),
-                referrer: viem_1.zeroAddress,
-                swapType,
-                amountIn,
-                amountOutMin,
-                amountOut,
-                amountInMax,
-            });
-            const data = (0, viem_1.encodeFunctionData)({
-                abi: constants_1.UNIVERSAL_ROUTER_ABI,
-                functionName: "execute",
-                args: [commands, inputs],
-            });
-            const hash = await walletProvider.sendTransaction({
-                to: constants_1.UniversalRouterAddress[chainId],
-                data,
-                value: swapType === "EXACT_IN" ? amountIn : amountInMax,
-            });
-            const receipt = await walletProvider.waitForTransactionReceipt(hash);
-            const swapAmounts = (0, utils_1.getSwapAmountsFromReceipt)({
-                receipt,
-                coinAddress: coinAddress,
-                chainId: Number(chainId),
-            });
-            const coinSymbol = await walletProvider.readContract({
-                address: coinAddress,
-                abi: constants_1.ERC20_ABI,
-                functionName: "symbol",
-            });
-            return `Bought ${(0, viem_1.formatEther)(swapAmounts.coinsBought)} $${coinSymbol} for ${(0, viem_1.formatEther)(swapAmounts.ethSold)} ETH\n
-        Tx hash: [${hash}](${network_1.NETWORK_ID_TO_VIEM_CHAIN[networkId].blockExplorers?.default.url}/tx/${hash})`;
-        }
-        catch (error) {
-            return `Error buying coin: ${error}`;
-        }
-    }
 }
 exports.FlaunchActionProvider = FlaunchActionProvider;
 __decorate([
@@ -423,16 +350,22 @@ This tool allows launching a new memecoin using the flaunch protocol.
 It takes:
 - name: The name of the token
 - symbol: The symbol of the token
-- imageUrl: URL to the token image
+- image: Local image file path or URL to the token image
 - description: Description of the token
-
-- websiteUrl: (optional) URL to the token website
-- discordUrl: (optional) URL to the token Discord
-- twitterUrl: (optional) URL to the token Twitter
-- telegramUrl: (optional) URL to the token Telegram
+- fairLaunchPercent: The percentage of tokens for fair launch (defaults to 60%)
+- fairLaunchDuration: The duration of the fair launch in minutes (defaults to 30 minutes)
+- initialMarketCapUSD: The initial market cap in USD (defaults to 10000 USD)
+- preminePercent: The percentage of total supply to premine (defaults to 0%, max is equal to fairLaunchPercent)
+- creatorFeeAllocationPercent: The percentage of fees allocated to creator and optional receivers (defaults to 80%)
+- creatorSplitPercent: The percentage of fees allocated to the creator (defaults to 100%), remainder goes to fee split recipients
+- splitReceivers: Array of fee split recipients with address and percentage (optional)
+- websiteUrl: URL to the token website (optional)
+- discordUrl: URL to the token Discord (optional)
+- twitterUrl: URL to the token Twitter (optional)
+- telegramUrl: URL to the token Telegram (optional)
 
 Note:
-- If the optional fields are not provided, don't include them in the call.
+- splitReceivers must add up to exactly 100% if provided.
     `,
         schema: schemas_1.FlaunchSchema,
     }),
@@ -504,8 +437,7 @@ It takes:
 /**
  * Factory function to create a new FlaunchActionProvider instance.
  *
- * @param config - Configuration options for the FlaunchActionProvider
  * @returns A new FlaunchActionProvider instance
  */
-const flaunchActionProvider = (config) => new FlaunchActionProvider(config);
+const flaunchActionProvider = () => new FlaunchActionProvider();
 exports.flaunchActionProvider = flaunchActionProvider;

package/dist/action-providers/flaunch/flaunchActionProvider.test.js

@@ -1,8 +1,42 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const flaunchActionProvider_1 = require("./flaunchActionProvider");
 const schemas_1 = require("./schemas");
 const viem_1 = require("viem");
+const swapUtils = __importStar(require("./swap_utils"));
 // Mock the actual contract calls with Jest
 jest.mock("viem", () => {
     const originalModule = jest.requireActual("viem");
@@ -22,27 +56,54 @@ jest.mock("viem", () => {
             };
         }),
         parseEther: jest.fn().mockReturnValue(BigInt(100000000000000000)),
+        parseUnits: jest.fn().mockReturnValue(BigInt(100000000000000000)),
+        encodeAbiParameters: jest.fn().mockReturnValue("0xencoded"),
+        encodeFunctionData: jest.fn().mockReturnValue("0xfunctiondata"),
         zeroAddress: "0x0000000000000000000000000000000000000000",
+        zeroHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
     };
 });
-// Mock the utils module
-jest.mock("./utils", () => ({
+// Mock the metadata_utils module
+jest.mock("./metadata_utils", () => ({
     generateTokenUri: jest.fn().mockResolvedValue("ipfs://test-uri"),
-    ethToMemecoin: jest.fn().mockReturnValue({
-        commands: "0x01",
-        inputs: ["0x1234"],
-    }),
+}));
+// Mock the client_utils module
+jest.mock("./client_utils", () => ({
+    ethRequiredToFlaunch: jest.fn().mockResolvedValue(BigInt(100000000000000000)),
+    getMemecoinAddressFromReceipt: jest
+        .fn()
+        .mockReturnValue("0x1234567890123456789012345678901234567890"),
+}));
+// Mock the swap_utils module
+jest.mock("./swap_utils", () => ({
+    getAmountWithSlippage: jest.fn().mockImplementation(amount => amount),
     memecoinToEthWithPermit2: jest.fn().mockReturnValue({
         commands: "0x02",
         inputs: ["0x5678"],
     }),
-    getAmountWithSlippage: jest.fn().mockImplementation(amount => amount),
     getSwapAmountsFromReceipt: jest.fn().mockImplementation(() => ({
         coinsBought: BigInt(1000000000000000000),
         ethSold: BigInt(100000000000000000),
         coinsSold: BigInt(1000000000000000000),
         ethBought: BigInt(100000000000000000),
     })),
+    buyFlaunchCoin: jest
+        .fn()
+        .mockImplementation(async (walletProvider, coinAddress, _swapType, _amount, _slippagePercent) => {
+        // Simulate the actual behavior by calling wallet provider methods
+        walletProvider.getNetwork();
+        const coinSymbol = await walletProvider.readContract({
+            address: coinAddress,
+            abi: [],
+            functionName: "symbol",
+        });
+        const hash = await walletProvider.sendTransaction({
+            to: coinAddress,
+            data: "0x",
+        });
+        await walletProvider.waitForTransactionReceipt(hash);
+        return `Bought ${(0, viem_1.formatEther)(BigInt(1000000000000000000))} $${coinSymbol} for ${(0, viem_1.formatEther)(BigInt(100000000000000000))} ETH`;
+    }),
 }));
 // Mock the constants used in the test
 jest.mock("./constants", () => {
@@ -85,7 +146,7 @@ jest.mock("./constants", () => {
     };
 });
 describe("FlaunchActionProvider", () => {
-    const provider = new flaunchActionProvider_1.FlaunchActionProvider({ pinataJwt: "test-jwt" });
+    const provider = new flaunchActionProvider_1.FlaunchActionProvider();
     let mockWalletProvider;
     beforeEach(() => {
         mockWalletProvider = {
@@ -155,9 +216,10 @@ describe("FlaunchActionProvider", () => {
             const validInput = {
                 name: "Test Token",
                 symbol: "TEST",
-                imageUrl: "https://example.com/image.png",
+                image: "https://example.com/image.png",
                 description: "A test token",
                 websiteUrl: "https://example.com",
+                premineAmount: 5,
             };
             const parseResult = schemas_1.FlaunchSchema.safeParse(validInput);
             expect(parseResult.success).toBe(true);
@@ -166,8 +228,9 @@ describe("FlaunchActionProvider", () => {
             const invalidInput = {
                 name: "",
                 symbol: "",
-                imageUrl: "not-a-url",
+                image: "not-a-url",
                 description: "",
+                premineAmount: 150, // Invalid: exceeds 100%
             };
             const parseResult = schemas_1.FlaunchSchema.safeParse(invalidInput);
             expect(parseResult.success).toBe(false);
@@ -205,9 +268,21 @@ describe("FlaunchActionProvider", () => {
             const args = {
                 name: "Test Token",
                 symbol: "TEST",
-                imageUrl: "https://example.com/image.png",
+                image: "https://example.com/image.png",
                 description: "A test token",
                 websiteUrl: "https://example.com",
+                fairLaunchPercent: 60,
+                fairLaunchDuration: 30,
+                initialMarketCapUSD: 10000,
+                creatorFeeAllocationPercent: 80,
+                creatorSplitPercent: 50,
+                splitReceivers: [
+                    {
+                        address: "0x1234567890123456789012345678901234567890",
+                        percent: 100,
+                    },
+                ],
+                preminePercent: 5,
             };
             const result = await provider.flaunch(mockWalletProvider, args);
             console.log("Test result:", result);
@@ -217,6 +292,24 @@ describe("FlaunchActionProvider", () => {
             expect(mockWalletProvider.sendTransaction).toHaveBeenCalled();
             expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalled();
         });
+        it("should reject premineAmount exceeding fairLaunchPercent", async () => {
+            const args = {
+                name: "Test Token",
+                symbol: "TEST",
+                image: "https://example.com/image.png",
+                description: "A test token",
+                websiteUrl: "https://example.com",
+                fairLaunchPercent: 60,
+                fairLaunchDuration: 30,
+                initialMarketCapUSD: 10000,
+                creatorFeeAllocationPercent: 80,
+                creatorSplitPercent: 50,
+                splitReceivers: [],
+                preminePercent: 70, // Invalid: exceeds fairLaunchPercent of 60%
+            };
+            const result = await provider.flaunch(mockWalletProvider, args);
+            expect(result).toContain("premineAmount (70%) cannot exceed fairLaunchPercent (60%)");
+        });
     });
     describe("buyCoinWithETHInput action", () => {
         it("should execute buyCoinWithETHInput action with wallet provider", async () => {
@@ -235,7 +328,8 @@ describe("FlaunchActionProvider", () => {
             expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalled();
         });
         it("should handle errors in buyCoinWithETHInput", async () => {
-            mockWalletProvider.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            // Mock buyFlaunchCoin to return an error string
+            swapUtils.buyFlaunchCoin.mockResolvedValueOnce("Error buying coin: Transaction failed");
             const args = {
                 coinAddress: "0x1234567890123456789012345678901234567890",
                 amountIn: "0.1",
@@ -262,7 +356,8 @@ describe("FlaunchActionProvider", () => {
             expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalled();
         });
         it("should handle errors in buyCoinWithCoinInput", async () => {
-            mockWalletProvider.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            // Mock buyFlaunchCoin to return an error string
+            swapUtils.buyFlaunchCoin.mockResolvedValueOnce("Error buying coin: Transaction failed");
             const args = {
                 coinAddress: "0x1234567890123456789012345678901234567890",
                 amountOut: "1000",

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

@@ -0,0 +1,12 @@
+interface TokenUriParams {
+    metadata: {
+        image: string;
+        description: string;
+        websiteUrl?: string;
+        discordUrl?: string;
+        twitterUrl?: string;
+        telegramUrl?: string;
+    };
+}
+export declare const generateTokenUri: (name: string, symbol: string, params: TokenUriParams) => Promise<string>;
+export {};