@coinbase/agentkit 0.0.0-nightly-20250716210450 → 0.0.0-nightly-20250724210458

package/README.md

@@ -261,7 +261,7 @@ const agent = createReactAgent({
 </tr>
 <tr>
     <td width="200"><code>post_cast</code></td>
-    <td width="768">Creates a new cast (message) on Farcaster with up to 280 characters.</td>
+    <td width="768">Creates a new cast (message) on Farcaster with up to 280 characters and support for up to 2 embedded URLs.</td>
 </tr>
 </table>
 </details>
@@ -362,6 +362,10 @@ const agent = createReactAgent({
     <td width="200"><code>post_tweet_reply</code></td>
     <td width="768">Creates a reply to an existing tweet using the tweet's unique identifier.</td>
 </tr>
+<tr>
+    <td width="200"><code>upload_media</code></td>
+    <td width="768">Uploads media (images, videos) to Twitter that can be attached to tweets.</td>
+</tr>
 </table>
 </details>
 <details>
@@ -384,6 +388,10 @@ const agent = createReactAgent({
     <td width="200"><code>wrap_eth</code></td>
     <td width="768">Converts native ETH to Wrapped ETH (WETH) on Base Sepolia or Base Mainnet.</td>
 </tr>
+<tr>
+    <td width="200"><code>unwrap_eth</code></td>
+    <td width="768">Converts Wrapped ETH (WETH) to Native ETH on Base Sepolia or Base Mainnet.</td>
+</tr>
 </table>
 </details>
 <details>

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

@@ -1,5 +1,2 @@
 export * from "./schemas";
 export * from "./cdpApiActionProvider";
-export * from "./cdpEvmWalletActionProvider";
-export * from "./cdpSolanaWalletActionProvider";
-export * from "./cdpSmartWalletActionProvider";

package/dist/action-providers/cdp/index.js

@@ -16,6 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./cdpApiActionProvider"), exports);
-__exportStar(require("./cdpEvmWalletActionProvider"), exports);
-__exportStar(require("./cdpSolanaWalletActionProvider"), exports);
-__exportStar(require("./cdpSmartWalletActionProvider"), exports);

package/dist/action-providers/farcaster/farcasterActionProvider.js

@@ -90,6 +90,7 @@ class FarcasterActionProvider extends actionProvider_1.ActionProvider {
                 body: JSON.stringify({
                     signer_uuid: this.signerUuid,
                     text: args.castText,
+                    embeds: args.embeds,
                 }),
             });
             const data = await response.json();
@@ -125,6 +126,7 @@ __decorate([
         name: "post_cast",
         description: `
 This tool will post a cast to Farcaster. The tool takes the text of the cast as input. Casts can be maximum 280 characters.
+Optionally, up to 2 embeds (links to websites or mini apps) can be attached to the cast by providing an array of URLs in the embeds parameter.
 
 A successful response will return a message with the API response as a JSON payload:
     {}

package/dist/action-providers/farcaster/farcasterActionProvider.test.js

@@ -23,6 +23,35 @@ describe("Farcaster Action Provider Input Schemas", () => {
             expect(result.success).toBe(true);
             expect(result.data).toEqual(validInput);
         });
+        it("should successfully parse valid cast text with embeds", () => {
+            const validInput = {
+                castText: "Hello, Farcaster!",
+                embeds: [{ url: "https://example.com" }],
+            };
+            const result = schemas_1.FarcasterPostCastSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail when embed URL is invalid", () => {
+            const invalidInput = {
+                castText: "Hello, Farcaster!",
+                embeds: [{ url: "invalid-url" }],
+            };
+            const result = schemas_1.FarcasterPostCastSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail when there are more than 2 embeds", () => {
+            const invalidInput = {
+                castText: "Hello, Farcaster!",
+                embeds: [
+                    { url: "https://example1.com" },
+                    { url: "https://example2.com" },
+                    { url: "https://example3.com" },
+                ],
+            };
+            const result = schemas_1.FarcasterPostCastSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
         it("should fail parsing cast text over 280 characters", () => {
             const invalidInput = {
                 castText: "a".repeat(281),
@@ -100,6 +129,32 @@ describe("Farcaster Action Provider", () => {
                 body: JSON.stringify({
                     signer_uuid: mockConfig.signerUuid,
                     text: args.castText,
+                    embeds: undefined,
+                }),
+            });
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            expect(result).toContain("Successfully posted cast to Farcaster");
+            expect(result).toContain(JSON.stringify(mockCastResponse));
+        });
+        it("should successfully post a cast with embeds", async () => {
+            mockFetch.mockResolvedValueOnce({
+                json: () => Promise.resolve(mockCastResponse),
+            });
+            const args = {
+                castText: "Hello, Farcaster!",
+                embeds: [{ url: "https://example.com" }],
+            };
+            const result = await actionProvider.postCast(args);
+            expect(mockFetch).toHaveBeenCalledWith("https://api.neynar.com/v2/farcaster/cast", {
+                method: "POST",
+                headers: {
+                    api_key: mockConfig.neynarApiKey,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    signer_uuid: mockConfig.signerUuid,
+                    text: args.castText,
+                    embeds: args.embeds,
                 }),
             });
             expect(mockFetch).toHaveBeenCalledTimes(1);

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

@@ -8,8 +8,21 @@ export declare const FarcasterAccountDetailsSchema: z.ZodObject<{}, "strip", z.Z
  */
 export declare const FarcasterPostCastSchema: z.ZodObject<{
     castText: z.ZodString;
+    embeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     castText: string;
+    embeds?: {
+        url: string;
+    }[] | undefined;
 }, {
     castText: string;
+    embeds?: {
+        url: string;
+    }[] | undefined;
 }>;

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

@@ -15,6 +15,12 @@ exports.FarcasterAccountDetailsSchema = zod_1.z
 exports.FarcasterPostCastSchema = zod_1.z
     .object({
     castText: zod_1.z.string().max(280, "Cast text must be a maximum of 280 characters."),
+    embeds: zod_1.z
+        .array(zod_1.z.object({
+        url: zod_1.z.string().url("Embed URL must be a valid URL"),
+    }))
+        .max(2, "Maximum of 2 embeds allowed")
+        .optional(),
 })
     .strip()
     .describe("Input schema for posting a text-based cast");

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

@@ -18,10 +18,13 @@ export declare const TwitterAccountMentionsSchema: z.ZodObject<{
  */
 export declare const TwitterPostTweetSchema: z.ZodObject<{
     tweet: z.ZodString;
+    mediaIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     tweet: string;
+    mediaIds?: string[] | undefined;
 }, {
     tweet: string;
+    mediaIds?: string[] | undefined;
 }>;
 /**
  * Input schema for posting a tweet reply.
@@ -29,10 +32,23 @@ export declare const TwitterPostTweetSchema: z.ZodObject<{
 export declare const TwitterPostTweetReplySchema: z.ZodObject<{
     tweetId: z.ZodString;
     tweetReply: z.ZodString;
+    mediaIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     tweetId: string;
     tweetReply: string;
+    mediaIds?: string[] | undefined;
 }, {
     tweetId: string;
     tweetReply: string;
+    mediaIds?: string[] | undefined;
+}>;
+/**
+ * Input schema for uploading media.
+ */
+export declare const TwitterUploadMediaSchema: z.ZodObject<{
+    filePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    filePath: string;
+}, {
+    filePath: string;
 }>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TwitterPostTweetReplySchema = exports.TwitterPostTweetSchema = exports.TwitterAccountMentionsSchema = exports.TwitterAccountDetailsSchema = void 0;
+exports.TwitterUploadMediaSchema = exports.TwitterPostTweetReplySchema = exports.TwitterPostTweetSchema = exports.TwitterAccountMentionsSchema = exports.TwitterAccountDetailsSchema = void 0;
 const zod_1 = require("zod");
 /**
  * Input schema for retrieving account details.
@@ -27,6 +27,11 @@ exports.TwitterAccountMentionsSchema = zod_1.z
 exports.TwitterPostTweetSchema = zod_1.z
     .object({
     tweet: zod_1.z.string().max(280, "Tweet must be a maximum of 280 characters."),
+    mediaIds: zod_1.z
+        .array(zod_1.z.string())
+        .max(4, "Maximum of 4 media IDs allowed")
+        .optional()
+        .describe("Optional array of 1-4 media IDs to attach to the tweet"),
 })
     .strip()
     .describe("Input schema for posting a tweet");
@@ -39,6 +44,23 @@ exports.TwitterPostTweetReplySchema = zod_1.z
     tweetReply: zod_1.z
         .string()
         .max(280, "The reply to the tweet which must be a maximum of 280 characters."),
+    mediaIds: zod_1.z
+        .array(zod_1.z.string())
+        .max(4, "Maximum of 4 media IDs allowed")
+        .optional()
+        .describe("Optional array of 1-4 media IDs to attach to the tweet"),
 })
     .strip()
     .describe("Input schema for posting a tweet reply");
+/**
+ * Input schema for uploading media.
+ */
+exports.TwitterUploadMediaSchema = zod_1.z
+    .object({
+    filePath: zod_1.z
+        .string()
+        .min(1, "File path is required.")
+        .describe("The path to the media file to upload"),
+})
+    .strip()
+    .describe("Input schema for uploading media to Twitter");

package/dist/action-providers/twitter/twitterActionProvider.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { TwitterAccountDetailsSchema, TwitterAccountMentionsSchema, TwitterPostTweetSchema, TwitterPostTweetReplySchema } from "./schemas";
+import { TwitterAccountDetailsSchema, TwitterAccountMentionsSchema, TwitterPostTweetSchema, TwitterPostTweetReplySchema, TwitterUploadMediaSchema } from "./schemas";
 /**
  * Configuration options for the TwitterActionProvider.
  */
@@ -65,6 +65,13 @@ export declare class TwitterActionProvider extends ActionProvider {
      * @returns A JSON string containing the posted reply details or error message
      */
     postTweetReply(args: z.infer<typeof TwitterPostTweetReplySchema>): Promise<string>;
+    /**
+     * Upload media to Twitter.
+     *
+     * @param args - The arguments containing the file path
+     * @returns A JSON string containing the media ID or error message
+     */
+    uploadMedia(args: z.infer<typeof TwitterUploadMediaSchema>): Promise<string>;
     /**
      * Checks if the Twitter action provider supports the given network.
      * Twitter actions don't depend on blockchain networks, so always return true.

package/dist/action-providers/twitter/twitterActionProvider.js

@@ -90,11 +90,19 @@ class TwitterActionProvider extends actionProvider_1.ActionProvider {
      */
     async postTweet(args) {
         try {
-            const response = await this.getClient().v2.tweet(args.tweet);
+            let mediaOptions = {};
+            if (args.mediaIds && args.mediaIds.length > 0) {
+                // Convert array to tuple format expected by the Twitter API
+                const mediaIdsTuple = args.mediaIds;
+                mediaOptions = {
+                    media: { media_ids: mediaIdsTuple },
+                };
+            }
+            const response = await this.getClient().v2.tweet(args.tweet, mediaOptions);
             return `Successfully posted to Twitter:\n${JSON.stringify(response)}`;
         }
         catch (error) {
-            return `Error posting to Twitter:\n${error}`;
+            return `Error posting to Twitter:\n${error} with media ids: ${args.mediaIds}`;
         }
     }
     /**
@@ -105,15 +113,36 @@ class TwitterActionProvider extends actionProvider_1.ActionProvider {
      */
     async postTweetReply(args) {
         try {
-            const response = await this.getClient().v2.tweet(args.tweetReply, {
+            const options = {
                 reply: { in_reply_to_tweet_id: args.tweetId },
-            });
+            };
+            if (args.mediaIds && args.mediaIds.length > 0) {
+                // Convert array to tuple format expected by the Twitter API
+                const mediaIdsTuple = args.mediaIds;
+                options.media = { media_ids: mediaIdsTuple };
+            }
+            const response = await this.getClient().v2.tweet(args.tweetReply, options);
             return `Successfully posted reply to Twitter:\n${JSON.stringify(response)}`;
         }
         catch (error) {
             return `Error posting reply to Twitter: ${error}`;
         }
     }
+    /**
+     * Upload media to Twitter.
+     *
+     * @param args - The arguments containing the file path
+     * @returns A JSON string containing the media ID or error message
+     */
+    async uploadMedia(args) {
+        try {
+            const mediaId = await this.getClient().v1.uploadMedia(args.filePath);
+            return `Successfully uploaded media to Twitter: ${mediaId}`;
+        }
+        catch (error) {
+            return `Error uploading media to Twitter: ${error}`;
+        }
+    }
     /**
      * Checks if the Twitter action provider supports the given network.
      * Twitter actions don't depend on blockchain networks, so always return true.
@@ -183,6 +212,8 @@ __decorate([
         name: "post_tweet",
         description: `
 This tool will post a tweet on Twitter. The tool takes the text of the tweet as input. Tweets can be maximum 280 characters.
+Optionally, up to 4 media items (images, videos) can be attached to the tweet by providing their media IDs in the mediaIds array.
+Media IDs are obtained by first uploading the media using the upload_media action.
 
 A successful response will return a message with the API response as a JSON payload:
     {"data": {"text": "hello, world!", "id": "0123456789012345678", "edit_history_tweet_ids": ["0123456789012345678"]}}
@@ -199,7 +230,10 @@ __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "post_tweet_reply",
         description: `
-This tool will post a tweet on Twitter. The tool takes the text of the tweet as input. Tweets can be maximum 280 characters.
+This tool will post a reply to a tweet on Twitter. The tool takes the text of the reply and the ID of the tweet to reply to as input.
+Replies can be maximum 280 characters.
+Optionally, up to 4 media items (images, videos) can be attached to the reply by providing their media IDs in the mediaIds array.
+Media IDs can be obtained by first uploading the media using the upload_media action.
 
 A successful response will return a message with the API response as a JSON payload:
     {"data": {"text": "hello, world!", "id": "0123456789012345678", "edit_history_tweet_ids": ["0123456789012345678"]}}
@@ -212,6 +246,23 @@ A failure response will return a message with the Twitter API request error:
     __metadata("design:paramtypes", [void 0]),
     __metadata("design:returntype", Promise)
 ], TwitterActionProvider.prototype, "postTweetReply", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "upload_media",
+        description: `
+This tool will upload media (images, videos, etc.) to Twitter.
+
+A successful response will return a message with the media ID:
+    Successfully uploaded media to Twitter: 1234567890
+
+A failure response will return a message with the Twitter API request error:
+    Error uploading media to Twitter: Invalid file format`,
+        schema: schemas_1.TwitterUploadMediaSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], TwitterActionProvider.prototype, "uploadMedia", null);
 /**
  * Factory function to create a new TwitterActionProvider instance.
  *

package/dist/action-providers/twitter/twitterActionProvider.test.js

@@ -14,16 +14,24 @@ const MOCK_USERNAME = "CDPAgentkit";
 const MOCK_TWEET = "Hello, world!";
 const MOCK_TWEET_ID = "0123456789012345678";
 const MOCK_TWEET_REPLY = "Hello again!";
+const MOCK_MEDIA_ID = "987654321";
+const MOCK_FILE_PATH = "/path/to/image.jpg";
 describe("TwitterActionProvider", () => {
     let mockClient;
     let provider;
+    let mockUploadMedia;
     beforeEach(() => {
         mockClient = {
             me: jest.fn(),
             userMentionTimeline: jest.fn(),
             tweet: jest.fn(),
         };
+        mockUploadMedia = jest.fn();
         jest.spyOn(twitter_api_v2_1.TwitterApi.prototype, "v2", "get").mockReturnValue(mockClient);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        jest.spyOn(twitter_api_v2_1.TwitterApi.prototype, "v1", "get").mockReturnValue({
+            uploadMedia: mockUploadMedia,
+        });
         provider = new twitterActionProvider_1.TwitterActionProvider(MOCK_CONFIG);
     });
     describe("Constructor", () => {
@@ -145,7 +153,16 @@ describe("TwitterActionProvider", () => {
         });
         it("should successfully post a tweet", async () => {
             const response = await provider.postTweet({ tweet: MOCK_TWEET });
-            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET);
+            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET, {});
+            expect(response).toContain("Successfully posted to Twitter");
+            expect(response).toContain(JSON.stringify(mockResponse));
+        });
+        it("should successfully post a tweet with media", async () => {
+            const mediaIds = [MOCK_MEDIA_ID];
+            const response = await provider.postTweet({ tweet: MOCK_TWEET, mediaIds });
+            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET, {
+                media: { media_ids: mediaIds },
+            });
             expect(response).toContain("Successfully posted to Twitter");
             expect(response).toContain(JSON.stringify(mockResponse));
         });
@@ -153,7 +170,7 @@ describe("TwitterActionProvider", () => {
             const error = new Error("An error has occurred");
             mockClient.tweet.mockRejectedValue(error);
             const response = await provider.postTweet({ tweet: MOCK_TWEET });
-            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET);
+            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET, {});
             expect(response).toContain("Error posting to Twitter");
             expect(response).toContain(error.message);
         });
@@ -180,6 +197,20 @@ describe("TwitterActionProvider", () => {
             expect(response).toContain("Successfully posted reply to Twitter");
             expect(response).toContain(JSON.stringify(mockResponse));
         });
+        it("should successfully post a tweet reply with media", async () => {
+            const mediaIds = [MOCK_MEDIA_ID];
+            const response = await provider.postTweetReply({
+                tweetId: MOCK_TWEET_ID,
+                tweetReply: MOCK_TWEET_REPLY,
+                mediaIds,
+            });
+            expect(mockClient.tweet).toHaveBeenCalledWith(MOCK_TWEET_REPLY, {
+                reply: { in_reply_to_tweet_id: MOCK_TWEET_ID },
+                media: { media_ids: mediaIds },
+            });
+            expect(response).toContain("Successfully posted reply to Twitter");
+            expect(response).toContain(JSON.stringify(mockResponse));
+        });
         it("should handle errors when posting a tweet reply", async () => {
             const error = new Error("An error has occurred");
             mockClient.tweet.mockRejectedValue(error);
@@ -194,6 +225,25 @@ describe("TwitterActionProvider", () => {
             expect(response).toContain(error.message);
         });
     });
+    describe("Upload Media Action", () => {
+        beforeEach(() => {
+            mockUploadMedia.mockResolvedValue(MOCK_MEDIA_ID);
+        });
+        it("should successfully upload media", async () => {
+            const response = await provider.uploadMedia({ filePath: MOCK_FILE_PATH });
+            expect(mockUploadMedia).toHaveBeenCalledWith(MOCK_FILE_PATH);
+            expect(response).toContain("Successfully uploaded media to Twitter");
+            expect(response).toContain(MOCK_MEDIA_ID);
+        });
+        it("should handle errors when uploading media", async () => {
+            const error = new Error("Invalid file format");
+            mockUploadMedia.mockRejectedValue(error);
+            const response = await provider.uploadMedia({ filePath: MOCK_FILE_PATH });
+            expect(mockUploadMedia).toHaveBeenCalledWith(MOCK_FILE_PATH);
+            expect(response).toContain("Error uploading media to Twitter");
+            expect(response).toContain(error.message);
+        });
+    });
     describe("Network Support", () => {
         it("should always return true for network support", () => {
             expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "1" })).toBe(true);

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

@@ -5,6 +5,15 @@ export declare const WETH_ABI: readonly [{
     readonly outputs: readonly [];
     readonly stateMutability: "payable";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "wad";
+        readonly type: "uint256";
+    }];
+    readonly name: "withdraw";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly inputs: readonly [{
         readonly name: "account";

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

@@ -10,6 +10,18 @@ exports.WETH_ABI = [
         stateMutability: "payable",
         type: "function",
     },
+    {
+        inputs: [
+            {
+                name: "wad",
+                type: "uint256",
+            },
+        ],
+        name: "withdraw",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
     {
         inputs: [
             {

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

@@ -6,3 +6,10 @@ export declare const WrapEthSchema: z.ZodObject<{
 }, {
     amountToWrap: string;
 }>;
+export declare const UnwrapEthSchema: z.ZodObject<{
+    amountToUnwrap: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    amountToUnwrap: string;
+}, {
+    amountToUnwrap: string;
+}>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WrapEthSchema = void 0;
+exports.UnwrapEthSchema = exports.WrapEthSchema = void 0;
 const zod_1 = require("zod");
 exports.WrapEthSchema = zod_1.z
     .object({
@@ -8,3 +8,9 @@ exports.WrapEthSchema = zod_1.z
 })
     .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"),
+})
+    .strip()
+    .describe("Instructions for unwrapping WETH to ETH");

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { WrapEthSchema } from "./schemas";
+import { WrapEthSchema, UnwrapEthSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
 /**
  * WethActionProvider is an action provider for WETH.
@@ -19,6 +19,14 @@ export declare class WethActionProvider extends ActionProvider<EvmWalletProvider
      * @returns A message containing the transaction hash.
      */
     wrapEth(walletProvider: EvmWalletProvider, args: z.infer<typeof WrapEthSchema>): Promise<string>;
+    /**
+     * Unwraps WETH to ETH.
+     *
+     * @param walletProvider - The wallet provider to use for the action.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transaction hash.
+     */
+    unwrapEth(walletProvider: EvmWalletProvider, args: z.infer<typeof UnwrapEthSchema>): Promise<string>;
     /**
      * Checks if the Weth action provider supports the given network.
      *

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

@@ -58,6 +58,30 @@ class WethActionProvider extends actionProvider_1.ActionProvider {
             return `Error wrapping ETH: ${error}`;
         }
     }
+    /**
+     * Unwraps WETH to ETH.
+     *
+     * @param walletProvider - The wallet provider to use for the action.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transaction hash.
+     */
+    async unwrapEth(walletProvider, args) {
+        try {
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.WETH_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WETH_ABI,
+                    functionName: "withdraw",
+                    args: [BigInt(args.amountToUnwrap)],
+                }),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Unwrapped WETH with transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error unwrapping WETH: ${error}`;
+        }
+    }
 }
 exports.WethActionProvider = WethActionProvider;
 __decorate([
@@ -74,7 +98,7 @@ 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 100000000000000 wei (0.0000001 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')
@@ -85,5 +109,30 @@ Important notes:
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], WethActionProvider.prototype, "wrapEth", null);
+__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.
+
+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')
+`,
+        schema: schemas_1.UnwrapEthSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WethActionProvider.prototype, "unwrapEth", null);
 const wethActionProvider = () => new WethActionProvider();
 exports.wethActionProvider = wethActionProvider;