@coinbase/agentkit 0.9.0 → 0.9.1

package/dist/action-providers/weth/wethActionProvider.js

@@ -58,6 +58,30 @@ class WethActionProvider extends actionProvider_1.ActionProvider {
             return `Error wrapping ETH: ${error}`;
         }
     }
+    /**
+     * Unwraps WETH to ETH.
+     *
+     * @param walletProvider - The wallet provider to use for the action.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transaction hash.
+     */
+    async unwrapEth(walletProvider, args) {
+        try {
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.WETH_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WETH_ABI,
+                    functionName: "withdraw",
+                    args: [BigInt(args.amountToUnwrap)],
+                }),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Unwrapped WETH with transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error unwrapping WETH: ${error}`;
+        }
+    }
 }
 exports.WethActionProvider = WethActionProvider;
 __decorate([
@@ -74,7 +98,7 @@ Important notes:
 - The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
 - Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action.
 - 1 wei = 0.000000000000000001 WETH
-- Minimum purchase amount is 100000000000000 wei (0.0000001 WETH)
+- Minimum purchase amount is 100000000000 wei (0.0000001 WETH)
 - Only supported on the following networks:
   - Base Sepolia (ie, 'base-sepolia')
   - Base Mainnet (ie, 'base', 'base-mainnet')
@@ -85,5 +109,30 @@ Important notes:
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], WethActionProvider.prototype, "wrapEth", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "unwrap_eth",
+        description: `
+    This tool can only be used to unwrap WETH to ETH.
+Do not use this tool for any other purpose, or trading other assets.
+
+Inputs:
+- Amount of WETH to unwrap.
+
+Important notes:
+- The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
+- Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action.
+- 1 wei = 0.000000000000000001 WETH
+- Minimum unwrap amount is 100000000000 wei (0.0000001 WETH)
+- Only supported on the following networks:
+  - Base Sepolia (ie, 'base-sepolia')
+  - Base Mainnet (ie, 'base', 'base-mainnet')
+`,
+        schema: schemas_1.UnwrapEthSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WethActionProvider.prototype, "unwrapEth", null);
 const wethActionProvider = () => new WethActionProvider();
 exports.wethActionProvider = wethActionProvider;

package/dist/action-providers/weth/wethActionProvider.test.js

@@ -21,6 +21,21 @@ describe("Wrap Eth Schema", () => {
         expect(result.success).toBe(false);
     });
 });
+describe("Unwrap Eth Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const result = schemas_1.UnwrapEthSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.UnwrapEthSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
 describe("Wrap Eth Action", () => {
     let mockWallet;
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
@@ -66,6 +81,51 @@ describe("Wrap Eth Action", () => {
         expect(response).toContain(`Error wrapping ETH: ${error}`);
     });
 });
+describe("Unwrap Eth Action", () => {
+    let mockWallet;
+    const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
+    beforeEach(async () => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+        };
+    });
+    it("should successfully respond", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const hash = "0x1234567890123456789012345678901234567890";
+        mockWallet.sendTransaction.mockResolvedValue(hash);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Unwrapped WETH with transaction hash: ${hash}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const error = new Error("Failed to unwrap WETH");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Error unwrapping WETH: ${error}`);
+    });
+});
 describe("supportsNetwork", () => {
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
     it("should return true for base-mainnet", () => {

package/dist/action-providers/zora/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./zoraActionProvider";
+export * from "./schemas";
+export * from "./utils";

package/dist/action-providers/zora/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./zoraActionProvider"), exports);
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./utils"), exports);

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const CreateCoinSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodString;
+    category: z.ZodDefault<z.ZodString>;
+    payoutRecipient: z.ZodOptional<z.ZodString>;
+    platformReferrer: z.ZodOptional<z.ZodString>;
+    currency: z.ZodDefault<z.ZodEnum<["ZORA", "ETH"]>>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    description: string;
+    currency: "ETH" | "ZORA";
+    image: string;
+    category: string;
+    platformReferrer?: string | undefined;
+    payoutRecipient?: string | undefined;
+}, {
+    symbol: string;
+    name: string;
+    description: string;
+    image: string;
+    currency?: "ETH" | "ZORA" | undefined;
+    platformReferrer?: string | undefined;
+    category?: string | undefined;
+    payoutRecipient?: string | undefined;
+}>;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCoinSchema = void 0;
+const zod_1 = require("zod");
+exports.CreateCoinSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().describe("The name of the coin to create"),
+    symbol: zod_1.z.string().describe("The symbol of the coin to create"),
+    description: zod_1.z.string().describe("The description of the coin"),
+    image: zod_1.z.string().describe("Local image file path or URI (ipfs:// or https://)"),
+    category: zod_1.z
+        .string()
+        .default("social")
+        .describe("The category of the coin, optional, defaults to 'social'"),
+    payoutRecipient: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The address that will receive creator earnings, defaults to wallet address"),
+    platformReferrer: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The address that will receive platform referrer fees, optional"),
+    currency: zod_1.z
+        .enum(["ZORA", "ETH"])
+        .default("ZORA")
+        .describe("Currency to be used for the trading pair, optional, defaults to 'ZORA'."),
+})
+    .strip()
+    .describe("Instructions for creating a new coin on Zora");

package/dist/action-providers/zora/utils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Configuration for Pinata
+ */
+interface PinataConfig {
+    jwt: string;
+}
+/**
+ * Parameters for generating token URI
+ */
+interface TokenUriParams {
+    name: string;
+    symbol: string;
+    description: string;
+    image: string;
+    category?: string;
+    pinataConfig: PinataConfig;
+}
+/**
+ * Generates a Zora token URI by handling local file or URI
+ *
+ * @param params - Parameters for generating the token URI
+ * @returns A promise that resolves to object containing the IPFS URI
+ */
+export declare function generateZoraTokenUri(params: TokenUriParams): Promise<{
+    uri: string;
+    imageUri: string;
+}>;
+export {};

package/dist/action-providers/zora/utils.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZoraTokenUri = generateZoraTokenUri;
+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 file to IPFS using Pinata
+ *
+ * @param params - Configuration and file data
+ * @param params.pinataConfig - Pinata configuration including JWT
+ * @param params.fileData - Base64 encoded file data
+ * @param params.fileName - Name for the uploaded file
+ * @param params.mimeType - MIME type of the file
+ * @returns Upload response with CID and other details
+ */
+async function uploadFileToIPFS(params) {
+    try {
+        const formData = new FormData();
+        // Convert base64 to Blob and then to File
+        const byteCharacters = atob(params.fileData);
+        const byteArrays = [];
+        for (let offset = 0; offset < byteCharacters.length; offset += 1024) {
+            const slice = byteCharacters.slice(offset, offset + 1024);
+            const byteNumbers = new Array(slice.length);
+            for (let i = 0; i < slice.length; i++) {
+                byteNumbers[i] = slice.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            byteArrays.push(byteArray);
+        }
+        const blob = new Blob(byteArrays, { type: params.mimeType });
+        const file = new File([blob], params.fileName, { type: params.mimeType });
+        formData.append("file", file);
+        const pinataMetadata = {
+            name: params.fileName,
+        };
+        formData.append("pinataMetadata", JSON.stringify(pinataMetadata));
+        const pinataOptions = {
+            cidVersion: 1,
+        };
+        formData.append("pinataOptions", JSON.stringify(pinataOptions));
+        const response = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${params.pinataConfig.jwt}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to upload file to IPFS: ${error.message || response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            IpfsHash: data.IpfsHash,
+            PinSize: data.PinSize,
+            Timestamp: data.Timestamp,
+            isDuplicate: data.isDuplicate || false,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to upload file to IPFS: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Uploads JSON data to IPFS using Pinata
+ *
+ * @param params - Configuration and JSON data
+ * @param params.pinataConfig - Pinata configuration including JWT
+ * @param params.json - JSON data to upload
+ * @returns Upload response with CID and other details
+ */
+async function uploadJsonToIPFS(params) {
+    try {
+        const requestBody = {
+            pinataOptions: {
+                cidVersion: 1,
+            },
+            pinataMetadata: {
+                name: `${params.json.name}-metadata.json`,
+            },
+            pinataContent: params.json,
+        };
+        const response = await fetch("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${params.pinataConfig.jwt}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        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();
+        return {
+            IpfsHash: data.IpfsHash,
+            PinSize: data.PinSize,
+            Timestamp: data.Timestamp,
+            isDuplicate: data.isDuplicate || false,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to upload JSON to IPFS: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Generates a Zora token URI by handling local file or URI
+ *
+ * @param params - Parameters for generating the token URI
+ * @returns A promise that resolves to object containing the IPFS URI
+ */
+async function generateZoraTokenUri(params) {
+    try {
+        let imageUri;
+        // Check if image is already a URI (ipfs:// or https://)
+        if (params.image.startsWith("ipfs://") || params.image.startsWith("https://")) {
+            imageUri = params.image;
+        }
+        else {
+            // Handle local file
+            const { base64, mimeType } = await readFileAsBase64(params.image);
+            const fileName = path_1.default.basename(params.image);
+            const imageRes = await uploadFileToIPFS({
+                pinataConfig: params.pinataConfig,
+                fileData: base64,
+                fileName,
+                mimeType,
+            });
+            imageUri = `ipfs://${imageRes.IpfsHash}`;
+        }
+        // Create and upload the metadata
+        const metadata = {
+            name: params.name,
+            description: params.description,
+            symbol: params.symbol,
+            image: imageUri,
+            content: {
+                uri: imageUri,
+                mime: imageUri.startsWith("ipfs://") || imageUri.startsWith("https://")
+                    ? "image/*"
+                    : "image/png",
+            },
+            properties: {
+                category: params.category || "social",
+            },
+        };
+        const metadataRes = await uploadJsonToIPFS({
+            pinataConfig: params.pinataConfig,
+            json: metadata,
+        });
+        const uri = `ipfs://${metadataRes.IpfsHash}`;
+        return { uri, imageUri };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to generate Zora token URI: ${error.message}`);
+        }
+        throw error;
+    }
+}

package/dist/action-providers/zora/zoraActionProvider.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers/evmWalletProvider";
+import { CreateCoinSchema } from "./schemas";
+import { Network } from "../../network";
+/**
+ * ZoraActionProvider provides actions for interacting with the Zora protocol.
+ */
+export declare class ZoraActionProvider extends ActionProvider<EvmWalletProvider> {
+    #private;
+    /**
+     * Constructor for the ZoraActionProvider.
+     */
+    constructor();
+    /**
+     * Creates a new Zora coin.
+     *
+     * @param walletProvider - The wallet provider to use for the transaction.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the coin creation details.
+     */
+    createCoin(walletProvider: EvmWalletProvider, args: z.infer<typeof CreateCoinSchema>): Promise<string>;
+    /**
+     * Checks if the Zora action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Zora action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+/**
+ * Factory function to create a new ZoraActionProvider instance.
+ *
+ * @returns A new ZoraActionProvider instance
+ */
+export declare const zoraActionProvider: () => ZoraActionProvider;

package/dist/action-providers/zora/zoraActionProvider.js

@@ -0,0 +1,151 @@
+"use strict";
+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);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ZoraActionProvider_pinataJwt;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoraActionProvider = exports.ZoraActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const evmWalletProvider_1 = require("../../wallet-providers/evmWalletProvider");
+const schemas_1 = require("./schemas");
+const actionDecorator_1 = require("../actionDecorator");
+const viem_1 = require("viem");
+const utils_1 = require("./utils");
+const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+/**
+ * ZoraActionProvider provides actions for interacting with the Zora protocol.
+ */
+class ZoraActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ZoraActionProvider.
+     */
+    constructor() {
+        super("zora", []);
+        _ZoraActionProvider_pinataJwt.set(this, void 0);
+        /**
+         * Checks if the Zora action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Zora action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm" && SUPPORTED_NETWORKS.includes(network.networkId);
+        // Set Pinata JWT
+        const pinataJwt = process.env.PINATA_JWT;
+        if (!pinataJwt) {
+            throw new Error("PINATA_JWT is not configured. Required for IPFS uploads.");
+        }
+        __classPrivateFieldSet(this, _ZoraActionProvider_pinataJwt, pinataJwt, "f");
+    }
+    /**
+     * Creates a new Zora coin.
+     *
+     * @param walletProvider - The wallet provider to use for the transaction.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the coin creation details.
+     */
+    async createCoin(walletProvider, args) {
+        try {
+            // Generate token URI from local file or URI
+            const { uri, imageUri } = await (0, utils_1.generateZoraTokenUri)({
+                name: args.name,
+                symbol: args.symbol,
+                description: args.description,
+                image: args.image,
+                category: args.category,
+                pinataConfig: { jwt: __classPrivateFieldGet(this, _ZoraActionProvider_pinataJwt, "f") },
+            });
+            // Dynamically import Zora SDK
+            const { createCoinCall, DeployCurrency, getCoinCreateFromLogs } = await import("@zoralabs/coins-sdk");
+            // Create coin call
+            const call = {
+                name: args.name,
+                symbol: args.symbol,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                uri: uri,
+                payoutRecipient: args.payoutRecipient || walletProvider.getAddress(),
+                platformReferrer: args.platformReferrer || "0x0000000000000000000000000000000000000000",
+                currency: args.currency === "ZORA" ? DeployCurrency.ZORA : DeployCurrency.ETH,
+            };
+            const createCoinRequest = await createCoinCall(call);
+            const { abi, functionName, address, args: callArgs, value } = createCoinRequest;
+            const data = (0, viem_1.encodeFunctionData)({ abi, functionName, args: callArgs });
+            const txRequest = { to: address, data, value };
+            // Send transaction
+            const hash = await walletProvider.sendTransaction(txRequest);
+            const receipt = await walletProvider.waitForTransactionReceipt(hash);
+            const deployment = getCoinCreateFromLogs(receipt);
+            if (receipt.status === "success") {
+                return JSON.stringify({
+                    success: true,
+                    transactionHash: hash,
+                    coinAddress: deployment?.coin,
+                    imageUri,
+                    uri,
+                    deployment,
+                    ...(walletProvider.getNetwork().networkId === "base-mainnet" &&
+                        deployment?.coin && {
+                        zoraURL: `https://zora.co/coin/base:${deployment.coin}`,
+                    }),
+                });
+            }
+            else {
+                throw new Error("Coin creation transaction reverted");
+            }
+        }
+        catch (error) {
+            return JSON.stringify({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+exports.ZoraActionProvider = ZoraActionProvider;
+_ZoraActionProvider_pinataJwt = new WeakMap();
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "coinIt",
+        description: `
+This tool will create a new Zora coin.
+It takes the following parameters:
+- name: The name of the coin
+- symbol: The symbol of the coin
+- image: Local image file path or URI (ipfs:// or https://)
+- description: The description of the coin
+- payoutRecipient: The address that will receive creator earnings (optional, defaults to the wallet address)
+- platformReferrer: The address that will receive platform referrer fees (optional, defaults to 0x0000000000000000000000000000000000000000)
+- category: The category of the coin (optional, defaults to 'social')
+- currency: The currency for deployment, can be 'ZORA' or 'ETH'. Determines which token will be used for the trading pair (optional, defaults to 'ZORA').
+The action will return the transaction hash, coin address, and deployment details upon success.
+`,
+        schema: schemas_1.CreateCoinSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [evmWalletProvider_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ZoraActionProvider.prototype, "createCoin", null);
+/**
+ * Factory function to create a new ZoraActionProvider instance.
+ *
+ * @returns A new ZoraActionProvider instance
+ */
+const zoraActionProvider = () => new ZoraActionProvider();
+exports.zoraActionProvider = zoraActionProvider;

package/dist/action-providers/zora/zoraActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};