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

package/dist/action-providers/flaunch/{utils.js → swap_utils.js}

@@ -1,174 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSwapAmountsFromReceipt = exports.getSwapAmountsFromLog = exports.memecoinToEthWithPermit2 = exports.ethToMemecoin = exports.getAmountWithSlippage = exports.generateTokenUri = void 0;
+exports.getSwapAmountsFromReceipt = exports.getSwapAmountsFromLog = exports.memecoinToEthWithPermit2 = exports.ethToMemecoin = exports.getAmountWithSlippage = void 0;
+exports.buyFlaunchCoin = buyFlaunchCoin;
 const viem_1 = require("viem");
 const constants_1 = require("./constants");
-/**
- * Uploads a base64 image to IPFS using Pinata
- *
- * @param params - Configuration and base64 image data
- * @param params.pinataConfig - Pinata configuration including JWT
- * @param params.base64Image - Base64 encoded image data
- * @param params.name - Optional name for the uploaded file
- * @param params.metadata - Optional metadata key-value pairs
- * @returns Upload response with CID and other details
- */
-const uploadImageToIPFS = async (params) => {
-    try {
-        const formData = new FormData();
-        // Convert base64 to Blob and then to File
-        // Remove data URL prefix if present (e.g., "data:image/jpeg;base64,")
-        const base64Data = params.base64Image.split(",")[1] || params.base64Image;
-        const byteCharacters = atob(base64Data);
-        const byteArrays = [];
-        for (let offset = 0; offset < byteCharacters.length; offset += 1024) {
-            const slice = byteCharacters.slice(offset, offset + 1024);
-            const byteNumbers = new Array(slice.length);
-            for (let i = 0; i < slice.length; i++) {
-                byteNumbers[i] = slice.charCodeAt(i);
-            }
-            const byteArray = new Uint8Array(byteNumbers);
-            byteArrays.push(byteArray);
-        }
-        // Detect mime type from base64 string
-        let mimeType = "image/png"; // default
-        if (params.base64Image.startsWith("data:")) {
-            mimeType = params.base64Image.split(";")[0].split(":")[1];
-        }
-        const blob = new Blob(byteArrays, { type: mimeType });
-        const fileName = params.name || `image.${mimeType.split("/")[1]}`;
-        const file = new File([blob], fileName, { type: mimeType });
-        formData.append("file", file);
-        const pinataMetadata = {
-            name: params.name || null,
-            keyvalues: params.metadata || {},
-        };
-        formData.append("pinataMetadata", JSON.stringify(pinataMetadata));
-        const pinataOptions = {
-            cidVersion: 1,
-        };
-        formData.append("pinataOptions", JSON.stringify(pinataOptions));
-        const response = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${params.pinataConfig.jwt}`,
-            },
-            body: formData,
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(`Failed to upload image to IPFS: ${error.message || response.statusText}`);
-        }
-        const data = await response.json();
-        return {
-            IpfsHash: data.IpfsHash,
-            PinSize: data.PinSize,
-            Timestamp: data.Timestamp,
-            isDuplicate: data.isDuplicate || false,
-        };
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to upload image to IPFS: ${error.message}`);
-        }
-        throw error;
-    }
-};
-/**
- * Uploads JSON data to IPFS using Pinata
- *
- * @param params - Configuration and JSON data
- * @param params.pinataConfig - Pinata configuration including JWT
- * @param params.json - JSON data to upload
- * @param params.name - Optional name for the uploaded file
- * @param params.metadata - Optional metadata key-value pairs
- * @returns Upload response with CID and other details
- */
-const uploadJsonToIPFS = async (params) => {
-    try {
-        const requestBody = {
-            pinataOptions: {
-                cidVersion: 1,
-            },
-            pinataMetadata: {
-                name: params.name || null,
-                keyvalues: params.metadata || {},
-            },
-            pinataContent: params.json,
-        };
-        const response = await fetch("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${params.pinataConfig.jwt}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(requestBody),
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(`Failed to upload JSON to IPFS: ${error.message || response.statusText}`);
-        }
-        const data = await response.json();
-        return {
-            IpfsHash: data.IpfsHash,
-            PinSize: data.PinSize,
-            Timestamp: data.Timestamp,
-            isDuplicate: data.isDuplicate || false,
-        };
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to upload JSON to IPFS: ${error.message}`);
-        }
-        throw error;
-    }
-};
-const generateTokenUriBase64Image = async (name, params) => {
-    // 1. upload image to IPFS
-    const imageRes = await uploadImageToIPFS({
-        pinataConfig: params.pinataConfig,
-        base64Image: params.metadata.base64Image,
-    });
-    // 2. upload metadata to IPFS
-    const coinMetadata = {
-        name,
-        description: params.metadata.description,
-        image: `ipfs://${imageRes.IpfsHash}`,
-        external_link: params.metadata.websiteUrl || "",
-        collaborators: [],
-        discordUrl: params.metadata.discordUrl || "",
-        twitterUrl: params.metadata.twitterUrl || "",
-        telegramUrl: params.metadata.telegramUrl || "",
-    };
-    const metadataRes = await uploadJsonToIPFS({
-        pinataConfig: params.pinataConfig,
-        json: coinMetadata,
-    });
-    return `ipfs://${metadataRes.IpfsHash}`;
-};
-const generateTokenUri = async (name, params) => {
-    // 1. get base64Image from imageUrl
-    const response = await fetch(params.metadata.imageUrl);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch image: ${response.statusText}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const base64Image = Buffer.from(arrayBuffer).toString("base64");
-    // 2. generate token uri
-    const tokenUri = await generateTokenUriBase64Image(name, {
-        pinataConfig: params.pinataConfig,
-        metadata: {
-            base64Image,
-            description: params.metadata.description,
-            websiteUrl: params.metadata.websiteUrl,
-            discordUrl: params.metadata.discordUrl,
-            twitterUrl: params.metadata.twitterUrl,
-            telegramUrl: params.metadata.telegramUrl,
-        },
-    });
-    return tokenUri;
-};
-exports.generateTokenUri = generateTokenUri;
+const network_1 = require("../../network");
+const viem_2 = require("viem");
 const getAmountWithSlippage = (amount, slippage, swapType) => {
     if (amount == null) {
         return 0n;
@@ -184,7 +21,7 @@ const ETH = viem_1.zeroAddress;
 const ethToMemecoin = (params) => {
     const flETH = constants_1.FLETHAddress[params.chainId];
     const flETHHooks = constants_1.FLETHHooksAddress[params.chainId];
-    const flaunchHooks = constants_1.FlaunchPositionManagerAddress[params.chainId];
+    const flaunchHooks = constants_1.FlaunchPositionManagerV1_1Address[params.chainId];
     // Determine actions based on swapType
     const v4Actions = ("0x" +
         (params.swapType === "EXACT_IN" ? constants_1.V4Actions.SWAP_EXACT_IN : constants_1.V4Actions.SWAP_EXACT_OUT) +
@@ -314,11 +151,11 @@ const ethToMemecoin = (params) => {
 };
 exports.ethToMemecoin = ethToMemecoin;
 // @notice Before calling the UniversalRouter the user must have:
-// 1. Given the Permit2 contract allowance to spend the memecoin
+// Given the Permit2 contract allowance to spend the memecoin
 const memecoinToEthWithPermit2 = (params) => {
     const flETH = constants_1.FLETHAddress[params.chainId];
     const flETHHooks = constants_1.FLETHHooksAddress[params.chainId];
-    const flaunchHooks = constants_1.FlaunchPositionManagerAddress[params.chainId];
+    const flaunchHooks = constants_1.FlaunchPositionManagerV1_1Address[params.chainId];
     const v4Actions = ("0x" +
         constants_1.V4Actions.SWAP_EXACT_IN +
         constants_1.V4Actions.SETTLE_ALL +
@@ -483,11 +320,11 @@ const getSwapAmountsFromReceipt = ({ receipt, coinAddress, chainId, }) => {
     const filteredPoolSwapEvent = receipt.logs
         .map(log => {
         try {
-            if (log.address.toLowerCase() !== constants_1.FlaunchPositionManagerAddress[chainId].toLowerCase()) {
+            if (log.address.toLowerCase() !== constants_1.FlaunchPositionManagerV1_1Address[chainId].toLowerCase()) {
                 return null;
             }
             const event = (0, viem_1.decodeEventLog)({
-                abi: constants_1.POSITION_MANAGER_ABI,
+                abi: constants_1.POSITION_MANAGERV1_1_ABI,
                 data: log.data,
                 topics: log.topics,
             });
@@ -505,3 +342,131 @@ const getSwapAmountsFromReceipt = ({ receipt, coinAddress, chainId, }) => {
     });
 };
 exports.getSwapAmountsFromReceipt = getSwapAmountsFromReceipt;
+/**
+ * Buys a flaunch coin using ETH input.
+ *
+ * @param walletProvider - The wallet provider instance for blockchain interactions
+ * @param coinAddress - The address of the coin to buy
+ * @param swapType - The type of swap to perform
+ * @param swapParams - The parameters for the swap
+ * @param swapParams.amountIn - The amount of ETH to spend (for EXACT_IN)
+ * @param swapParams.amountOut - The amount of coins to buy (for EXACT_OUT)
+ * @param slippagePercent - The slippage percentage
+ * @returns A promise that resolves to a string describing the transaction result
+ */
+async function buyFlaunchCoin(walletProvider, coinAddress, swapType, swapParams, slippagePercent) {
+    const network = walletProvider.getNetwork();
+    const chainId = network.chainId;
+    const networkId = network.networkId;
+    if (!chainId || !networkId) {
+        throw new Error("Chain ID is not set.");
+    }
+    try {
+        let amountIn;
+        let amountOutMin;
+        let amountOut;
+        let amountInMax;
+        if (swapType === "EXACT_IN") {
+            amountIn = (0, viem_1.parseEther)(swapParams.amountIn);
+            const quoteResult = await walletProvider.getPublicClient().simulateContract({
+                address: constants_1.QuoterAddress[chainId],
+                abi: constants_1.QUOTER_ABI,
+                functionName: "quoteExactInput",
+                args: [
+                    {
+                        exactAmount: amountIn,
+                        exactCurrency: viem_1.zeroAddress, // ETH
+                        path: [
+                            {
+                                fee: 0,
+                                tickSpacing: 60,
+                                hookData: "0x",
+                                hooks: constants_1.FLETHHooksAddress[chainId],
+                                intermediateCurrency: constants_1.FLETHAddress[chainId],
+                            },
+                            {
+                                fee: 0,
+                                tickSpacing: 60,
+                                hooks: constants_1.FlaunchPositionManagerV1_1Address[chainId],
+                                hookData: "0x",
+                                intermediateCurrency: coinAddress,
+                            },
+                        ],
+                    },
+                ],
+            });
+            amountOutMin = (0, exports.getAmountWithSlippage)(quoteResult.result[0], // amountOut
+            (slippagePercent / 100).toFixed(18).toString(), swapType);
+        }
+        else {
+            // EXACT_OUT
+            amountOut = (0, viem_1.parseEther)(swapParams.amountOut);
+            const quoteResult = await walletProvider.getPublicClient().simulateContract({
+                address: constants_1.QuoterAddress[chainId],
+                abi: constants_1.QUOTER_ABI,
+                functionName: "quoteExactOutput",
+                args: [
+                    {
+                        path: [
+                            {
+                                intermediateCurrency: viem_1.zeroAddress,
+                                fee: 0,
+                                tickSpacing: 60,
+                                hookData: "0x",
+                                hooks: constants_1.FLETHHooksAddress[chainId],
+                            },
+                            {
+                                intermediateCurrency: constants_1.FLETHAddress[chainId],
+                                fee: 0,
+                                tickSpacing: 60,
+                                hooks: constants_1.FlaunchPositionManagerV1_1Address[chainId],
+                                hookData: "0x",
+                            },
+                        ],
+                        exactCurrency: coinAddress,
+                        exactAmount: amountOut,
+                    },
+                ],
+            });
+            amountInMax = (0, exports.getAmountWithSlippage)(quoteResult.result[0], // amountIn
+            (slippagePercent / 100).toFixed(18).toString(), swapType);
+        }
+        const { commands, inputs } = (0, exports.ethToMemecoin)({
+            sender: walletProvider.getAddress(),
+            memecoin: coinAddress,
+            chainId: Number(chainId),
+            referrer: viem_1.zeroAddress,
+            swapType,
+            amountIn,
+            amountOutMin,
+            amountOut,
+            amountInMax,
+        });
+        const data = (0, viem_1.encodeFunctionData)({
+            abi: constants_1.UNIVERSAL_ROUTER_ABI,
+            functionName: "execute",
+            args: [commands, inputs],
+        });
+        const hash = await walletProvider.sendTransaction({
+            to: constants_1.UniversalRouterAddress[chainId],
+            data,
+            value: swapType === "EXACT_IN" ? amountIn : amountInMax,
+        });
+        const receipt = await walletProvider.waitForTransactionReceipt(hash);
+        const swapAmounts = (0, exports.getSwapAmountsFromReceipt)({
+            receipt,
+            coinAddress: coinAddress,
+            chainId: Number(chainId),
+        });
+        const coinSymbol = await walletProvider.readContract({
+            address: coinAddress,
+            abi: constants_1.ERC20_ABI,
+            functionName: "symbol",
+        });
+        return `Bought ${(0, viem_2.formatEther)(swapAmounts.coinsBought)} $${coinSymbol} for ${(0, viem_2.formatEther)(swapAmounts.ethSold)} ETH\n
+      Tx hash: [${hash}](${network_1.NETWORK_ID_TO_VIEM_CHAIN[networkId].blockExplorers?.default.url}/tx/${hash})`;
+    }
+    catch (error) {
+        return `Error buying coin: ${error}`;
+    }
+}

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

@@ -3,11 +3,14 @@ export * from "./actionProvider";
 export * from "./customActionProvider";
 export * from "./across";
 export * from "./alchemy";
+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";
@@ -29,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

@@ -19,11 +19,14 @@ __exportStar(require("./actionProvider"), exports);
 __exportStar(require("./customActionProvider"), exports);
 __exportStar(require("./across"), exports);
 __exportStar(require("./alchemy"), exports);
+__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);
@@ -45,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/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"}`,

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