@coinbase/agentkit 0.10.2 → 0.10.3

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnsoRouteSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for route action.
+ */
+exports.EnsoRouteSchema = zod_1.z
+    .object({
+    tokenIn: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("Address of the token to swap from. For ETH, use 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"),
+    tokenOut: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("Address of the token to swap to, For ETH, use 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"),
+    amountIn: zod_1.z.string().describe("Amount of tokenIn to swap in whole units (e.g. 100 USDC)"),
+    slippage: zod_1.z.number().optional().describe("Slippage in basis points (1/10000). Default - 50"),
+})
+    .strip()
+    .describe("Instructions for routing through Enso API");

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

@@ -30,8 +30,10 @@ export declare const TOKEN_ADDRESSES_BY_SYMBOLS: {
     };
     readonly "arbitrum-mainnet": {
         readonly USDC: "0xaf88d065e77c8cc2239327c5edb3a432268e5831";
+        readonly WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1";
     };
     readonly "optimism-mainnet": {
         readonly USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85";
+        readonly WETH: "0x4200000000000000000000000000000000000006";
     };
 };

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

@@ -43,8 +43,10 @@ exports.TOKEN_ADDRESSES_BY_SYMBOLS = {
     },
     "arbitrum-mainnet": {
         USDC: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+        WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
     },
     "optimism-mainnet": {
         USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
+        WETH: "0x4200000000000000000000000000000000000006",
     },
 };

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, GetTokenAddressSchema } from "./schemas";
+import { GetBalanceSchema, TransferSchema, GetTokenAddressSchema, ApproveSchema, AllowanceSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
 /**
  * ERC20ActionProvider is an action provider for ERC20 tokens.
@@ -27,6 +27,22 @@ export declare class ERC20ActionProvider extends ActionProvider<EvmWalletProvide
      * @returns A message containing the transfer details.
      */
     transfer(walletProvider: EvmWalletProvider, args: z.infer<typeof TransferSchema>): Promise<string>;
+    /**
+     * Approves a spender to transfer a specified amount of tokens.
+     *
+     * @param walletProvider - The wallet provider to approve from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the approval details.
+     */
+    approve(walletProvider: EvmWalletProvider, args: z.infer<typeof ApproveSchema>): Promise<string>;
+    /**
+     * Checks the allowance for a spender of an ERC20 token.
+     *
+     * @param walletProvider - The wallet provider to check the allowance from.
+     * @param args - The input arguments containing tokenAddress and spender.
+     * @returns A message containing the allowance amount for the spender.
+     */
+    getAllowance(walletProvider: EvmWalletProvider, args: z.infer<typeof AllowanceSchema>): Promise<string>;
     /**
      * Gets the contract address for a token symbol on the current network.
      *

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

@@ -117,6 +117,66 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
             return `Error transferring the asset: ${error}`;
         }
     }
+    /**
+     * Approves a spender to transfer a specified amount of tokens.
+     *
+     * @param walletProvider - The wallet provider to approve from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the approval details.
+     */
+    async approve(walletProvider, args) {
+        try {
+            // Get token details for better error messages and validation
+            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.`;
+            }
+            // Convert amount to wei using token decimals
+            const amountInWei = (0, viem_1.parseUnits)(String(args.amount), tokenDetails.decimals);
+            const hash = await walletProvider.sendTransaction({
+                to: tokenAddress,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: viem_1.erc20Abi,
+                    functionName: "approve",
+                    args: [args.spenderAddress, amountInWei],
+                }),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Approved ${args.amount} ${tokenDetails.name} (${args.tokenAddress}) for spender ${args.spenderAddress}.\nTransaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error approving tokens: ${error}`;
+        }
+    }
+    /**
+     * Checks the allowance for a spender of an ERC20 token.
+     *
+     * @param walletProvider - The wallet provider to check the allowance from.
+     * @param args - The input arguments containing tokenAddress and spender.
+     * @returns A message containing the allowance amount for the spender.
+     */
+    async getAllowance(walletProvider, args) {
+        try {
+            // Get token details for proper formatting
+            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.`;
+            }
+            const allowance = await walletProvider.readContract({
+                address: args.tokenAddress,
+                abi: viem_1.erc20Abi,
+                functionName: "allowance",
+                args: [walletProvider.getAddress(), args.spenderAddress],
+            });
+            // Format the allowance using token decimals
+            const formattedAllowance = (0, viem_1.formatUnits)(allowance, tokenDetails.decimals);
+            return `Allowance for ${args.spenderAddress} to spend ${tokenDetails.name} (${args.tokenAddress}) is ${formattedAllowance} tokens`;
+        }
+        catch (error) {
+            return `Error checking allowance: ${error}`;
+        }
+    }
     /**
      * Gets the contract address for a token symbol on the current network.
      *
@@ -166,7 +226,7 @@ __decorate([
 It takes the following inputs:
 - 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')
+- destinationAddress: The address to send the funds to
 Important notes:
 - 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
 `,
@@ -176,6 +236,48 @@ Important notes:
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], ERC20ActionProvider.prototype, "transfer", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "approve",
+        description: `
+This tool will approve a spender to transfer ERC20 tokens from the wallet.
+
+It takes the following inputs:
+- amount: The amount to approve in whole units (e.g. 100 for 100 USDC)
+- tokenAddress: The contract address of the token to approve
+- spenderAddress: The spender address to approve
+
+Important notes:
+- This will overwrite any existing allowance
+- To revoke an allowance, set the amount to 0
+- Ensure you trust the spender address before approving
+- Never assume token 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.ApproveSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "approve", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_allowance",
+        description: `
+This tool will get the allowance amount for a spender of an ERC20 token.
+
+It takes the following inputs:
+- tokenAddress: The contract address of the token to check allowance for
+- spenderAddress: The address to check allowance for
+
+Important notes:
+- Never assume token 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.AllowanceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "getAllowance", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "get_erc20_token_address",

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

@@ -7,6 +7,7 @@ const MOCK_DECIMALS = 6;
 const MOCK_CONTRACT_ADDRESS = "0x1234567890123456789012345678901234567890";
 const MOCK_DESTINATION = "0x9876543210987654321098765432109876543210";
 const MOCK_ADDRESS = "0x1234567890123456789012345678901234567890";
+const MOCK_SPENDER = "0xabcdef1234567890123456789012345678901234";
 describe("Transfer Schema", () => {
     it("should successfully parse valid input", () => {
         const validInput = {
@@ -142,6 +143,206 @@ describe("GetTokenAddress Schema", () => {
         expect(result.success).toBe(false);
     });
 });
+describe("Approve Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const result = schemas_1.ApproveSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.ApproveSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing invalid token address", () => {
+        const invalidInput = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: "invalid-address",
+            spenderAddress: MOCK_SPENDER,
+        };
+        const result = schemas_1.ApproveSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing invalid spender address", () => {
+        const invalidInput = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: "invalid-address",
+        };
+        const result = schemas_1.ApproveSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Allowance Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const result = schemas_1.AllowanceSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.AllowanceSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing invalid token address", () => {
+        const invalidInput = {
+            tokenAddress: "invalid-address",
+            spenderAddress: MOCK_SPENDER,
+        };
+        const result = schemas_1.AllowanceSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing invalid spender address", () => {
+        const invalidInput = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: "invalid-address",
+        };
+        const result = schemas_1.AllowanceSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Approve Action", () => {
+    const TRANSACTION_HASH = "0xapprove123456789";
+    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(),
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            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 approve tokens", async () => {
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
+        const args = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.approve(mockWallet, args);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(mockWallet.sendTransaction).toHaveBeenCalled();
+        expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(TRANSACTION_HASH);
+        expect(response).toContain(`Approved ${MOCK_AMOUNT} MockToken (${MOCK_CONTRACT_ADDRESS}) for spender ${MOCK_SPENDER}`);
+        expect(response).toContain(`Transaction hash: ${TRANSACTION_HASH}`);
+    });
+    it("should fail with an error when token details cannot be fetched", async () => {
+        mockMulticall.mockRejectedValue(new Error("Failed to get token details"));
+        const args = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.approve(mockWallet, args);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(response).toContain("Error: Could not fetch token details");
+    });
+    it("should fail with an error when transaction fails", async () => {
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
+        mockWallet.sendTransaction.mockRejectedValue(new Error("Transaction failed"));
+        const args = {
+            amount: MOCK_AMOUNT.toString(),
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.approve(mockWallet, args);
+        expect(response).toContain("Error approving tokens: Error: Transaction failed");
+    });
+});
+describe("Get Allowance Action", () => {
+    let mockWallet;
+    let mockMulticall;
+    let mockReadContract;
+    const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();
+    beforeEach(async () => {
+        mockMulticall = jest.fn();
+        mockReadContract = jest.fn();
+        const mockPublicClient = {
+            multicall: mockMulticall,
+            getCode: jest.fn().mockResolvedValue("0x"),
+        };
+        mockWallet = {
+            readContract: mockReadContract,
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            getNetwork: jest.fn().mockReturnValue({
+                networkId: "base-mainnet",
+            }),
+            getPublicClient: jest.fn().mockReturnValue(mockPublicClient),
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+        };
+    });
+    it("should successfully get allowance", async () => {
+        const allowanceAmount = BigInt(MOCK_AMOUNT * 10 ** MOCK_DECIMALS);
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
+        mockReadContract.mockResolvedValue(allowanceAmount);
+        const args = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.getAllowance(mockWallet, args);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(mockReadContract).toHaveBeenCalled();
+        expect(response).toContain(`Allowance for ${MOCK_SPENDER} to spend MockToken (${MOCK_CONTRACT_ADDRESS}) is ${MOCK_AMOUNT}`);
+    });
+    it("should fail with an error when token details cannot be fetched", async () => {
+        mockMulticall.mockRejectedValue(new Error("Failed to get token details"));
+        const args = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.getAllowance(mockWallet, args);
+        expect(mockMulticall).toHaveBeenCalled();
+        expect(response).toContain("Error: Could not fetch token details");
+    });
+    it("should fail with an error when allowance read fails", async () => {
+        mockMulticall.mockResolvedValueOnce([
+            { result: "MockToken" }, // name
+            { result: MOCK_DECIMALS }, // decimals
+            { result: BigInt(100000 * 10 ** MOCK_DECIMALS) }, // balance
+        ]);
+        mockReadContract.mockRejectedValue(new Error("Allowance read failed"));
+        const args = {
+            tokenAddress: MOCK_CONTRACT_ADDRESS,
+            spenderAddress: MOCK_SPENDER,
+        };
+        const response = await actionProvider.getAllowance(mockWallet, args);
+        expect(response).toContain("Error checking allowance: Error: Allowance read failed");
+    });
+});
 describe("Get Token Address Action", () => {
     let mockWallet;
     const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();

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

@@ -28,6 +28,35 @@ export declare const GetBalanceSchema: z.ZodObject<{
     tokenAddress: string;
     address?: string | undefined;
 }>;
+/**
+ * Input schema for approve action.
+ */
+export declare const ApproveSchema: z.ZodObject<{
+    amount: z.ZodString;
+    tokenAddress: z.ZodString;
+    spenderAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    tokenAddress: string;
+    spenderAddress: string;
+}, {
+    amount: string;
+    tokenAddress: string;
+    spenderAddress: string;
+}>;
+/**
+ * Input schema for allowance action.
+ */
+export declare const AllowanceSchema: z.ZodObject<{
+    tokenAddress: z.ZodString;
+    spenderAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    tokenAddress: string;
+    spenderAddress: string;
+}, {
+    tokenAddress: string;
+    spenderAddress: string;
+}>;
 /**
  * Input schema for get token address action.
  */

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetTokenAddressSchema = exports.GetBalanceSchema = exports.TransferSchema = void 0;
+exports.GetTokenAddressSchema = exports.AllowanceSchema = exports.ApproveSchema = exports.GetBalanceSchema = exports.TransferSchema = void 0;
 const zod_1 = require("zod");
 /**
  * Input schema for transfer action.
@@ -38,6 +38,39 @@ exports.GetBalanceSchema = zod_1.z
 })
     .strip()
     .describe("Instructions for getting wallet balance");
+/**
+ * Input schema for approve action.
+ */
+exports.ApproveSchema = zod_1.z
+    .object({
+    amount: zod_1.z.string().describe("The amount to approve in whole units (e.g. 100 for 100 USDC)"),
+    tokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The contract address of the token"),
+    spenderAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address to approve for spending tokens"),
+})
+    .strip()
+    .describe("Instructions for approving token spending");
+/**
+ * Input schema for allowance action.
+ */
+exports.AllowanceSchema = zod_1.z
+    .object({
+    tokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The contract address of the token"),
+    spenderAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address to check allowance for"),
+})
+    .strip()
+    .describe("Instructions for checking token allowance");
 /**
  * Input schema for get token address action.
  */

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

@@ -7,8 +7,10 @@ export * from "./baseAccount";
 export * from "./basename";
 export * from "./cdp-legacy";
 export * from "./cdp";
+export * from "./clanker";
 export * from "./compound";
 export * from "./defillama";
+export * from "./enso";
 export * from "./erc20";
 export * from "./erc721";
 export * from "./farcaster";
@@ -30,8 +32,8 @@ export * from "./flaunch";
 export * from "./onramp";
 export * from "./vaultsfyi";
 export * from "./x402";
+export * from "./yelay";
 export * from "./zerion";
 export * from "./zerodev";
 export * from "./zeroX";
 export * from "./zora";
-export * from "./clanker";

package/dist/action-providers/index.js

@@ -23,8 +23,10 @@ __exportStar(require("./baseAccount"), exports);
 __exportStar(require("./basename"), exports);
 __exportStar(require("./cdp-legacy"), exports);
 __exportStar(require("./cdp"), exports);
+__exportStar(require("./clanker"), exports);
 __exportStar(require("./compound"), exports);
 __exportStar(require("./defillama"), exports);
+__exportStar(require("./enso"), exports);
 __exportStar(require("./erc20"), exports);
 __exportStar(require("./erc721"), exports);
 __exportStar(require("./farcaster"), exports);
@@ -46,8 +48,8 @@ __exportStar(require("./flaunch"), exports);
 __exportStar(require("./onramp"), exports);
 __exportStar(require("./vaultsfyi"), exports);
 __exportStar(require("./x402"), exports);
+__exportStar(require("./yelay"), exports);
 __exportStar(require("./zerion"), exports);
 __exportStar(require("./zerodev"), exports);
 __exportStar(require("./zeroX"), exports);
 __exportStar(require("./zora"), exports);
-__exportStar(require("./clanker"), exports);

package/dist/action-providers/wallet/walletActionProvider.js

@@ -133,7 +133,7 @@ __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "native_transfer",
         description: `
-This tool will transfer (send) native tokens from the wallet to another onchain address.
+This tool will transfer (send) native tokens (ETH for EVM networks, SOL for SVM networks) from the wallet to another onchain address.
 
 It takes the following inputs:
 - amount: The amount to transfer in whole units (e.g. 4.2 ETH, 0.1 SOL)

package/dist/action-providers/weth/constants.d.ts

@@ -1,4 +1,3 @@
-export declare const WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
 export declare const WETH_ABI: readonly [{
     readonly inputs: readonly [];
     readonly name: "deposit";

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WETH_ABI = exports.WETH_ADDRESS = void 0;
-exports.WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+exports.WETH_ABI = void 0;
 exports.WETH_ABI = [
     {
         inputs: [],

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

@@ -4,13 +4,17 @@ exports.UnwrapEthSchema = exports.WrapEthSchema = void 0;
 const zod_1 = require("zod");
 exports.WrapEthSchema = zod_1.z
     .object({
-    amountToWrap: zod_1.z.string().describe("Amount of ETH to wrap in wei"),
+    amountToWrap: zod_1.z
+        .string()
+        .describe("Amount of ETH to wrap in human-readable format (e.g., 0.1 for 0.1 ETH)"),
 })
     .strip()
     .describe("Instructions for wrapping ETH to WETH");
 exports.UnwrapEthSchema = zod_1.z
     .object({
-    amountToUnwrap: zod_1.z.string().describe("Amount of WETH to unwrap in wei"),
+    amountToUnwrap: zod_1.z
+        .string()
+        .describe("Amount of WETH to unwrap in human-readable format (e.g., 0.1 for 0.1 WETH)"),
 })
     .strip()
     .describe("Instructions for unwrapping WETH to ETH");

package/dist/action-providers/weth/wethActionProvider.d.ts

@@ -3,6 +3,13 @@ import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
 import { WrapEthSchema, UnwrapEthSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * Gets the WETH address for the given network.
+ *
+ * @param network - The network to get the WETH address for.
+ * @returns The WETH address for the network, or undefined if not supported.
+ */
+export declare const getWethAddress: (network: Network) => string | undefined;
 /**
  * WethActionProvider is an action provider for WETH.
  */