@coinbase/agentkit 0.10.0 → 0.10.2

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

@@ -1,195 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSepoliaTokenToAssetId = exports.BaseTokenToAssetId = exports.abi = void 0;
+exports.TOKEN_ADDRESSES_BY_SYMBOLS = exports.BaseSepoliaTokenToAssetId = exports.BaseTokenToAssetId = void 0;
 const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
-exports.abi = [
-    {
-        type: "event",
-        name: "Approval",
-        inputs: [
-            {
-                indexed: true,
-                name: "owner",
-                type: "address",
-            },
-            {
-                indexed: true,
-                name: "spender",
-                type: "address",
-            },
-            {
-                indexed: false,
-                name: "value",
-                type: "uint256",
-            },
-        ],
-    },
-    {
-        type: "event",
-        name: "Transfer",
-        inputs: [
-            {
-                indexed: true,
-                name: "from",
-                type: "address",
-            },
-            {
-                indexed: true,
-                name: "to",
-                type: "address",
-            },
-            {
-                indexed: false,
-                name: "value",
-                type: "uint256",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "allowance",
-        stateMutability: "view",
-        inputs: [
-            {
-                name: "owner",
-                type: "address",
-            },
-            {
-                name: "spender",
-                type: "address",
-            },
-        ],
-        outputs: [
-            {
-                type: "uint256",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "approve",
-        stateMutability: "nonpayable",
-        inputs: [
-            {
-                name: "spender",
-                type: "address",
-            },
-            {
-                name: "amount",
-                type: "uint256",
-            },
-        ],
-        outputs: [
-            {
-                type: "bool",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "balanceOf",
-        stateMutability: "view",
-        inputs: [
-            {
-                name: "account",
-                type: "address",
-            },
-        ],
-        outputs: [
-            {
-                type: "uint256",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "decimals",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "uint8",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "name",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "string",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "symbol",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "string",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "totalSupply",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "uint256",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "transfer",
-        stateMutability: "nonpayable",
-        inputs: [
-            {
-                name: "recipient",
-                type: "address",
-            },
-            {
-                name: "amount",
-                type: "uint256",
-            },
-        ],
-        outputs: [
-            {
-                type: "bool",
-            },
-        ],
-    },
-    {
-        type: "function",
-        name: "transferFrom",
-        stateMutability: "nonpayable",
-        inputs: [
-            {
-                name: "sender",
-                type: "address",
-            },
-            {
-                name: "recipient",
-                type: "address",
-            },
-            {
-                name: "amount",
-                type: "uint256",
-            },
-        ],
-        outputs: [
-            {
-                type: "bool",
-            },
-        ],
-    },
-];
 exports.BaseTokenToAssetId = new Map([
     ["0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf", coinbase_sdk_1.Coinbase.assets.Cbbtc],
     ["0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", coinbase_sdk_1.Coinbase.assets.Usdc],
@@ -200,3 +12,39 @@ exports.BaseSepoliaTokenToAssetId = new Map([
     ["0x036CbD53842c5426634e7929541eC2318f3dCF7e", coinbase_sdk_1.Coinbase.assets.Usdc],
     ["0x808456652fdb597867f38412077A9182bf77359F", coinbase_sdk_1.Coinbase.assets.Eurc],
 ]);
+// Token symbol to address mappings for frequently used tokens
+exports.TOKEN_ADDRESSES_BY_SYMBOLS = {
+    "base-mainnet": {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        EURC: "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42",
+        CBBTC: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+        CBETH: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
+        WETH: "0x4200000000000000000000000000000000000006",
+        ZORA: "0x1111111111166b7FE7bd91427724B487980aFc69",
+        AERO: "0x940181a94a35a4569e4529a3cdfb74e38fd98631",
+        BNKR: "0x22af33fe49fd1fa80c7149773dde5890d3c76f3b",
+        CLANKER: "0x1bc0c42215582d5a085795f4badbac3ff36d1bcb",
+    },
+    "base-sepolia": {
+        USDC: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        EURC: "0x808456652fdb597867f38412077A9182bf77359F",
+        CBBTC: "0xcbB7C0006F23900c38EB856149F799620fcb8A4a",
+        WETH: "0x4200000000000000000000000000000000000006",
+    },
+    "ethereum-mainnet": {
+        USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        EURC: "0x1abaea1f7c830bd89acc67ec4af516284b1bc33c",
+        CBBTC: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+        WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        CBETH: "0xBe9895146f7AF43049ca1c1AE358B0541Ea49704",
+    },
+    "polygon-mainnet": {
+        USDC: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359",
+    },
+    "arbitrum-mainnet": {
+        USDC: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+    },
+    "optimism-mainnet": {
+        USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
+    },
+};

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { GetBalanceSchema, TransferSchema } from "./schemas";
+import { GetBalanceSchema, TransferSchema, GetTokenAddressSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
 /**
  * ERC20ActionProvider is an action provider for ERC20 tokens.
@@ -27,6 +27,14 @@ export declare class ERC20ActionProvider extends ActionProvider<EvmWalletProvide
      * @returns A message containing the transfer details.
      */
     transfer(walletProvider: EvmWalletProvider, args: z.infer<typeof TransferSchema>): Promise<string>;
+    /**
+     * Gets the contract address for a token symbol on the current network.
+     *
+     * @param walletProvider - The wallet provider to get the network from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the token address or an error if not found.
+     */
+    getTokenAddress(walletProvider: EvmWalletProvider, args: z.infer<typeof GetTokenAddressSchema>): Promise<string>;
     /**
      * Checks if the ERC20 action provider supports the given network.
      *

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

@@ -15,6 +15,7 @@ const actionProvider_1 = require("../actionProvider");
 const actionDecorator_1 = require("../actionDecorator");
 const schemas_1 = require("./schemas");
 const constants_1 = require("./constants");
+const utils_1 = require("./utils");
 const viem_1 = require("viem");
 const wallet_providers_1 = require("../../wallet-providers");
 /**
@@ -42,24 +43,12 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
      * @returns A message containing the balance.
      */
     async getBalance(walletProvider, args) {
-        try {
-            const balance = await walletProvider.readContract({
-                address: args.contractAddress,
-                abi: constants_1.abi,
-                functionName: "balanceOf",
-                args: [walletProvider.getAddress()],
-            });
-            const decimals = await walletProvider.readContract({
-                address: args.contractAddress,
-                abi: constants_1.abi,
-                functionName: "decimals",
-                args: [],
-            });
-            return `Balance of ${args.contractAddress} is ${(0, viem_1.formatUnits)(balance, decimals)}`;
-        }
-        catch (error) {
-            return `Error getting balance: ${error}`;
+        const address = args.address || walletProvider.getAddress();
+        const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, args.tokenAddress, args.address);
+        if (!tokenDetails) {
+            return `Error: Could not fetch token details for ${args.tokenAddress}`;
         }
+        return `Balance of ${tokenDetails.name} (${args.tokenAddress}) at address ${address} is ${tokenDetails.formattedBalance}`;
     }
     /**
      * Transfers a specified amount of an ERC20 token to a destination onchain.
@@ -70,11 +59,36 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
      */
     async transfer(walletProvider, args) {
         try {
+            // Check token details
+            const tokenAddress = (0, viem_1.getAddress)(args.tokenAddress);
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, args.tokenAddress);
+            if (!tokenDetails) {
+                return `Error: Could not fetch token details for ${args.tokenAddress}. Please verify the token address is correct.`;
+            }
+            // Check token balance
+            const amountInWei = (0, viem_1.parseUnits)(String(args.amount), tokenDetails.decimals);
+            if (tokenDetails.balance < amountInWei) {
+                return `Error: Insufficient ${tokenDetails.name} (${args.tokenAddress}) token balance. Requested to send ${args.amount} of ${tokenDetails.name} (${args.tokenAddress}), but only ${tokenDetails.formattedBalance} is available.`;
+            }
+            // Guardrails to prevent loss of funds
+            if (args.tokenAddress === args.destinationAddress) {
+                return "Error: Transfer destination is the token contract address. Refusing transfer to prevent loss of funds.";
+            }
+            if ((await walletProvider
+                .getPublicClient()
+                .getCode({ address: args.destinationAddress })) !== "0x") {
+                // If destination address is a contract, check if its an ERC20 token
+                // This assumes if the contract implements name, balance and decimals functions, it is an ERC20 token
+                const destinationTokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, args.destinationAddress);
+                if (destinationTokenDetails) {
+                    return "Error: Transfer destination is an ERC20 token contract. Refusing to transfer to prevent loss of funds.";
+                }
+                // If contract but not an ERC20 token (e.g a smart wallet), allow the transfer
+            }
             // Check if we can do gasless transfer
-            const isCdpWallet = walletProvider.getName() === "cdp_wallet_provider";
+            const isLegacyCdpWallet = walletProvider.getName() === "legacy_cdp_wallet_provider";
             const network = walletProvider.getNetwork();
-            const tokenAddress = (0, viem_1.getAddress)(args.contractAddress);
-            const canDoGasless = isCdpWallet &&
+            const canDoGasless = isLegacyCdpWallet &&
                 ((network.networkId === "base-mainnet" && constants_1.BaseTokenToAssetId.has(tokenAddress)) ||
                     (network.networkId === "base-sepolia" && constants_1.BaseSepoliaTokenToAssetId.has(tokenAddress)));
             if (canDoGasless) {
@@ -83,33 +97,59 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
                 const assetId = network.networkId === "base-mainnet"
                     ? constants_1.BaseTokenToAssetId.get(tokenAddress)
                     : constants_1.BaseSepoliaTokenToAssetId.get(tokenAddress);
-                const hash = await cdpWallet.gaslessERC20Transfer(assetId, args.destination, args.amount);
+                const hash = await cdpWallet.gaslessERC20Transfer(assetId, args.destinationAddress, BigInt(args.amount));
                 await walletProvider.waitForTransactionReceipt(hash);
-                return `Transferred ${args.amount} of ${args.contractAddress} to ${args.destination} using gasless transfer.\nTransaction hash: ${hash}`;
+                return `Transferred ${args.amount} of ${args.tokenAddress} to ${args.destinationAddress} using gasless transfer.\nTransaction hash: ${hash}`;
             }
             // Fallback to regular transfer
             const hash = await walletProvider.sendTransaction({
-                to: args.contractAddress,
+                to: args.tokenAddress,
                 data: (0, viem_1.encodeFunctionData)({
-                    abi: constants_1.abi,
+                    abi: viem_1.erc20Abi,
                     functionName: "transfer",
-                    args: [args.destination, BigInt(args.amount)],
+                    args: [args.destinationAddress, amountInWei],
                 }),
             });
             await walletProvider.waitForTransactionReceipt(hash);
-            return `Transferred ${args.amount} of ${args.contractAddress} to ${args.destination}.\nTransaction hash for the transfer: ${hash}`;
+            return `Transferred ${args.amount} of ${tokenDetails?.name} (${args.tokenAddress}) to ${args.destinationAddress}.\nTransaction hash for the transfer: ${hash}`;
         }
         catch (error) {
             return `Error transferring the asset: ${error}`;
         }
     }
+    /**
+     * Gets the contract address for a token symbol on the current network.
+     *
+     * @param walletProvider - The wallet provider to get the network from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the token address or an error if not found.
+     */
+    async getTokenAddress(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        const networkTokens = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[network.networkId ?? ""];
+        const tokenAddress = networkTokens?.[args.symbol];
+        if (tokenAddress) {
+            return `Token address for ${args.symbol} on ${network.networkId}: ${tokenAddress}`;
+        }
+        // Get available token symbols for the current network
+        const availableSymbols = networkTokens ? Object.keys(networkTokens) : [];
+        const availableSymbolsText = availableSymbols.length > 0
+            ? ` Available token symbols on ${network.networkId}: ${availableSymbols.join(", ")}`
+            : ` No token symbols are configured for ${network.networkId}`;
+        return `Error: Token symbol "${args.symbol}" not found on ${network.networkId}.${availableSymbolsText}`;
+    }
 }
 exports.ERC20ActionProvider = ERC20ActionProvider;
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "get_balance",
         description: `
-    This tool will get the balance of an ERC20 asset in the wallet. It takes the contract address as input.
+    This tool will get the balance of an ERC20 token for a given address. 
+    It takes the following inputs:
+    - tokenAddress: The contract address of the token to get the balance for
+    - address: (Optional) The address to check the balance for. If not provided, uses the wallet's address
+    Important notes:
+    - Never assume token or address, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool to get the token address first
     `,
         schema: schemas_1.GetBalanceSchema,
     }),
@@ -121,22 +161,34 @@ __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "transfer",
         description: `
-    This tool will transfer an ERC20 token from the wallet to another onchain address.
+    This tool will transfer (send) an ERC20 token from the wallet to another onchain address.
 
 It takes the following inputs:
-- amount: The amount to transfer
-- contractAddress: The contract address of the token to transfer
-- destination: Where to send the funds (can be an onchain address, ENS 'example.eth', or Basename 'example.base.eth')
-
+- amount: The amount to transfer in whole units (e.g. 10.5 USDC)
+- tokenAddress: The contract address of the token to transfer
+- destinationAddress: Where to send the funds (can be an onchain address, ENS 'example.eth', or Basename 'example.base.eth')
 Important notes:
-- Ensure sufficient balance of the input asset before transferring
-- When sending native assets (e.g. 'eth' on base-mainnet), ensure there is sufficient balance for the transfer itself AND the gas cost of this transfer
-    `,
+- Never assume token or destination addresses, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool to get the token address first
+`,
         schema: schemas_1.TransferSchema,
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], ERC20ActionProvider.prototype, "transfer", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_erc20_token_address",
+        description: `
+    This tool will get the contract address for frequently used ERC20 tokens on different networks.
+    It takes the following input:
+    - symbol: The token symbol (e.g. USDC, EURC, CBBTC)
+    `,
+        schema: schemas_1.GetTokenAddressSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "getTokenAddress", null);
 const erc20ActionProvider = () => new ERC20ActionProvider();
 exports.erc20ActionProvider = erc20ActionProvider;

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

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const erc20ActionProvider_1 = require("./erc20ActionProvider");
 const schemas_1 = require("./schemas");
-const viem_1 = require("viem");
-const constants_1 = require("./constants");
 const MOCK_AMOUNT = 15;
 const MOCK_DECIMALS = 6;
 const MOCK_CONTRACT_ADDRESS = "0x1234567890123456789012345678901234567890";
@@ -12,9 +10,9 @@ const MOCK_ADDRESS = "0x1234567890123456789012345678901234567890";
 describe("Transfer Schema", () => {
     it("should successfully parse valid input", () => {
         const validInput = {
-            amount: MOCK_AMOUNT,
-            contractAddress: MOCK_CONTRACT_ADDRESS,
-            destination: MOCK_DESTINATION,
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            destinationAddress: MOCK_DESTINATION,
         };
         const result = schemas_1.TransferSchema.safeParse(validInput);
         expect(result.success).toBe(true);
@@ -28,49 +26,53 @@ describe("Transfer Schema", () => {
 });
 describe("Get Balance Action", () => {
     let mockWallet;
+    let mockMulticall;
     const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();
     beforeEach(async () => {
+        mockMulticall = jest.fn();
+        const mockPublicClient = {
+            multicall: mockMulticall,
+            getCode: jest.fn().mockResolvedValue("0x"),
+        };
         mockWallet = {
             getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
-            readContract: jest.fn(),
+            getPublicClient: jest.fn().mockReturnValue(mockPublicClient),
         };
     });
     it("should successfully respond", async () => {
-        mockWallet.readContract.mockResolvedValueOnce(MOCK_AMOUNT);
-        mockWallet.readContract.mockResolvedValueOnce(MOCK_DECIMALS);
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(MOCK_AMOUNT * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
         const args = {
-            contractAddress: MOCK_CONTRACT_ADDRESS,
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
         };
         const response = await actionProvider.getBalance(mockWallet, args);
-        expect(mockWallet.readContract).toHaveBeenCalledWith({
-            address: args.contractAddress,
-            abi: constants_1.abi,
-            functionName: "balanceOf",
-            args: [mockWallet.getAddress()],
-        });
-        expect(response).toContain(`Balance of ${MOCK_CONTRACT_ADDRESS} is ${MOCK_AMOUNT / 10 ** MOCK_DECIMALS}`);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(response).toContain(`Balance of MockToken (${MOCK_CONTRACT_ADDRESS}) at address ${MOCK_ADDRESS} is ${MOCK_AMOUNT}`);
     });
     it("should fail with an error", async () => {
         const args = {
-            contractAddress: MOCK_CONTRACT_ADDRESS,
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
         };
-        const error = new Error("Failed to get balance");
-        mockWallet.readContract.mockRejectedValue(error);
+        mockMulticall.mockRejectedValue(new Error("Failed to get balance"));
         const response = await actionProvider.getBalance(mockWallet, args);
-        expect(mockWallet.readContract).toHaveBeenCalledWith({
-            address: args.contractAddress,
-            abi: constants_1.abi,
-            functionName: "balanceOf",
-            args: [mockWallet.getAddress()],
-        });
-        expect(response).toContain(`Error getting balance: ${error}`);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(response).toContain("Error: Could not fetch token details");
     });
 });
 describe("Transfer Action", () => {
     const TRANSACTION_HASH = "0xghijkl987654321";
     let mockWallet;
+    let mockMulticall;
     const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();
     beforeEach(async () => {
+        mockMulticall = jest.fn();
+        const mockPublicClient = {
+            multicall: mockMulticall,
+            getCode: jest.fn().mockResolvedValue("0x"),
+        };
         mockWallet = {
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
@@ -78,47 +80,40 @@ describe("Transfer Action", () => {
             getNetwork: jest.fn().mockReturnValue({
                 networkId: "base-mainnet",
             }),
+            getPublicClient: jest.fn().mockReturnValue(mockPublicClient),
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
         };
         mockWallet.sendTransaction.mockResolvedValue(TRANSACTION_HASH);
         mockWallet.waitForTransactionReceipt.mockResolvedValue({});
     });
     it("should successfully respond", async () => {
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
         const args = {
-            amount: BigInt(MOCK_AMOUNT),
-            contractAddress: MOCK_CONTRACT_ADDRESS,
-            destination: MOCK_DESTINATION,
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            destinationAddress: MOCK_DESTINATION,
         };
         const response = await actionProvider.transfer(mockWallet, args);
-        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: args.contractAddress,
-            data: (0, viem_1.encodeFunctionData)({
-                abi: constants_1.abi,
-                functionName: "transfer",
-                args: [args.destination, BigInt(args.amount)],
-            }),
-        });
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(mockWallet.sendTransaction).toHaveBeenCalled();
         expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(TRANSACTION_HASH);
-        expect(response).toContain(`Transferred ${MOCK_AMOUNT} of ${MOCK_CONTRACT_ADDRESS} to ${MOCK_DESTINATION}`);
+        expect(response).toContain(`Transferred ${MOCK_AMOUNT} of MockToken (${MOCK_CONTRACT_ADDRESS}) to ${MOCK_DESTINATION}`);
         expect(response).toContain(`Transaction hash for the transfer: ${TRANSACTION_HASH}`);
     });
     it("should fail with an error", async () => {
+        mockMulticall.mockRejectedValue(new Error("Failed to get token details"));
         const args = {
-            amount: BigInt(MOCK_AMOUNT),
-            contractAddress: MOCK_CONTRACT_ADDRESS,
-            destination: MOCK_DESTINATION,
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            destinationAddress: MOCK_DESTINATION,
         };
-        const error = new Error("Failed to execute transfer");
-        mockWallet.sendTransaction.mockRejectedValue(error);
         const response = await actionProvider.transfer(mockWallet, args);
-        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: args.contractAddress,
-            data: (0, viem_1.encodeFunctionData)({
-                abi: constants_1.abi,
-                functionName: "transfer",
-                args: [args.destination, BigInt(args.amount)],
-            }),
-        });
-        expect(response).toContain(`Error transferring the asset: ${error}`);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(response).toContain("Error: Could not fetch token details");
     });
     describe("supportsNetwork", () => {
         it("should return true when protocolFamily is evm", () => {
@@ -129,3 +124,71 @@ describe("Transfer Action", () => {
         });
     });
 });
+describe("GetTokenAddress Schema", () => {
+    it("should successfully parse valid token symbol", () => {
+        const validInput = { symbol: "usdc" };
+        const result = schemas_1.GetTokenAddressSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data?.symbol).toBe("USDC"); // Should be uppercase
+    });
+    it("should fail parsing empty symbol", () => {
+        const emptyInput = { symbol: "" };
+        const result = schemas_1.GetTokenAddressSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing symbol too long", () => {
+        const longInput = { symbol: "VERYLONGTOKENSYMBOL" };
+        const result = schemas_1.GetTokenAddressSchema.safeParse(longInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Get Token Address Action", () => {
+    let mockWallet;
+    const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();
+    beforeEach(() => {
+        mockWallet = {
+            getNetwork: jest.fn(),
+        };
+    });
+    it("should return token address for valid symbol on base-mainnet", async () => {
+        mockWallet.getNetwork.mockReturnValue({
+            protocolFamily: "evm",
+            networkId: "base-mainnet",
+        });
+        const response = await actionProvider.getTokenAddress(mockWallet, { symbol: "USDC" });
+        expect(response).toContain("Token address for USDC on base-mainnet: 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913");
+    });
+    it("should return token address for valid symbol on base-sepolia", async () => {
+        mockWallet.getNetwork.mockReturnValue({
+            protocolFamily: "evm",
+            networkId: "base-sepolia",
+        });
+        const response = await actionProvider.getTokenAddress(mockWallet, { symbol: "EURC" });
+        expect(response).toContain("Token address for EURC on base-sepolia: 0x808456652fdb597867f38412077A9182bf77359F");
+    });
+    it("should return error for unsupported network", async () => {
+        mockWallet.getNetwork.mockReturnValue({
+            protocolFamily: "evm",
+            networkId: "unsupported-network",
+        });
+        const response = await actionProvider.getTokenAddress(mockWallet, { symbol: "USDC" });
+        expect(response).toContain('Error: Token symbol "USDC" not found on unsupported-network');
+    });
+    it("should return error for unknown token symbol", async () => {
+        mockWallet.getNetwork.mockReturnValue({
+            protocolFamily: "evm",
+            networkId: "base-mainnet",
+        });
+        const response = await actionProvider.getTokenAddress(mockWallet, { symbol: "UNKNOWN" });
+        expect(response).toContain('Error: Token symbol "UNKNOWN" not found on base-mainnet');
+        expect(response).toContain('Error: Token symbol "UNKNOWN" not found on base-mainnet');
+    });
+    it("should return error when network ID is not available", async () => {
+        mockWallet.getNetwork.mockReturnValue({
+            protocolFamily: "evm",
+            // networkId is undefined
+        });
+        const response = await actionProvider.getTokenAddress(mockWallet, { symbol: "USDC" });
+        expect(response).toContain('Error: Token symbol "USDC" not found on undefined');
+    });
+});