@coinbase/agentkit 0.10.1 → 0.10.3

package/dist/action-providers/pyth/pythActionProvider.test.js

@@ -9,39 +9,180 @@ describe("PythActionProvider", () => {
         jest.resetAllMocks().restoreAllMocks();
     });
     describe("fetchPriceFeed", () => {
-        it("should return the first price feed ID that matches the input token symbol", async () => {
+        it("should return the first price feed ID that matches the input token symbol for crypto", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
-                json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
+                json: async () => [
+                    { id: "some-price-feed-id", attributes: { base: "BTC", quote_currency: "USD" } },
+                ],
             });
-            const priceFeedId = await provider.fetchPriceFeed({ tokenSymbol: "BTC" });
-            expect(priceFeedId).toEqual("some-price-feed-id");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("some-price-feed-id");
+        });
+        it("should return the first price feed ID that matches the input token symbol for metals", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "gold-price-feed-id", attributes: { base: "XAU", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "XAU",
+                assetType: "metal",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("gold-price-feed-id");
+        });
+        it("should return the first price feed ID that matches the input token symbol for commodities", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "oil-price-feed-id", attributes: { base: "WTI", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "WTI",
+                assetType: "metal",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("oil-price-feed-id");
+        });
+        it("should return the first price feed ID that matches the input token symbol for equities", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    {
+                        id: "apple-price-feed-id",
+                        attributes: {
+                            base: "AAPL",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.AAPL/USD",
+                            display_symbol: "AAPL/USD",
+                        },
+                    },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "AAPL",
+                assetType: "equity",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("apple-price-feed-id");
         });
-        it("should throw an error if no price feed is found", async () => {
+        it("should return the first price feed ID that matches the input token symbol for FX", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
-                json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
+                json: async () => [
+                    { id: "eur-price-feed-id", attributes: { base: "EUR", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "EUR",
+                assetType: "fx",
+                quoteCurrency: "USD",
             });
-            await expect(provider.fetchPriceFeed({ tokenSymbol: "SOL" })).rejects.toThrow("No price feed found for SOL");
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("eur-price-feed-id");
         });
-        it("should return hardcoded price feed ID for ETH", async () => {
-            const priceFeedId = await provider.fetchPriceFeed({ tokenSymbol: "ETH" });
-            expect(priceFeedId).toEqual("0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace");
+        it("should return error if no price feed is found", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "some-price-feed-id", attributes: { base: "BTC", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "SOL",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price feed found for SOL/USD");
         });
-        it("should throw an error if the response is not ok", async () => {
+        it("should return error if the response is not ok", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: false,
                 status: 404,
             });
-            await expect(provider.fetchPriceFeed({ tokenSymbol: "BTC" })).rejects.toThrow("HTTP error! status: 404");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("HTTP error! status: 404");
         });
-        it("should throw an error if response is ok but no data is returned", async () => {
+        it("should return error if response is ok but no data is returned", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
                 json: async () => [],
             });
-            const provider = (0, pythActionProvider_1.pythActionProvider)();
-            await expect(provider.fetchPriceFeed({ tokenSymbol: "BTC" })).rejects.toThrow("No price feed found for BTC");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price feed found for BTC");
+        });
+        it("should prefer regular market hours feed for equities over pre/post market", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    {
+                        id: "post-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD.POST",
+                            display_symbol: "COIN/USD POST MARKET",
+                        },
+                    },
+                    {
+                        id: "regular-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD",
+                            display_symbol: "COIN/USD",
+                        },
+                    },
+                    {
+                        id: "pre-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD.PRE",
+                            display_symbol: "COIN/USD PRE MARKET",
+                        },
+                    },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "COIN",
+                assetType: "equity",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("regular-market-feed-id");
+            expect(parsed.feedType).toEqual("COIN/USD");
         });
     });
     describe("fetchPrice", () => {
@@ -59,8 +200,10 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("1");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("1");
         });
         it("should return the price for a given price feed ID with a negative exponent", async () => {
             fetchMock.mockResolvedValueOnce({
@@ -76,9 +219,10 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const provider = (0, pythActionProvider_1.pythActionProvider)();
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("1.00");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("1.00");
         });
         it("should handle scaled price starting with a decimal", async () => {
             fetchMock.mockResolvedValueOnce({
@@ -94,24 +238,32 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("0.25");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("0.25");
         });
-        it("should throw an error if there is no price data", async () => {
+        it("should return error if there is no price data", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({
                     parsed: [],
                 }),
             });
-            await expect(provider.fetchPrice({ priceFeedID: "some-price-feed-id" })).rejects.toThrow("No price data found for some-price-feed-id");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price data found for some-price-feed-id");
         });
-        it("should throw an error if response is not ok", async () => {
+        it("should return error if response is not ok", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: false,
                 status: 404,
             });
-            await expect(provider.fetchPrice({ priceFeedID: "some-price-feed-id" })).rejects.toThrow("HTTP error! status: 404");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("HTTP error! status: 404");
         });
     });
 });

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

@@ -4,10 +4,16 @@ import { z } from "zod";
  */
 export declare const PythFetchPriceFeedIDSchema: z.ZodObject<{
     tokenSymbol: z.ZodString;
+    quoteCurrency: z.ZodDefault<z.ZodString>;
+    assetType: z.ZodDefault<z.ZodEnum<["crypto", "equity", "fx", "metal"]>>;
 }, "strict", z.ZodTypeAny, {
     tokenSymbol: string;
+    quoteCurrency: string;
+    assetType: "crypto" | "equity" | "fx" | "metal";
 }, {
     tokenSymbol: string;
+    quoteCurrency?: string | undefined;
+    assetType?: "crypto" | "equity" | "fx" | "metal" | undefined;
 }>;
 /**
  * Input schema for Pyth fetch price action.

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

@@ -7,7 +7,15 @@ const zod_1 = require("zod");
  */
 exports.PythFetchPriceFeedIDSchema = zod_1.z
     .object({
-    tokenSymbol: zod_1.z.string().describe("The token symbol to fetch the price feed ID for"),
+    tokenSymbol: zod_1.z.string().describe("The asset ticker/symbol to fetch the price feed ID for"),
+    quoteCurrency: zod_1.z
+        .string()
+        .default("USD")
+        .describe("The quote currency to filter by (defaults to USD)"),
+    assetType: zod_1.z
+        .enum(["crypto", "equity", "fx", "metal"])
+        .default("crypto")
+        .describe("The asset type to search for (crypto, equity, fx, metal)"),
 })
     .strict();
 /**

package/dist/action-providers/superfluid/superfluidSuperTokenCreatorActionProvider.js

@@ -74,14 +74,15 @@ class SuperfluidSuperTokenCreatorActionProvider extends actionProvider_1.ActionP
                     `${symbol}x`,
                 ],
             });
+            const superTokenFactoryAddress = walletProvider.getNetwork().networkId === "base-sepolia"
+                ? constants_1.SuperTokenFactoryAddress_Base_Sepolia
+                : constants_1.SuperTokenFactoryAddress;
             const createSuperTokenHash = await walletProvider.sendTransaction({
-                to: walletProvider.getNetwork().networkId === "base-sepolia"
-                    ? constants_1.SuperTokenFactoryAddress_Base_Sepolia
-                    : constants_1.SuperTokenFactoryAddress,
+                to: superTokenFactoryAddress,
                 data: createSuperTokenData,
             });
             const receipt = await walletProvider.waitForTransactionReceipt(createSuperTokenHash);
-            const superTokenAddress = (0, parseLogs_1.extractCreatedSuperTokenAddressAbi)(receipt);
+            const superTokenAddress = (0, parseLogs_1.extractCreatedSuperTokenAddressAbi)(receipt, superTokenFactoryAddress);
             return `Created super token for ${args.erc20TokenAddress}.  Super token address at ${superTokenAddress}  Transaction hash: ${createSuperTokenHash}`;
         }
         catch (error) {

package/dist/action-providers/superfluid/utils/parseLogs.d.ts

@@ -12,7 +12,8 @@ type TxReceipt = {
  * Extracts the super token address using the contract abi
  *
  * @param receipt - the transaction receipt from creating the super token
+ * @param factoryAddress - the address of the factory that created the super token
  * @returns - The contract address of the created Super Token
  */
-export declare function extractCreatedSuperTokenAddressAbi(receipt: TxReceipt): `0x${string}`;
+export declare function extractCreatedSuperTokenAddressAbi(receipt: TxReceipt, factoryAddress: `0x${string}`): `0x${string}`;
 export {};

package/dist/action-providers/superfluid/utils/parseLogs.js

@@ -46,12 +46,15 @@ function pickTokenLike(args) {
  * Extracts the super token address using the contract abi
  *
  * @param receipt - the transaction receipt from creating the super token
+ * @param factoryAddress - the address of the factory that created the super token
  * @returns - The contract address of the created Super Token
  */
-function extractCreatedSuperTokenAddressAbi(receipt) {
-    const factory = receipt.to?.toLowerCase();
+function extractCreatedSuperTokenAddressAbi(receipt, factoryAddress) {
+    const factory = factoryAddress.toLowerCase();
     if (!factory)
-        throw new Error("Missing receipt.to (factory address)");
+        throw new Error("Missing factory address");
+    console.log("factory", factory);
+    console.log("receipt.logs", receipt.logs);
     for (const log of receipt.logs) {
         if (log.address.toLowerCase() !== factory)
             continue;

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

@@ -69,6 +69,9 @@ class WalletActionProvider extends actionProvider_1.ActionProvider {
                 "Wallet Details:",
                 `- Provider: ${name}`,
                 `- Address: ${address}`,
+                ...(walletProvider instanceof wallet_providers_1.CdpSmartWalletProvider
+                    ? [`- Owner Address: ${walletProvider.ownerAccount.address}`]
+                    : []),
                 "- Network:",
                 `  * Protocol Family: ${network.protocolFamily}`,
                 `  * Network ID: ${network.networkId || "N/A"}`,
@@ -130,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.
  */

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,
     }),