@coinbase/agentkit 0.0.0-nightly-20251001210424 → 0.0.0-nightly-20251002210424

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/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.
  */

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

@@ -9,14 +9,26 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wethActionProvider = exports.WethActionProvider = void 0;
+exports.wethActionProvider = exports.WethActionProvider = exports.getWethAddress = void 0;
 const zod_1 = require("zod");
 const actionProvider_1 = require("../actionProvider");
 const actionDecorator_1 = require("../actionDecorator");
 const schemas_1 = require("./schemas");
 const constants_1 = require("./constants");
+const constants_2 = require("../erc20/constants");
 const viem_1 = require("viem");
 const wallet_providers_1 = require("../../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.
+ */
+const getWethAddress = (network) => {
+    const networkTokens = constants_2.TOKEN_ADDRESSES_BY_SYMBOLS[network.networkId];
+    return networkTokens && "WETH" in networkTokens ? networkTokens.WETH : undefined;
+};
+exports.getWethAddress = getWethAddress;
 /**
  * WethActionProvider is an action provider for WETH.
  */
@@ -32,7 +44,9 @@ class WethActionProvider extends actionProvider_1.ActionProvider {
          * @param network - The network to check.
          * @returns True if the Weth action provider supports the network, false otherwise.
          */
-        this.supportsNetwork = (network) => network.networkId === "base-mainnet" || network.networkId === "base-sepolia";
+        this.supportsNetwork = (network) => {
+            return (0, exports.getWethAddress)(network) !== undefined;
+        };
     }
     /**
      * Wraps ETH to WETH.
@@ -42,17 +56,30 @@ class WethActionProvider extends actionProvider_1.ActionProvider {
      * @returns A message containing the transaction hash.
      */
     async wrapEth(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        const wethAddress = (0, exports.getWethAddress)(network);
+        if (!wethAddress) {
+            return `Error: WETH not supported on network ${network.networkId}`;
+        }
         try {
+            // Convert human-readable ETH amount to wei (ETH has 18 decimals)
+            const amountInWei = (0, viem_1.parseUnits)(args.amountToWrap, 18);
+            // Check ETH balance before wrapping
+            const ethBalance = await walletProvider.getBalance();
+            if (ethBalance < amountInWei) {
+                const ethBalanceFormatted = (0, viem_1.formatUnits)(ethBalance, 18);
+                return `Error: Insufficient ETH balance. Requested to wrap ${args.amountToWrap} ETH, but only ${ethBalanceFormatted} ETH is available.`;
+            }
             const hash = await walletProvider.sendTransaction({
-                to: constants_1.WETH_ADDRESS,
+                to: wethAddress,
                 data: (0, viem_1.encodeFunctionData)({
                     abi: constants_1.WETH_ABI,
                     functionName: "deposit",
                 }),
-                value: BigInt(args.amountToWrap),
+                value: amountInWei,
             });
             await walletProvider.waitForTransactionReceipt(hash);
-            return `Wrapped ETH with transaction hash: ${hash}`;
+            return `Wrapped ${args.amountToWrap} ETH to WETH. Transaction hash: ${hash}`;
         }
         catch (error) {
             return `Error wrapping ETH: ${error}`;
@@ -66,17 +93,35 @@ class WethActionProvider extends actionProvider_1.ActionProvider {
      * @returns A message containing the transaction hash.
      */
     async unwrapEth(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        const wethAddress = (0, exports.getWethAddress)(network);
+        if (!wethAddress) {
+            return `Error: WETH not supported on network ${network.networkId}`;
+        }
         try {
+            // Convert human-readable WETH amount to wei (WETH has 18 decimals)
+            const amountInWei = (0, viem_1.parseUnits)(args.amountToUnwrap, 18);
+            // Check WETH balance before unwrapping
+            const wethBalance = await walletProvider.readContract({
+                address: wethAddress,
+                abi: viem_1.erc20Abi,
+                functionName: "balanceOf",
+                args: [walletProvider.getAddress()],
+            });
+            if (wethBalance < amountInWei) {
+                const wethBalanceFormatted = (0, viem_1.formatUnits)(wethBalance, 18);
+                return `Error: Insufficient WETH balance. Requested to unwrap ${args.amountToUnwrap} WETH, but only ${wethBalanceFormatted} WETH is available.`;
+            }
             const hash = await walletProvider.sendTransaction({
-                to: constants_1.WETH_ADDRESS,
+                to: wethAddress,
                 data: (0, viem_1.encodeFunctionData)({
                     abi: constants_1.WETH_ABI,
                     functionName: "withdraw",
-                    args: [BigInt(args.amountToUnwrap)],
+                    args: [amountInWei],
                 }),
             });
             await walletProvider.waitForTransactionReceipt(hash);
-            return `Unwrapped WETH with transaction hash: ${hash}`;
+            return `Unwrapped ${args.amountToUnwrap} WETH to ETH. Transaction hash: ${hash}`;
         }
         catch (error) {
             return `Error unwrapping WETH: ${error}`;
@@ -88,20 +133,10 @@ __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "wrap_eth",
         description: `
-    This tool can only be used to wrap ETH to WETH.
-Do not use this tool for any other purpose, or trading other assets.
+    This tool wraps ETH to WETH.
 
 Inputs:
-- Amount of ETH to wrap.
-
-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 100000000000 wei (0.0000001 WETH)
-- Only supported on the following networks:
-  - Base Sepolia (ie, 'base-sepolia')
-  - Base Mainnet (ie, 'base', 'base-mainnet')
+- Amount of ETH to wrap in human-readable format (e.g., 0.1 for 0.1 ETH).
 `,
         schema: schemas_1.WrapEthSchema,
     }),
@@ -113,20 +148,10 @@ __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.
+    This tool unwraps WETH to ETH.
 
 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')
+- Amount of WETH to unwrap in human-readable format (e.g., 0.1 for 0.1 WETH).
 `,
         schema: schemas_1.UnwrapEthSchema,
     }),

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

@@ -42,6 +42,11 @@ describe("Wrap Eth Action", () => {
     beforeEach(async () => {
         mockWallet = {
             getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            }),
+            getBalance: jest.fn().mockResolvedValue((0, viem_1.parseUnits)("20", 18)), // 20 ETH balance
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
         };
@@ -54,14 +59,14 @@ describe("Wrap Eth Action", () => {
         mockWallet.sendTransaction.mockResolvedValue(hash);
         const response = await actionProvider.wrapEth(mockWallet, args);
         expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: constants_1.WETH_ADDRESS,
+            to: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
             data: (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WETH_ABI,
                 functionName: "deposit",
             }),
-            value: BigInt(MOCK_AMOUNT),
+            value: (0, viem_1.parseUnits)(MOCK_AMOUNT, 18),
         });
-        expect(response).toContain(`Wrapped ETH with transaction hash: ${hash}`);
+        expect(response).toContain(`Wrapped ${MOCK_AMOUNT} ETH to WETH. Transaction hash: ${hash}`);
     });
     it("should fail with an error", async () => {
         const args = {
@@ -71,15 +76,25 @@ describe("Wrap Eth Action", () => {
         mockWallet.sendTransaction.mockRejectedValue(error);
         const response = await actionProvider.wrapEth(mockWallet, args);
         expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: constants_1.WETH_ADDRESS,
+            to: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
             data: (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WETH_ABI,
                 functionName: "deposit",
             }),
-            value: BigInt(MOCK_AMOUNT),
+            value: (0, viem_1.parseUnits)(MOCK_AMOUNT, 18),
         });
         expect(response).toContain(`Error wrapping ETH: ${error}`);
     });
+    it("should fail with insufficient ETH balance", async () => {
+        const args = {
+            amountToWrap: MOCK_AMOUNT,
+        };
+        // Mock insufficient balance (less than 15 ETH)
+        mockWallet.getBalance.mockResolvedValue((0, viem_1.parseUnits)("10", 18));
+        const response = await actionProvider.wrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).not.toHaveBeenCalled();
+        expect(response).toContain("Error: Insufficient ETH balance");
+    });
 });
 describe("Unwrap Eth Action", () => {
     let mockWallet;
@@ -87,6 +102,11 @@ describe("Unwrap Eth Action", () => {
     beforeEach(async () => {
         mockWallet = {
             getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            }),
+            readContract: jest.fn().mockResolvedValue((0, viem_1.parseUnits)("20", 18)), // 20 WETH balance
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
         };
@@ -98,15 +118,21 @@ describe("Unwrap Eth Action", () => {
         const hash = "0x1234567890123456789012345678901234567890";
         mockWallet.sendTransaction.mockResolvedValue(hash);
         const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.readContract).toHaveBeenCalledWith({
+            address: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
+            abi: viem_1.erc20Abi,
+            functionName: "balanceOf",
+            args: [MOCK_ADDRESS],
+        });
         expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: constants_1.WETH_ADDRESS,
+            to: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
             data: (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WETH_ABI,
                 functionName: "withdraw",
-                args: [BigInt(MOCK_AMOUNT)],
+                args: [(0, viem_1.parseUnits)(MOCK_AMOUNT, 18)],
             }),
         });
-        expect(response).toContain(`Unwrapped WETH with transaction hash: ${hash}`);
+        expect(response).toContain(`Unwrapped ${MOCK_AMOUNT} WETH to ETH. Transaction hash: ${hash}`);
     });
     it("should fail with an error", async () => {
         const args = {
@@ -115,16 +141,32 @@ describe("Unwrap Eth Action", () => {
         const error = new Error("Failed to unwrap WETH");
         mockWallet.sendTransaction.mockRejectedValue(error);
         const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.readContract).toHaveBeenCalledWith({
+            address: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
+            abi: viem_1.erc20Abi,
+            functionName: "balanceOf",
+            args: [MOCK_ADDRESS],
+        });
         expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: constants_1.WETH_ADDRESS,
+            to: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
             data: (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WETH_ABI,
                 functionName: "withdraw",
-                args: [BigInt(MOCK_AMOUNT)],
+                args: [(0, viem_1.parseUnits)(MOCK_AMOUNT, 18)],
             }),
         });
         expect(response).toContain(`Error unwrapping WETH: ${error}`);
     });
+    it("should fail with insufficient WETH balance", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        // Mock insufficient WETH balance (less than 15 WETH)
+        mockWallet.readContract.mockResolvedValue((0, viem_1.parseUnits)("10", 18));
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).not.toHaveBeenCalled();
+        expect(response).toContain("Error: Insufficient WETH balance");
+    });
 });
 describe("supportsNetwork", () => {
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
@@ -142,11 +184,18 @@ describe("supportsNetwork", () => {
         });
         expect(result).toBe(true);
     });
-    it("should return false for non-base networks", () => {
+    it("should return true for ethereum-mainnet", () => {
         const result = actionProvider.supportsNetwork({
             protocolFamily: "evm",
             networkId: "ethereum-mainnet",
         });
+        expect(result).toBe(true);
+    });
+    it("should return false for networks without WETH", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            networkId: "polygon-mainnet",
+        });
         expect(result).toBe(false);
     });
 });

package/dist/wallet-providers/cdpSmartWalletProvider.js

@@ -246,15 +246,13 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async waitForTransactionReceipt(userOpHash) {
         // For smart wallets, we need to wait for the user operation to be confirmed
-        // This is a simplified implementation - in practice you might want to poll
-        // the CDP API for user operation status
         const receipt = await __classPrivateFieldGet(this, _CdpSmartWalletProvider_cdp, "f").evm.waitForUserOperation({
             smartAccountAddress: this.smartAccount.address,
             userOpHash,
         });
         // Append transaction logs if available
         if (receipt.status === "complete") {
-            const receiptTx = await __classPrivateFieldGet(this, _CdpSmartWalletProvider_publicClient, "f").getTransactionReceipt({
+            const receiptTx = await __classPrivateFieldGet(this, _CdpSmartWalletProvider_publicClient, "f").waitForTransactionReceipt({
                 hash: receipt.transactionHash,
             });
             if (receiptTx.logs)

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.0.0-nightly-20251001210424",
+  "version": "0.0.0-nightly-20251002210424",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",