@coinbase/agentkit 0.8.2 → 0.9.1

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;

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

@@ -21,6 +21,21 @@ describe("Wrap Eth Schema", () => {
         expect(result.success).toBe(false);
     });
 });
+describe("Unwrap Eth Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const result = schemas_1.UnwrapEthSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.UnwrapEthSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
 describe("Wrap Eth Action", () => {
     let mockWallet;
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
@@ -66,6 +81,51 @@ describe("Wrap Eth Action", () => {
         expect(response).toContain(`Error wrapping ETH: ${error}`);
     });
 });
+describe("Unwrap Eth Action", () => {
+    let mockWallet;
+    const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
+    beforeEach(async () => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+        };
+    });
+    it("should successfully respond", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const hash = "0x1234567890123456789012345678901234567890";
+        mockWallet.sendTransaction.mockResolvedValue(hash);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Unwrapped WETH with transaction hash: ${hash}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const error = new Error("Failed to unwrap WETH");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Error unwrapping WETH: ${error}`);
+    });
+});
 describe("supportsNetwork", () => {
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
     it("should return true for base-mainnet", () => {

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

@@ -1,30 +1,77 @@
 import { z } from "zod";
-export declare const PaidRequestSchema: z.ZodObject<{
+export declare const HttpRequestSchema: z.ZodObject<{
     url: z.ZodString;
-    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
+    method: z.ZodDefault<z.ZodNullable<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>>;
+    headers: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    body: z.ZodNullable<z.ZodOptional<z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null;
+    url: string;
+    body?: any;
+    headers?: Record<string, string> | null | undefined;
+}, {
+    url: string;
+    method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null | undefined;
+    body?: any;
+    headers?: Record<string, string> | null | undefined;
+}>;
+export declare const RetryWithX402Schema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodDefault<z.ZodNullable<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     body: z.ZodOptional<z.ZodAny>;
+    selectedPaymentOption: z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        maxAmountRequired: z.ZodString;
+        asset: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        scheme: string;
+        network: string;
+        asset: string;
+        maxAmountRequired: string;
+    }, {
+        scheme: string;
+        network: string;
+        asset: string;
+        maxAmountRequired: string;
+    }>;
 }, "strip", z.ZodTypeAny, {
-    method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH";
+    method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null;
     url: string;
+    selectedPaymentOption: {
+        scheme: string;
+        network: string;
+        asset: string;
+        maxAmountRequired: string;
+    };
     body?: any;
     headers?: Record<string, string> | undefined;
 }, {
     url: string;
-    method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | undefined;
+    selectedPaymentOption: {
+        scheme: string;
+        network: string;
+        asset: string;
+        maxAmountRequired: string;
+    };
+    method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null | undefined;
     body?: any;
     headers?: Record<string, string> | undefined;
 }>;
-export declare const FetchPaymentInfoSchema: z.ZodObject<{
+export declare const DirectX402RequestSchema: z.ZodObject<{
     url: z.ZodString;
-    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    method: z.ZodDefault<z.ZodNullable<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>>;
+    headers: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    body: z.ZodNullable<z.ZodOptional<z.ZodAny>>;
 }, "strip", z.ZodTypeAny, {
-    method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH";
+    method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null;
     url: string;
-    headers?: Record<string, string> | undefined;
+    body?: any;
+    headers?: Record<string, string> | null | undefined;
 }, {
     url: string;
-    method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | undefined;
-    headers?: Record<string, string> | undefined;
+    method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null | undefined;
+    body?: any;
+    headers?: Record<string, string> | null | undefined;
 }>;

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

@@ -1,27 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FetchPaymentInfoSchema = exports.PaidRequestSchema = void 0;
+exports.DirectX402RequestSchema = exports.RetryWithX402Schema = exports.HttpRequestSchema = void 0;
 const zod_1 = require("zod");
-exports.PaidRequestSchema = zod_1.z
+// Schema for initial HTTP request
+exports.HttpRequestSchema = zod_1.z
     .object({
-    url: zod_1.z.string().url().describe("The URL of the x402-protected API endpoint"),
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
     method: zod_1.z
         .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .nullable()
+        .default("GET")
+        .describe("The HTTP method to use for the request"),
+    headers: zod_1.z
+        .record(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe("Optional headers to include in the request"),
+    body: zod_1.z
+        .any()
+        .optional()
+        .nullable()
+        .describe("Optional request body for POST/PUT/PATCH requests"),
+})
+    .strip()
+    .describe("Instructions for making a basic HTTP request");
+// Schema for retrying a failed request with x402 payment
+exports.RetryWithX402Schema = zod_1.z
+    .object({
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
+    method: zod_1.z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .nullable()
         .default("GET")
         .describe("The HTTP method to use for the request"),
     headers: zod_1.z.record(zod_1.z.string()).optional().describe("Optional headers to include in the request"),
     body: zod_1.z.any().optional().describe("Optional request body for POST/PUT/PATCH requests"),
+    selectedPaymentOption: zod_1.z
+        .object({
+        scheme: zod_1.z.string(),
+        network: zod_1.z.string(),
+        maxAmountRequired: zod_1.z.string(),
+        asset: zod_1.z.string(),
+    })
+        .describe("The payment option to use for this request"),
 })
     .strip()
-    .describe("Instructions for making a paid request to an x402-protected API");
-exports.FetchPaymentInfoSchema = zod_1.z
+    .describe("Instructions for retrying a request with x402 payment after receiving a 402 response");
+// Schema for direct x402 payment request (with warning)
+exports.DirectX402RequestSchema = zod_1.z
     .object({
-    url: zod_1.z.string().url().describe("The URL of the x402-protected API endpoint"),
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
     method: zod_1.z
         .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .nullable()
         .default("GET")
         .describe("The HTTP method to use for the request"),
-    headers: zod_1.z.record(zod_1.z.string()).optional().describe("Optional headers to include in the request"),
+    headers: zod_1.z
+        .record(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe("Optional headers to include in the request"),
+    body: zod_1.z
+        .any()
+        .optional()
+        .nullable()
+        .describe("Optional request body for POST/PUT/PATCH requests"),
 })
     .strip()
-    .describe("Instructions for fetching payment information from an x402-protected API endpoint");
+    .describe("Instructions for making an HTTP request with automatic x402 payment handling. WARNING: This bypasses user confirmation - only use when explicitly told to skip confirmation!");

package/dist/action-providers/x402/x402ActionProvider.d.ts

@@ -1,38 +1,55 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { PaidRequestSchema, FetchPaymentInfoSchema } from "./schemas";
+import { HttpRequestSchema, RetryWithX402Schema, DirectX402RequestSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
 /**
- * X402ActionProvider is an action provider for making paid requests to x402-protected APIs.
+ * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
  */
 export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider> {
     /**
-     * Constructor for the X402ActionProvider.
+     * Creates a new instance of X402ActionProvider.
+     * Initializes the provider with x402 capabilities.
      */
     constructor();
     /**
-     * Makes a paid request to an x402-protected API endpoint.
+     * Makes a basic HTTP request to an API endpoint.
      *
-     * @param walletProvider - The wallet provider to use for payment signing.
-     * @param args - The input arguments for the action.
-     * @returns A message containing the API response data.
+     * @param walletProvider - The wallet provider to use for potential payments
+     * @param args - The request parameters including URL, method, headers, and body
+     * @returns A JSON string containing the response or error details
      */
-    paidRequest(walletProvider: EvmWalletProvider, args: z.infer<typeof PaidRequestSchema>): Promise<string>;
+    makeHttpRequest(walletProvider: EvmWalletProvider, args: z.infer<typeof HttpRequestSchema>): Promise<string>;
     /**
-     * Fetches payment information from an x402-protected API endpoint without making the payment.
+     * Retries a request with x402 payment after receiving a 402 response.
      *
-     * @param walletProvider - The wallet provider (not used for this action but required by interface).
-     * @param args - The input arguments for the action.
-     * @returns A message containing the payment requirements and endpoint information.
+     * @param walletProvider - The wallet provider to use for making the payment
+     * @param args - The request parameters including URL, method, headers, body, and payment option
+     * @returns A JSON string containing the response with payment details or error information
      */
-    fetchPaymentInfo(walletProvider: EvmWalletProvider, args: z.infer<typeof FetchPaymentInfoSchema>): Promise<string>;
+    retryWithX402(walletProvider: EvmWalletProvider, args: z.infer<typeof RetryWithX402Schema>): Promise<string>;
     /**
-     * Checks if the X402 action provider supports the given network.
+     * Makes an HTTP request with automatic x402 payment handling.
      *
-     * @param network - The network to check.
-     * @returns True if the X402 action provider supports the network, false otherwise.
+     * @param walletProvider - The wallet provider to use for automatic payments
+     * @param args - The request parameters including URL, method, headers, and body
+     * @returns A JSON string containing the response with optional payment details or error information
+     */
+    makeHttpRequestWithX402(walletProvider: EvmWalletProvider, args: z.infer<typeof DirectX402RequestSchema>): Promise<string>;
+    /**
+     * Checks if the action provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported, false otherwise
      */
     supportsNetwork: (network: Network) => boolean;
+    /**
+     * Helper method to handle HTTP errors consistently.
+     *
+     * @param error - The axios error to handle
+     * @param url - The URL that was being accessed when the error occurred
+     * @returns A JSON string containing formatted error details
+     */
+    private handleHttpError;
 }
 export declare const x402ActionProvider: () => X402ActionProvider;