@coinbase/agentkit 0.8.2 → 0.9.1

package/dist/action-providers/truemarkets/truemarketsActionProvider.test.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const truemarketsActionProvider_1 = require("./truemarketsActionProvider");
+const constants_1 = require("./constants");
+const viem_1 = require("viem");
+// Mock viem's createPublicClient
+jest.mock("viem", () => {
+    const originalModule = jest.requireActual("viem");
+    return {
+        ...originalModule,
+        createPublicClient: jest.fn().mockImplementation(() => ({
+            // Mock public client methods as needed
+            multicall: jest.fn().mockImplementation(({ contracts }) => {
+                // Create mock responses with success status
+                return contracts.map(() => ({
+                    status: "success",
+                    result: "mock result",
+                }));
+            }),
+            readContract: jest.fn(),
+        })),
+        http: jest.fn().mockImplementation(url => ({ url })),
+    };
+});
+describe("TrueMarketsActionProvider", () => {
+    let provider;
+    let mockWallet;
+    // Mock addresses and data for tests
+    const MOCK_MARKET_ADDRESS = "0x1234567890123456789012345678901234567890";
+    const MOCK_YES_POOL_ADDRESS = "0x2345678901234567890123456789012345678901";
+    const MOCK_NO_POOL_ADDRESS = "0x3456789012345678901234567890123456789012";
+    const MOCK_YES_TOKEN_ADDRESS = "0x4567890123456789012345678901234567890123";
+    const MOCK_NO_TOKEN_ADDRESS = "0x5678901234567890123456789012345678901234";
+    const MOCK_MARKET_QUESTION = "Will this test pass?";
+    const MOCK_ADDITIONAL_INFO = "Test additional info";
+    const MOCK_MARKET_SOURCE = "Test source";
+    const MOCK_STATUS_NUM = 0n; // Created status
+    const MOCK_END_OF_TRADING = 1717171717n; // Unix timestamp
+    describe("constructor", () => {
+        it("should use the provided RPC_URL for the public client", () => {
+            const customRpcUrl = "https://custom-rpc.example.com";
+            (0, truemarketsActionProvider_1.truemarketsActionProvider)({ RPC_URL: customRpcUrl });
+            // Verify createPublicClient was called with the correct URL
+            expect(viem_1.createPublicClient).toHaveBeenCalledWith(expect.objectContaining({
+                chain: expect.anything(),
+                transport: expect.objectContaining({ url: customRpcUrl }),
+            }));
+        });
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        provider = (0, truemarketsActionProvider_1.truemarketsActionProvider)();
+        mockWallet = {
+            readContract: jest.fn(),
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            getNetwork: jest.fn().mockReturnValue({
+                networkId: "base-mainnet",
+            }),
+        };
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("getPredictionMarkets", () => {
+        it("should successfully fetch active markets", async () => {
+            // Mock readContract calls
+            mockWallet.readContract
+                // First call: numberOfActiveMarkets
+                .mockResolvedValueOnce(2n);
+            // Create a spy on the actual implementation
+            const getPredictionMarketsSpy = jest.spyOn(provider, "getPredictionMarkets");
+            // Replace the original implementation with our mocked version to return JSON string
+            getPredictionMarketsSpy.mockImplementation(async () => {
+                return JSON.stringify({
+                    success: true,
+                    totalMarkets: 2,
+                    markets: [
+                        {
+                            id: 1,
+                            address: MOCK_MARKET_ADDRESS,
+                            marketQuestion: MOCK_MARKET_QUESTION,
+                        },
+                        {
+                            id: 0,
+                            address: "0x6789012345678901234567890123456789012345",
+                            marketQuestion: "Will this other test pass?",
+                        },
+                    ],
+                });
+            });
+            const args = {
+                limit: 10,
+                offset: 0,
+                sortOrder: "desc",
+            };
+            const responseString = await provider.getPredictionMarkets(mockWallet, args);
+            const response = JSON.parse(responseString);
+            // Verify response contains expected data
+            expect(response.success).toBe(true);
+            expect(response.totalMarkets).toBe(2);
+            expect(response.markets.length).toBe(2);
+            expect(response.markets[0].marketQuestion).toBe(MOCK_MARKET_QUESTION);
+            expect(response.markets[0].address).toBe(MOCK_MARKET_ADDRESS);
+            // Restore the original implementation
+            getPredictionMarketsSpy.mockRestore();
+        });
+        it("should handle no active markets", async () => {
+            mockWallet.readContract.mockResolvedValueOnce(0n);
+            const args = {
+                limit: 10,
+                offset: 0,
+                sortOrder: "desc",
+            };
+            const responseString = await provider.getPredictionMarkets(mockWallet, args);
+            const response = JSON.parse(responseString);
+            expect(response.success).toBe(true);
+            expect(response.totalMarkets).toBe(0);
+            expect(response.markets.length).toBe(0);
+        });
+        it("should handle errors", async () => {
+            const error = new Error("Failed to fetch active markets");
+            mockWallet.readContract.mockRejectedValueOnce(error);
+            const args = {
+                limit: 10,
+                offset: 0,
+                sortOrder: "desc",
+            };
+            const responseString = await provider.getPredictionMarkets(mockWallet, args);
+            const response = JSON.parse(responseString);
+            expect(response.success).toBe(false);
+            expect(response.error).toBe("Error retrieving active markets: Error: Failed to fetch active markets");
+        });
+    });
+    describe("getPredictionMarketDetails", () => {
+        let mockPublicClient;
+        beforeEach(() => {
+            // Access the mocked public client
+            mockPublicClient = viem_1.createPublicClient.mock.results[0].value;
+            // Setup multicall mock responses
+            mockPublicClient.multicall
+                // Basic info calls
+                .mockResolvedValueOnce([
+                { status: "success", result: MOCK_MARKET_QUESTION },
+                { status: "success", result: MOCK_ADDITIONAL_INFO },
+                { status: "success", result: MOCK_MARKET_SOURCE },
+                { status: "success", result: MOCK_STATUS_NUM },
+                { status: "success", result: MOCK_END_OF_TRADING },
+                { status: "success", result: [MOCK_YES_POOL_ADDRESS, MOCK_NO_POOL_ADDRESS] },
+                { status: "success", result: 0n },
+            ])
+                // Pool info calls
+                .mockResolvedValueOnce([
+                { status: "success", result: constants_1.USDC_ADDRESS },
+                { status: "success", result: MOCK_YES_TOKEN_ADDRESS },
+                { status: "success", result: MOCK_NO_TOKEN_ADDRESS },
+                { status: "success", result: constants_1.USDC_ADDRESS },
+                { status: "success", result: [79228162514264337593543950336n, 0, 0, 0, 0, 0, true] },
+                { status: "success", result: [79228162514264337593543950336n, 0, 0, 0, 0, 0, true] },
+            ])
+                // Balance calls
+                .mockResolvedValueOnce([
+                { status: "success", result: 1000000n },
+                { status: "success", result: 500000000000000000000n },
+                { status: "success", result: 2000000n },
+                { status: "success", result: 1000000000000000000000n },
+            ]);
+        });
+        it("should successfully fetch market details", async () => {
+            const args = MOCK_MARKET_ADDRESS;
+            const responseString = await provider.getPredictionMarketDetails(mockWallet, args);
+            const response = JSON.parse(responseString);
+            // Verify the expected JSON structure
+            expect(response.success).toBe(true);
+            expect(response.marketAddress).toBe(MOCK_MARKET_ADDRESS);
+            expect(response.question).toBe(MOCK_MARKET_QUESTION);
+            expect(response.additionalInfo).toBe(MOCK_ADDITIONAL_INFO);
+            expect(response.source).toBe(MOCK_MARKET_SOURCE);
+            expect(response.status).toBe(0);
+            // Verify tokens
+            expect(response.tokens.yes.lpAddress).toBe(MOCK_YES_POOL_ADDRESS);
+            expect(response.tokens.yes.tokenAddress).toBe(MOCK_YES_TOKEN_ADDRESS);
+            expect(response.tokens.no.lpAddress).toBe(MOCK_NO_POOL_ADDRESS);
+            expect(response.tokens.no.tokenAddress).toBe(MOCK_NO_TOKEN_ADDRESS);
+            // Verify prices and tvl exist
+            expect(typeof response.prices.yes).toBe("number");
+            expect(typeof response.prices.no).toBe("number");
+            expect(typeof response.tvl).toBe("number");
+        });
+        it("should handle errors", async () => {
+            const error = new Error("Failed to fetch market details");
+            mockWallet.readContract.mockReset();
+            mockPublicClient.multicall.mockReset();
+            mockPublicClient.multicall.mockRejectedValueOnce(error);
+            const args = MOCK_MARKET_ADDRESS;
+            const responseString = await provider.getPredictionMarketDetails(mockWallet, args);
+            const response = JSON.parse(responseString);
+            expect(response.success).toBe(false);
+            expect(response.error).toBe("Error retrieving market details: Error: Failed to fetch market details");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for base-mainnet", () => {
+            const network = {
+                networkId: "base-mainnet",
+                protocolFamily: "evm",
+            };
+            expect(provider.supportsNetwork(network)).toBe(true);
+        });
+        it("should return false for other networks", () => {
+            const network = {
+                networkId: "ethereum-mainnet",
+                protocolFamily: "evm",
+            };
+            expect(provider.supportsNetwork(network)).toBe(false);
+        });
+    });
+});

package/dist/action-providers/truemarkets/utils.d.ts

@@ -0,0 +1,10 @@
+export type Slot0Result = readonly [bigint, number, number, number, number, number, boolean];
+export declare const GetMarketStatus: Record<number, string>;
+/**
+ * Interface representing a TruthMarket
+ */
+export interface TruthMarket {
+    id: number;
+    address: string;
+    marketQuestion: string;
+}

package/dist/action-providers/truemarkets/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMarketStatus = void 0;
+const constants_1 = require("./constants");
+// Create mapping for status lookup
+exports.GetMarketStatus = Object.entries(constants_1.MarketStatus).reduce((acc, [key, value]) => {
+    acc[value] = key;
+    return acc;
+}, {});

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