@coinbase/agentkit 0.10.0 → 0.10.2

package/dist/action-providers/cdp/cdpSmartWalletActionProvider.test.js

@@ -36,23 +36,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const cdpSmartWalletActionProvider_1 = require("./cdpSmartWalletActionProvider");
 const schemas_1 = require("./schemas");
 const spendPermissionUtils = __importStar(require("./spendPermissionUtils"));
+const swapUtils = __importStar(require("./swapUtils"));
+const utils = __importStar(require("../../utils"));
 // Mock the CDP SDK and utility functions
 jest.mock("@coinbase/cdp-sdk");
 jest.mock("./spendPermissionUtils");
+jest.mock("./swapUtils");
+jest.mock("../../utils");
 describe("CDP Smart Wallet Action Provider", () => {
     let actionProvider;
     let mockWalletProvider;
     let mockCdpClient;
     let mockSmartAccount;
+    const mockGetTokenDetails = swapUtils.getTokenDetails;
+    const mockRetryWithExponentialBackoff = utils.retryWithExponentialBackoff;
     beforeEach(() => {
         jest.clearAllMocks();
         mockSmartAccount = {
             useSpendPermission: jest.fn(),
+            swap: jest.fn(),
             address: "0x1234567890123456789012345678901234567890",
         };
         mockCdpClient = {
             evm: {
                 listSpendPermissions: jest.fn(),
+                getSwapPrice: jest.fn(),
             },
         };
         mockWalletProvider = {
@@ -60,7 +68,19 @@ describe("CDP Smart Wallet Action Provider", () => {
             getAddress: jest.fn(),
             getClient: jest.fn(),
             smartAccount: mockSmartAccount,
+            ownerAccount: {
+                type: "server",
+                address: "0xowner123",
+            },
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            getPaymasterUrl: jest.fn(),
+            getCdpSdkNetwork: jest.fn(),
         };
+        // Default setup for utility functions
+        mockRetryWithExponentialBackoff.mockImplementation(async (fn) => {
+            return await fn();
+        });
         actionProvider = new cdpSmartWalletActionProvider_1.CdpSmartWalletActionProvider();
     });
     describe("listSpendPermissions", () => {
@@ -74,6 +94,7 @@ describe("CDP Smart Wallet Action Provider", () => {
             });
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
         });
         it("should successfully list spend permissions for EVM networks", async () => {
             const expectedResult = "Found 1 spend permission(s):\n1. Token: ETH, Allowance: 1000, Period: 3600 seconds, Start: 123456, End: 234567";
@@ -110,6 +131,7 @@ describe("CDP Smart Wallet Action Provider", () => {
             });
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
         });
         it("should successfully use spend permission for EVM networks", async () => {
             const mockPermission = {
@@ -140,6 +162,7 @@ describe("CDP Smart Wallet Action Provider", () => {
                 protocolFamily: "evm",
                 networkId: "base-mainnet",
             });
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
             const mockPermission = { spender: "0x1234", token: "ETH" };
             const mockSpendResult = { status: "completed" };
             spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
@@ -156,6 +179,9 @@ describe("CDP Smart Wallet Action Provider", () => {
                 protocolFamily: "evm",
                 networkId: "ethereum-mainnet",
             });
+            mockWalletProvider.getCdpSdkNetwork.mockImplementation(() => {
+                throw new Error("Unsupported network for smart wallets: ethereum-mainnet");
+            });
             await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Unsupported network for smart wallets: ethereum-mainnet");
         });
         it("should return error message for non-EVM networks", async () => {
@@ -163,7 +189,7 @@ describe("CDP Smart Wallet Action Provider", () => {
                 protocolFamily: "svm",
                 networkId: "solana-devnet",
             });
-            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Unsupported network for smart wallets: solana-devnet");
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Spend permissions are currently only supported on EVM networks.");
         });
         it("should handle spend permission not found error", async () => {
             spendPermissionUtils.findLatestSpendPermission.mockRejectedValue(new Error("No spend permissions found"));
@@ -188,6 +214,246 @@ describe("CDP Smart Wallet Action Provider", () => {
             expect(() => schemas_1.UseSpendPermissionSchema.parse(invalidInput)).toThrow();
         });
     });
+    describe("getSwapPrice", () => {
+        const mockArgs = {
+            fromToken: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", // ETH
+            toToken: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", // USDC on Base
+            fromAmount: "0.1",
+            slippageBps: 100,
+        };
+        beforeEach(() => {
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
+            mockGetTokenDetails.mockResolvedValue({
+                fromTokenDecimals: 18,
+                toTokenDecimals: 6,
+                fromTokenName: "ETH",
+                toTokenName: "USDC",
+            });
+        });
+        it("should get swap price quote on base-mainnet", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                toAmount: "990000", // 0.99 USDC
+                minToAmount: "980000", // 0.98 USDC
+                liquidityAvailable: true,
+                issues: {},
+            });
+            const result = await actionProvider.getSwapPrice(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(mockCdpClient.evm.getSwapPrice).toHaveBeenCalledWith({
+                fromToken: mockArgs.fromToken,
+                toToken: mockArgs.toToken,
+                fromAmount: 100000000000000000n, // 0.1 ETH in wei
+                network: "base",
+                taker: "0x1234567890123456789012345678901234567890",
+            });
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.fromAmount).toBe("0.1");
+            expect(parsedResult.toAmount).toBe("0.99");
+            expect(parsedResult.liquidityAvailable).toBe(true);
+        });
+        it("should get swap price quote on base-sepolia", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                toAmount: "990000",
+                minToAmount: "980000",
+                liquidityAvailable: true,
+                issues: {},
+            });
+            const result = await actionProvider.getSwapPrice(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(mockCdpClient.evm.getSwapPrice).toHaveBeenCalledWith({
+                fromToken: mockArgs.fromToken,
+                toToken: mockArgs.toToken,
+                fromAmount: 100000000000000000n,
+                network: "base-sepolia",
+                taker: "0x1234567890123456789012345678901234567890",
+            });
+            expect(parsedResult.success).toBe(true);
+        });
+        it("should return error for unsupported networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            });
+            const result = await actionProvider.getSwapPrice(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("CDP Swap API for smart wallets is currently only supported on Base networks");
+        });
+        it("should handle swap price API errors", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockRejectedValue(new Error("API Error"));
+            const result = await actionProvider.getSwapPrice(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("Error fetching swap price: Error: API Error");
+        });
+    });
+    describe("swap", () => {
+        const mockArgs = {
+            fromToken: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", // ETH
+            toToken: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", // USDC on Base
+            fromAmount: "0.1",
+            slippageBps: 100,
+        };
+        beforeEach(() => {
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValue({ status: "complete" });
+            mockWalletProvider.getPaymasterUrl.mockReturnValue("https://paymaster.example");
+            mockGetTokenDetails.mockResolvedValue({
+                fromTokenDecimals: 18,
+                toTokenDecimals: 6,
+                fromTokenName: "ETH",
+                toTokenName: "USDC",
+            });
+        });
+        it("should execute swap on base-mainnet", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: true,
+                issues: {},
+                toAmount: "990000", // 0.99 USDC
+                minToAmount: "980000", // 0.98 USDC
+            });
+            mockSmartAccount.swap.mockResolvedValue({ userOpHash: "0xswap789" });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(mockSmartAccount.swap).toHaveBeenCalledWith({
+                network: "base",
+                fromToken: mockArgs.fromToken,
+                toToken: mockArgs.toToken,
+                fromAmount: 100000000000000000n, // 0.1 ETH in wei
+                slippageBps: 100,
+                paymasterUrl: "https://paymaster.example",
+                signerAddress: "0xowner123",
+            });
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.transactionHash).toBe("0xswap789");
+            expect(parsedResult.fromAmount).toBe("0.1");
+            expect(parsedResult.toAmount).toBe("0.99");
+        });
+        it("should return error for unsupported networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("CDP Swap API for smart wallets is currently only supported on Base networks");
+        });
+        it("should throw error for local owner account", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockWalletProvider.ownerAccount = {
+                type: "local",
+                address: "0xlocal123",
+            };
+            await expect(actionProvider.swap(mockWalletProvider, mockArgs)).rejects.toThrow("Smart wallet owner account is not a CDP server account");
+        });
+        it("should return error when liquidity is not available", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: false,
+                issues: {},
+                toAmount: "0",
+                minToAmount: "0",
+            });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("No liquidity available to swap");
+        });
+        it("should return error when balance is insufficient", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: true,
+                issues: {
+                    balance: {
+                        currentBalance: "50000000000000000", // 0.05 ETH
+                    },
+                },
+                toAmount: "990000",
+                minToAmount: "980000",
+            });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("Balance is not enough to perform swap");
+            expect(parsedResult.error).toContain("but only have 0.05 ETH");
+        });
+        it("should handle approval transaction when allowance is insufficient", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: true,
+                issues: {
+                    allowance: {
+                        requiredAllowance: "100000000000000000",
+                        currentAllowance: "0",
+                    },
+                },
+                toAmount: "990000",
+                minToAmount: "980000",
+            });
+            mockWalletProvider.sendTransaction.mockResolvedValue("0xapproval123");
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValueOnce({ status: "complete" }); // For approval
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValueOnce({ status: "complete" }); // For swap
+            mockSmartAccount.swap.mockResolvedValue({ userOpHash: "0xswap789" });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalled();
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.approvalTxHash).toBe("0xapproval123");
+            expect(parsedResult.transactionHash).toBe("0xswap789");
+        });
+        it("should handle swap execution errors", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: true,
+                issues: {},
+                toAmount: "990000",
+                minToAmount: "980000",
+            });
+            mockSmartAccount.swap.mockRejectedValue(new Error("Swap execution failed"));
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("Swap failed: Error: Swap execution failed");
+        });
+    });
     describe("supportsNetwork", () => {
         it("should return true for any network", () => {
             const evmNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };

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

@@ -13,20 +13,20 @@ export declare const RequestFaucetFundsV2Schema: z.ZodObject<{
  * Input schema for swap tokens action.
  */
 export declare const SwapSchema: z.ZodObject<{
-    fromAssetId: z.ZodString;
-    toAssetId: z.ZodString;
-    amount: z.ZodString;
-    network: z.ZodOptional<z.ZodString>;
+    fromToken: z.ZodString;
+    toToken: z.ZodString;
+    fromAmount: z.ZodString;
+    slippageBps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
-    amount: string;
-    fromAssetId: string;
-    toAssetId: string;
-    network?: string | undefined;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string;
+    slippageBps: number;
 }, {
-    amount: string;
-    fromAssetId: string;
-    toAssetId: string;
-    network?: string | undefined;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string;
+    slippageBps?: number | undefined;
 }>;
 /**
  * Input schema for listing spend permissions action.

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

@@ -16,13 +16,25 @@ exports.RequestFaucetFundsV2Schema = zod_1.z
  */
 exports.SwapSchema = zod_1.z
     .object({
-    fromAssetId: zod_1.z.string().describe("The asset ID to swap from (e.g., 'eth', 'usdc')"),
-    toAssetId: zod_1.z.string().describe("The asset ID to swap to (e.g., 'eth', 'usdc')"),
-    amount: zod_1.z.string().describe("The amount to swap (in the from asset's units)"),
-    network: zod_1.z
+    fromToken: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token contract address to swap from"),
+    toToken: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token contract address to swap to"),
+    fromAmount: zod_1.z
         .string()
+        .describe("The amount of fromToken to sell in whole units (e.g., 1.5 WETH, 10.5 USDC)"),
+    slippageBps: zod_1.z
+        .number()
+        .int()
+        .min(0)
+        .max(10000)
         .optional()
-        .describe("The network to perform the swap on (defaults to wallet's network)"),
+        .default(100)
+        .describe("The maximum acceptable slippage in basis points (0-10000, default: 100 = 1%)"),
 })
     .strip()
     .describe("Instructions for swapping tokens");

package/dist/action-providers/cdp/swapUtils.d.ts

@@ -0,0 +1,23 @@
+import { EvmWalletProvider } from "../../wallet-providers";
+export declare const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+ * Checks if a token is native ETH.
+ *
+ * @param token - The token address to check.
+ * @returns True if the token is native ETH, false otherwise.
+ */
+export declare function isNativeEth(token: string): boolean;
+/**
+ * Gets the details (decimals and name) for both fromToken and toToken
+ *
+ * @param walletProvider - The EVM wallet provider to read contracts
+ * @param fromToken - The contract address of the from token
+ * @param toToken - The contract address of the to token
+ * @returns Promise<{fromTokenDecimals: number, toTokenDecimals: number, fromTokenName: string, toTokenName: string}>
+ */
+export declare function getTokenDetails(walletProvider: EvmWalletProvider, fromToken: string, toToken: string): Promise<{
+    fromTokenDecimals: number;
+    toTokenDecimals: number;
+    fromTokenName: string;
+    toTokenName: string;
+}>;

package/dist/action-providers/cdp/swapUtils.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERMIT2_ADDRESS = void 0;
+exports.isNativeEth = isNativeEth;
+exports.getTokenDetails = getTokenDetails;
+const viem_1 = require("viem");
+// Permit2 contract address is the same across all networks
+exports.PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+ * Checks if a token is native ETH.
+ *
+ * @param token - The token address to check.
+ * @returns True if the token is native ETH, false otherwise.
+ */
+function isNativeEth(token) {
+    return token.toLowerCase() === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+}
+/**
+ * Gets the details (decimals and name) for both fromToken and toToken
+ *
+ * @param walletProvider - The EVM wallet provider to read contracts
+ * @param fromToken - The contract address of the from token
+ * @param toToken - The contract address of the to token
+ * @returns Promise<{fromTokenDecimals: number, toTokenDecimals: number, fromTokenName: string, toTokenName: string}>
+ */
+async function getTokenDetails(walletProvider, fromToken, toToken) {
+    // Initialize default values for native ETH
+    let fromTokenDecimals = 18;
+    let fromTokenName = "ETH";
+    let toTokenDecimals = 18;
+    let toTokenName = "ETH";
+    // Prepare multicall contracts array
+    const contracts = [];
+    const contractIndexMap = {
+        fromDecimals: -1,
+        fromName: -1,
+        toDecimals: -1,
+        toName: -1,
+    };
+    // Add from token contracts if not native ETH
+    if (!isNativeEth(fromToken)) {
+        contractIndexMap.fromDecimals = contracts.length;
+        contracts.push({
+            address: fromToken,
+            abi: viem_1.erc20Abi,
+            functionName: "decimals",
+        });
+        contractIndexMap.fromName = contracts.length;
+        contracts.push({
+            address: fromToken,
+            abi: viem_1.erc20Abi,
+            functionName: "name",
+        });
+    }
+    // Add to token contracts if not native ETH
+    if (!isNativeEth(toToken)) {
+        contractIndexMap.toDecimals = contracts.length;
+        contracts.push({
+            address: toToken,
+            abi: viem_1.erc20Abi,
+            functionName: "decimals",
+        });
+        contractIndexMap.toName = contracts.length;
+        contracts.push({
+            address: toToken,
+            abi: viem_1.erc20Abi,
+            functionName: "name",
+        });
+    }
+    // Execute multicall if there are contracts to call
+    if (contracts.length > 0) {
+        try {
+            const results = await walletProvider.getPublicClient().multicall({
+                contracts,
+            });
+            // Extract from token details
+            if (contractIndexMap.fromDecimals !== -1) {
+                const decimalsResult = results[contractIndexMap.fromDecimals];
+                const nameResult = results[contractIndexMap.fromName];
+                if (decimalsResult.status === "success" && nameResult.status === "success") {
+                    fromTokenDecimals = decimalsResult.result;
+                    fromTokenName = nameResult.result;
+                }
+                else {
+                    throw new Error(`Failed to read details for fromToken ${fromToken}. This address may not be a valid ERC20 contract.`);
+                }
+            }
+            // Extract to token details
+            if (contractIndexMap.toDecimals !== -1) {
+                const decimalsResult = results[contractIndexMap.toDecimals];
+                const nameResult = results[contractIndexMap.toName];
+                if (decimalsResult.status === "success" && nameResult.status === "success") {
+                    toTokenDecimals = decimalsResult.result;
+                    toTokenName = nameResult.result;
+                }
+                else {
+                    throw new Error(`Failed to read details for toToken ${toToken}. This address may not be a valid ERC20 contract.`);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read token details via multicall. Error: ${error}`);
+        }
+    }
+    return { fromTokenDecimals, toTokenDecimals, fromTokenName, toTokenName };
+}

package/dist/action-providers/clanker/clankerActionProvider.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { ClankTokenSchema } from "./schemas";
+/**
+ * ClankerActionProvider provides actions for clanker operations.
+ *
+ * @description
+ * This provider is designed to work with EvmWalletProvider for blockchain interactions.
+ * It supports all evm networks.
+ */
+export declare class ClankerActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the ClankerActionProvider.
+     */
+    constructor();
+    /**
+     * Clanker action provider
+     *
+     * @description
+     * This action deploys a clanker token using the Clanker sdk
+     * It automatically includes the coin in the Clanker ecosystem
+     *
+     * @param walletProvider - The wallet provider instance for blockchain interactions
+     * @param args - Clanker arguments (modify these to fine tune token deployment, like initial quote token and rewards config)
+     * @returns A promise that resolves to a string describing the clanker result
+     */
+    clankToken(walletProvider: EvmWalletProvider, args: z.infer<typeof ClankTokenSchema>): Promise<string>;
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network: Network): boolean;
+}
+/**
+ * Factory function to create a new ClankerActionProvider instance.
+ *
+ * @returns A new ClankerActionProvider instance
+ */
+export declare const clankerActionProvider: () => ClankerActionProvider;