@coinbase/agentkit 0.10.0 → 0.10.2

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 {};

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

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTokenUri = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Reads a local file and converts it to base64
+ *
+ * @param imageFileName - Path to the local file
+ * @returns Base64 encoded file and mime type
+ */
+async function readFileAsBase64(imageFileName) {
+    return new Promise((resolve, reject) => {
+        fs_1.default.readFile(imageFileName, (err, data) => {
+            if (err) {
+                reject(new Error(`Failed to read file: ${err.message}`));
+                return;
+            }
+            // Determine mime type based on file extension
+            const extension = path_1.default.extname(imageFileName).toLowerCase();
+            let mimeType = "application/octet-stream"; // default
+            if (extension === ".png")
+                mimeType = "image/png";
+            else if (extension === ".jpg" || extension === ".jpeg")
+                mimeType = "image/jpeg";
+            else if (extension === ".gif")
+                mimeType = "image/gif";
+            else if (extension === ".svg")
+                mimeType = "image/svg+xml";
+            const base64 = data.toString("base64");
+            resolve({ base64, mimeType });
+        });
+    });
+}
+/**
+ * Uploads a base64 image to IPFS using Flaunch API
+ * Rate Limit: Maximum 4 image uploads per minute per IP address
+ *
+ * @param params - Configuration and base64 image data
+ * @param params.base64Image - Base64 encoded image data
+ * @param params.name - Optional name for the uploaded file
+ * @param params.metadata - Optional metadata key-value pairs
+ * @returns Upload response with CID and other details
+ */
+const uploadImageToIPFS = async (params) => {
+    try {
+        const response = await fetch("https://web2-api.flaunch.gg/api/v1/upload-image", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ base64Image: params.base64Image }),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to upload image to IPFS: ${error.message || response.statusText}`);
+        }
+        const data = await response.json();
+        if (!data.success) {
+            throw new Error(`Failed to upload image to IPFS: ${data.error || "Unknown error"}`);
+        }
+        return {
+            IpfsHash: data.ipfsHash,
+            tokenURI: data.tokenURI,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to upload image to IPFS: ${error.message}`);
+        }
+        throw error;
+    }
+};
+/**
+ * Uploads JSON data to IPFS using Flaunch API
+ *
+ * @param params - Configuration and JSON data
+ * @param params.json - JSON data to upload
+ * @param params.name - Optional name for the uploaded file
+ * @param params.metadata - Optional metadata key-value pairs
+ * @returns Upload response with CID and other details
+ */
+const uploadJsonToIPFS = async (params) => {
+    try {
+        const response = await fetch("https://web2-api.flaunch.gg/api/v1/upload-metadata", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                name: params.json.name,
+                symbol: params.json.symbol,
+                description: params.json.description,
+                imageIpfs: params.json.image,
+                websiteUrl: params.json.external_link,
+                discordUrl: params.json.discordUrl,
+                twitterUrl: params.json.twitterUrl,
+                telegramUrl: params.json.telegramUrl,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to upload JSON to IPFS: ${error.message || response.statusText}`);
+        }
+        const data = await response.json();
+        if (!data.success) {
+            throw new Error(`Failed to upload metadata: ${data.error}`);
+        }
+        return {
+            IpfsHash: data.ipfsHash,
+            tokenURI: data.tokenURI,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to upload JSON to IPFS: ${error.message}`);
+        }
+        throw error;
+    }
+};
+/**
+ * Converts a remote image URL to a properly formatted base64 data URL
+ *
+ * @param imageUrl - URL of the image to fetch and convert
+ * @returns Base64 data URL with proper MIME type detection
+ */
+const convertImageUrlToBase64 = async (imageUrl) => {
+    try {
+        const response = await fetch(imageUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch image: ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const base64Data = Buffer.from(arrayBuffer).toString("base64");
+        // Detect MIME type from response headers
+        const contentType = response.headers.get("content-type");
+        let mimeType = "image/jpeg"; // default fallback
+        if (contentType && contentType.startsWith("image/")) {
+            mimeType = contentType;
+        }
+        else {
+            // Try to detect from URL extension as fallback
+            const urlLower = imageUrl.toLowerCase();
+            if (urlLower.includes(".png")) {
+                mimeType = "image/png";
+            }
+            else if (urlLower.includes(".gif")) {
+                mimeType = "image/gif";
+            }
+            else if (urlLower.includes(".webp")) {
+                mimeType = "image/webp";
+            }
+            else if (urlLower.includes(".svg")) {
+                mimeType = "image/svg+xml";
+            }
+        }
+        return `data:${mimeType};base64,${base64Data}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to convert image URL to base64: ${error.message}`);
+        }
+        throw error;
+    }
+};
+const generateTokenUriBase64Image = async (name, symbol, params) => {
+    // 1. upload image to IPFS
+    const imageRes = await uploadImageToIPFS({
+        base64Image: params.metadata.base64Image,
+    });
+    // 2. upload metadata to IPFS
+    const coinMetadata = {
+        name,
+        symbol,
+        description: params.metadata.description,
+        image: `ipfs://${imageRes.IpfsHash}`,
+        external_link: params.metadata.websiteUrl || "",
+        collaborators: [],
+        discordUrl: params.metadata.discordUrl || "",
+        twitterUrl: params.metadata.twitterUrl || "",
+        telegramUrl: params.metadata.telegramUrl || "",
+    };
+    const metadataRes = await uploadJsonToIPFS({
+        json: coinMetadata,
+    });
+    return `ipfs://${metadataRes.IpfsHash}`;
+};
+const generateTokenUri = async (name, symbol, params) => {
+    // 1. get base64Image from image (url or local path)
+    let base64Image;
+    const image = params.metadata.image;
+    if (image.startsWith("https://") || image.startsWith("http://")) {
+        base64Image = await convertImageUrlToBase64(image);
+    }
+    else {
+        // assume local file
+        const { base64, mimeType } = await readFileAsBase64(image);
+        base64Image = `data:${mimeType};base64,${base64}`;
+    }
+    // 2. generate token uri
+    const tokenUri = await generateTokenUriBase64Image(name, symbol, {
+        metadata: {
+            base64Image,
+            description: params.metadata.description,
+            websiteUrl: params.metadata.websiteUrl,
+            discordUrl: params.metadata.discordUrl,
+            twitterUrl: params.metadata.twitterUrl,
+            telegramUrl: params.metadata.telegramUrl,
+        },
+    });
+    return tokenUri;
+};
+exports.generateTokenUri = generateTokenUri;

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

@@ -11,30 +11,66 @@ import { z } from "zod";
 export declare const FlaunchSchema: z.ZodObject<{
     name: z.ZodString;
     symbol: z.ZodString;
-    imageUrl: z.ZodString;
+    image: z.ZodString;
     description: z.ZodString;
     websiteUrl: z.ZodOptional<z.ZodString>;
     discordUrl: z.ZodOptional<z.ZodString>;
     twitterUrl: z.ZodOptional<z.ZodString>;
     telegramUrl: z.ZodOptional<z.ZodString>;
+    fairLaunchPercent: z.ZodDefault<z.ZodNumber>;
+    fairLaunchDuration: z.ZodDefault<z.ZodNumber>;
+    initialMarketCapUSD: z.ZodDefault<z.ZodNumber>;
+    creatorFeeAllocationPercent: z.ZodDefault<z.ZodNumber>;
+    creatorSplitPercent: z.ZodDefault<z.ZodNumber>;
+    splitReceivers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        percent: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        percent: number;
+    }, {
+        address: string;
+        percent: number;
+    }>, "many">>;
+    preminePercent: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     symbol: string;
     name: string;
     description: string;
-    imageUrl: string;
+    image: string;
+    fairLaunchPercent: number;
+    fairLaunchDuration: number;
+    initialMarketCapUSD: number;
+    creatorFeeAllocationPercent: number;
+    creatorSplitPercent: number;
+    preminePercent: number;
     websiteUrl?: string | undefined;
     discordUrl?: string | undefined;
     twitterUrl?: string | undefined;
     telegramUrl?: string | undefined;
+    splitReceivers?: {
+        address: string;
+        percent: number;
+    }[] | undefined;
 }, {
     symbol: string;
     name: string;
     description: string;
-    imageUrl: string;
+    image: string;
     websiteUrl?: string | undefined;
     discordUrl?: string | undefined;
     twitterUrl?: string | undefined;
     telegramUrl?: string | undefined;
+    fairLaunchPercent?: number | undefined;
+    fairLaunchDuration?: number | undefined;
+    initialMarketCapUSD?: number | undefined;
+    creatorFeeAllocationPercent?: number | undefined;
+    creatorSplitPercent?: number | undefined;
+    splitReceivers?: {
+        address: string;
+        percent: number;
+    }[] | undefined;
+    preminePercent?: number | undefined;
 }>;
 export declare const BuyCoinWithETHInputSchema: z.ZodObject<{
     coinAddress: z.ZodString;

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

@@ -11,16 +11,68 @@ const zod_1 = require("zod");
 /**
  * Schema for Flaunch token creation
  */
-exports.FlaunchSchema = zod_1.z.object({
-    name: zod_1.z.string().min(1).describe("The name of the token"),
-    symbol: zod_1.z.string().min(1).describe("The symbol of the token"),
-    imageUrl: zod_1.z.string().url().describe("The URL to the token image"),
-    description: zod_1.z.string().describe("The description of the token"),
-    websiteUrl: zod_1.z.string().url().optional().describe("The (optional) URL to the token website"),
-    discordUrl: zod_1.z.string().url().optional().describe("The (optional) URL to the token Discord"),
-    twitterUrl: zod_1.z.string().url().optional().describe("The (optional) URL to the token Twitter"),
-    telegramUrl: zod_1.z.string().url().optional().describe("The (optional) URL to the token Telegram"),
-});
+exports.FlaunchSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().min(1).describe("The name of the token to flaunch"),
+    symbol: zod_1.z.string().min(1).describe("The symbol of the token to flaunch"),
+    image: zod_1.z.string().describe("Local image file path or URL to the token image"),
+    description: zod_1.z.string().describe("Description of the token"),
+    websiteUrl: zod_1.z.string().optional().describe("URL to the token website"),
+    discordUrl: zod_1.z.string().optional().describe("URL to the token Discord"),
+    twitterUrl: zod_1.z.string().optional().describe("URL to the token Twitter"),
+    telegramUrl: zod_1.z.string().optional().describe("URL to the token Telegram"),
+    fairLaunchPercent: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(60)
+        .describe("The percentage of tokens for fair launch (defaults to 60%)"),
+    fairLaunchDuration: zod_1.z
+        .number()
+        .min(0)
+        .default(30)
+        .describe("The duration of the fair launch in minutes (defaults to 30 minutes)"),
+    initialMarketCapUSD: zod_1.z
+        .number()
+        .min(100)
+        .max(100000)
+        .default(10000)
+        .describe("The initial market cap in USD (defaults to 10000 USD)"),
+    creatorFeeAllocationPercent: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(80)
+        .describe("The percentage of the fees allocated to the creator and optional additional receivers (defaults to 80%). Remainder goes to community via token buy backs"),
+    creatorSplitPercent: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(100)
+        .describe("The percentage of the fees allocated to the creator. Defaults to 100%, set to smaller value if fees are to be distributed to additional receivers"),
+    splitReceivers: zod_1.z
+        .array(zod_1.z.object({
+        address: zod_1.z
+            .string()
+            .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+            .describe("The recipient's address"),
+        percent: zod_1.z
+            .number()
+            .min(0)
+            .max(100)
+            .describe("The percentage share for the recipient. All split receiver percentages must add up to 100%"),
+    }))
+        .optional()
+        .describe("The recipients for the fee split (optional)"),
+    preminePercent: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(0)
+        .describe("The percentage of total supply to premine (defaults to 0%, max is equal to fairLaunchPercent)"),
+})
+    .strip()
+    .describe("Instructions for creating a new memecoin using the flaunch protocol.");
 exports.BuyCoinWithETHInputSchema = zod_1.z.object({
     coinAddress: zod_1.z
         .string()

package/dist/action-providers/flaunch/{utils.d.ts → swap_utils.d.ts}

@@ -1,23 +1,6 @@
 import { Address, Hex, TransactionReceipt } from "viem";
 import { BuySwapAmounts, SellSwapAmounts, PermitSingle, PoolSwapEventArgs } from "./types";
-/**
- * Configuration for Pinata
- */
-interface PinataConfig {
-    jwt: string;
-}
-interface TokenUriParams {
-    metadata: {
-        imageUrl: string;
-        description: string;
-        websiteUrl?: string;
-        discordUrl?: string;
-        twitterUrl?: string;
-        telegramUrl?: string;
-    };
-    pinataConfig: PinataConfig;
-}
-export declare const generateTokenUri: (name: string, params: TokenUriParams) => Promise<string>;
+import { EvmWalletProvider } from "../../wallet-providers";
 export declare const getAmountWithSlippage: (amount: bigint | undefined, slippage: string, swapType: "EXACT_IN" | "EXACT_OUT") => bigint;
 export declare const ethToMemecoin: (params: {
     sender: Address;
@@ -57,4 +40,19 @@ export declare const getSwapAmountsFromReceipt: ({ receipt, coinAddress, chainId
     coinAddress: Address;
     chainId: number;
 }) => BuySwapAmounts | SellSwapAmounts;
-export {};
+/**
+ * Buys a flaunch coin using ETH input.
+ *
+ * @param walletProvider - The wallet provider instance for blockchain interactions
+ * @param coinAddress - The address of the coin to buy
+ * @param swapType - The type of swap to perform
+ * @param swapParams - The parameters for the swap
+ * @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
+ */
+export declare function buyFlaunchCoin(walletProvider: EvmWalletProvider, coinAddress: string, swapType: "EXACT_IN" | "EXACT_OUT", swapParams: {
+    amountIn?: string;
+    amountOut?: string;
+}, slippagePercent: number): Promise<string>;