@coinbase/agentkit 0.10.1 → 0.10.3

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

@@ -42,6 +42,11 @@ describe("Wrap Eth Action", () => {
     beforeEach(async () => {
         mockWallet = {
             getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            }),
+            getBalance: jest.fn().mockResolvedValue((0, viem_1.parseUnits)("20", 18)), // 20 ETH balance
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
         };
@@ -54,14 +59,14 @@ describe("Wrap Eth Action", () => {
         mockWallet.sendTransaction.mockResolvedValue(hash);
         const response = await actionProvider.wrapEth(mockWallet, args);
         expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: constants_1.WETH_ADDRESS,
+            to: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
             data: (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WETH_ABI,
                 functionName: "deposit",
             }),
-            value: BigInt(MOCK_AMOUNT),
+            value: (0, viem_1.parseUnits)(MOCK_AMOUNT, 18),
         });
-        expect(response).toContain(`Wrapped ETH with transaction hash: ${hash}`);
+        expect(response).toContain(`Wrapped ${MOCK_AMOUNT} ETH to WETH. Transaction hash: ${hash}`);
     });
     it("should fail with an error", async () => {
         const args = {
@@ -71,15 +76,25 @@ describe("Wrap Eth Action", () => {
         mockWallet.sendTransaction.mockRejectedValue(error);
         const response = await actionProvider.wrapEth(mockWallet, args);
         expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: constants_1.WETH_ADDRESS,
+            to: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
             data: (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WETH_ABI,
                 functionName: "deposit",
             }),
-            value: BigInt(MOCK_AMOUNT),
+            value: (0, viem_1.parseUnits)(MOCK_AMOUNT, 18),
         });
         expect(response).toContain(`Error wrapping ETH: ${error}`);
     });
+    it("should fail with insufficient ETH balance", async () => {
+        const args = {
+            amountToWrap: MOCK_AMOUNT,
+        };
+        // Mock insufficient balance (less than 15 ETH)
+        mockWallet.getBalance.mockResolvedValue((0, viem_1.parseUnits)("10", 18));
+        const response = await actionProvider.wrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).not.toHaveBeenCalled();
+        expect(response).toContain("Error: Insufficient ETH balance");
+    });
 });
 describe("Unwrap Eth Action", () => {
     let mockWallet;
@@ -87,6 +102,11 @@ describe("Unwrap Eth Action", () => {
     beforeEach(async () => {
         mockWallet = {
             getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            }),
+            readContract: jest.fn().mockResolvedValue((0, viem_1.parseUnits)("20", 18)), // 20 WETH balance
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
         };
@@ -98,15 +118,21 @@ describe("Unwrap Eth Action", () => {
         const hash = "0x1234567890123456789012345678901234567890";
         mockWallet.sendTransaction.mockResolvedValue(hash);
         const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.readContract).toHaveBeenCalledWith({
+            address: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
+            abi: viem_1.erc20Abi,
+            functionName: "balanceOf",
+            args: [MOCK_ADDRESS],
+        });
         expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: constants_1.WETH_ADDRESS,
+            to: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
             data: (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WETH_ABI,
                 functionName: "withdraw",
-                args: [BigInt(MOCK_AMOUNT)],
+                args: [(0, viem_1.parseUnits)(MOCK_AMOUNT, 18)],
             }),
         });
-        expect(response).toContain(`Unwrapped WETH with transaction hash: ${hash}`);
+        expect(response).toContain(`Unwrapped ${MOCK_AMOUNT} WETH to ETH. Transaction hash: ${hash}`);
     });
     it("should fail with an error", async () => {
         const args = {
@@ -115,16 +141,32 @@ describe("Unwrap Eth Action", () => {
         const error = new Error("Failed to unwrap WETH");
         mockWallet.sendTransaction.mockRejectedValue(error);
         const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.readContract).toHaveBeenCalledWith({
+            address: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
+            abi: viem_1.erc20Abi,
+            functionName: "balanceOf",
+            args: [MOCK_ADDRESS],
+        });
         expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
-            to: constants_1.WETH_ADDRESS,
+            to: (0, wethActionProvider_1.getWethAddress)({ protocolFamily: "evm", networkId: "base-mainnet" }),
             data: (0, viem_1.encodeFunctionData)({
                 abi: constants_1.WETH_ABI,
                 functionName: "withdraw",
-                args: [BigInt(MOCK_AMOUNT)],
+                args: [(0, viem_1.parseUnits)(MOCK_AMOUNT, 18)],
             }),
         });
         expect(response).toContain(`Error unwrapping WETH: ${error}`);
     });
+    it("should fail with insufficient WETH balance", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        // Mock insufficient WETH balance (less than 15 WETH)
+        mockWallet.readContract.mockResolvedValue((0, viem_1.parseUnits)("10", 18));
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).not.toHaveBeenCalled();
+        expect(response).toContain("Error: Insufficient WETH balance");
+    });
 });
 describe("supportsNetwork", () => {
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
@@ -142,11 +184,18 @@ describe("supportsNetwork", () => {
         });
         expect(result).toBe(true);
     });
-    it("should return false for non-base networks", () => {
+    it("should return true for ethereum-mainnet", () => {
         const result = actionProvider.supportsNetwork({
             protocolFamily: "evm",
             networkId: "ethereum-mainnet",
         });
+        expect(result).toBe(true);
+    });
+    it("should return false for networks without WETH", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            networkId: "polygon-mainnet",
+        });
         expect(result).toBe(false);
     });
 });

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

@@ -1,4 +1,11 @@
 import { z } from "zod";
+export declare const ListX402ServicesSchema: z.ZodObject<{
+    maxUsdcPrice: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxUsdcPrice?: number | undefined;
+}, {
+    maxUsdcPrice?: number | undefined;
+}>;
 export declare const HttpRequestSchema: z.ZodObject<{
     url: z.ZodString;
     method: z.ZodDefault<z.ZodNullable<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>>;

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

@@ -1,7 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DirectX402RequestSchema = exports.RetryWithX402Schema = exports.HttpRequestSchema = void 0;
+exports.DirectX402RequestSchema = exports.RetryWithX402Schema = exports.HttpRequestSchema = exports.ListX402ServicesSchema = void 0;
 const zod_1 = require("zod");
+// Schema for listing x402 services
+exports.ListX402ServicesSchema = zod_1.z
+    .object({
+    maxUsdcPrice: zod_1.z
+        .number()
+        .optional()
+        .describe("Optional maximum price in USDC whole units (e.g., 0.1 for 0.10 USDC). Only USDC payment options will be considered when this filter is applied."),
+})
+    .strip()
+    .describe("Parameters for listing x402 services with optional filtering");
 // Schema for initial HTTP request
 exports.HttpRequestSchema = zod_1.z
     .object({

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

@@ -0,0 +1,55 @@
+import { Network } from "../../network";
+import { AxiosError } from "axios";
+import { WalletProvider } from "../../wallet-providers";
+/**
+ * Supported network types for x402 protocol
+ */
+export type X402Network = "base" | "base-sepolia" | "solana" | "solana-devnet";
+/**
+ * Converts the internal network ID to the format expected by the x402 protocol.
+ *
+ * @param network - The network to convert
+ * @returns The network ID in x402 format
+ * @throws Error if the network is not supported
+ */
+export declare function getX402Network(network: Network): X402Network | string | undefined;
+/**
+ * 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
+ */
+export declare function handleHttpError(error: AxiosError, url: string): string;
+/**
+ * Formats a payment option into a human-readable string.
+ *
+ * @param option - The payment option to format
+ * @param option.asset - The asset address or identifier
+ * @param option.maxAmountRequired - The maximum amount required for the payment
+ * @param option.network - The network identifier
+ * @param walletProvider - The wallet provider for token details lookup
+ * @returns A formatted string like "0.1 USDC on base"
+ */
+export declare function formatPaymentOption(option: {
+    asset: string;
+    maxAmountRequired: string;
+    network: string;
+}, walletProvider: WalletProvider): Promise<string>;
+/**
+ * Checks if an asset is USDC on any supported network.
+ *
+ * @param asset - The asset address or identifier
+ * @param walletProvider - The wallet provider for network context
+ * @returns True if the asset is USDC, false otherwise
+ */
+export declare function isUsdcAsset(asset: string, walletProvider: WalletProvider): boolean;
+/**
+ * Converts whole units to atomic units for a given asset.
+ *
+ * @param wholeUnits - The amount in whole units (e.g., 0.1 for 0.1 USDC)
+ * @param asset - The asset address or identifier
+ * @param walletProvider - The wallet provider for token details lookup
+ * @returns The amount in atomic units as a string, or null if conversion fails
+ */
+export declare function convertWholeUnitsToAtomic(wholeUnits: number, asset: string, walletProvider: WalletProvider): Promise<string | null>;

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

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getX402Network = getX402Network;
+exports.handleHttpError = handleHttpError;
+exports.formatPaymentOption = formatPaymentOption;
+exports.isUsdcAsset = isUsdcAsset;
+exports.convertWholeUnitsToAtomic = convertWholeUnitsToAtomic;
+const utils_1 = require("../erc20/utils");
+const constants_1 = require("../erc20/constants");
+const viem_1 = require("viem");
+const wallet_providers_1 = require("../../wallet-providers");
+/**
+ * USDC token addresses for Solana networks
+ */
+const SOLANA_USDC_ADDRESSES = {
+    "solana-devnet": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+    "solana-mainnet": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+};
+/**
+ * Converts the internal network ID to the format expected by the x402 protocol.
+ *
+ * @param network - The network to convert
+ * @returns The network ID in x402 format
+ * @throws Error if the network is not supported
+ */
+function getX402Network(network) {
+    switch (network.networkId) {
+        case "base-mainnet":
+            return "base";
+        case "base-sepolia":
+            return "base-sepolia";
+        case "solana-mainnet":
+            return "solana";
+        case "solana-devnet":
+            return "solana-devnet";
+        default:
+            return network.networkId;
+    }
+}
+/**
+ * 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
+ */
+function handleHttpError(error, url) {
+    if (error.response) {
+        return JSON.stringify({
+            error: true,
+            message: `HTTP ${error.response.status} error when accessing ${url}`,
+            details: error.response.data?.error || error.response.statusText,
+            suggestion: "Check if the URL is correct and the API is available.",
+        }, null, 2);
+    }
+    if (error.request) {
+        return JSON.stringify({
+            error: true,
+            message: `Network error when accessing ${url}`,
+            details: error.message,
+            suggestion: "Check your internet connection and verify the API endpoint is accessible.",
+        }, null, 2);
+    }
+    return JSON.stringify({
+        error: true,
+        message: `Error making request to ${url}`,
+        details: error.message,
+        suggestion: "Please check the request parameters and try again.",
+    }, null, 2);
+}
+/**
+ * Formats a payment option into a human-readable string.
+ *
+ * @param option - The payment option to format
+ * @param option.asset - The asset address or identifier
+ * @param option.maxAmountRequired - The maximum amount required for the payment
+ * @param option.network - The network identifier
+ * @param walletProvider - The wallet provider for token details lookup
+ * @returns A formatted string like "0.1 USDC on base"
+ */
+async function formatPaymentOption(option, walletProvider) {
+    const { asset, maxAmountRequired, network } = option;
+    // Check if this is an EVM network and we can use ERC20 helpers
+    const walletNetwork = walletProvider.getNetwork();
+    const isEvmNetwork = walletNetwork.protocolFamily === "evm";
+    const isSvmNetwork = walletNetwork.protocolFamily === "svm";
+    if (isEvmNetwork && walletProvider instanceof wallet_providers_1.EvmWalletProvider) {
+        const networkId = walletNetwork.networkId;
+        const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
+        if (tokenSymbols) {
+            for (const [symbol, address] of Object.entries(tokenSymbols)) {
+                if (asset.toLowerCase() === address.toLowerCase()) {
+                    const decimals = symbol === "USDC" || symbol === "EURC" ? 6 : 18;
+                    const formattedAmount = (0, viem_1.formatUnits)(BigInt(maxAmountRequired), decimals);
+                    return `${formattedAmount} ${symbol} on ${network} network`;
+                }
+            }
+        }
+        // Fall back to getTokenDetails for unknown tokens
+        try {
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, asset);
+            if (tokenDetails) {
+                const formattedAmount = (0, viem_1.formatUnits)(BigInt(maxAmountRequired), tokenDetails.decimals);
+                return `${formattedAmount} ${tokenDetails.name} on ${network} network`;
+            }
+        }
+        catch {
+            // If we can't get token details, fall back to raw format
+        }
+    }
+    if (isSvmNetwork && walletProvider instanceof wallet_providers_1.SvmWalletProvider) {
+        // Check if the asset is USDC on Solana networks
+        const networkId = walletNetwork.networkId;
+        const usdcAddress = SOLANA_USDC_ADDRESSES[networkId];
+        if (usdcAddress && asset === usdcAddress) {
+            // USDC has 6 decimals on Solana
+            const formattedAmount = (0, viem_1.formatUnits)(BigInt(maxAmountRequired), 6);
+            return `${formattedAmount} USDC on ${network} network`;
+        }
+    }
+    // Fallback to original format for non-EVM/SVM networks or when token details can't be fetched
+    return `${asset} ${maxAmountRequired} on ${network} network`;
+}
+/**
+ * Checks if an asset is USDC on any supported network.
+ *
+ * @param asset - The asset address or identifier
+ * @param walletProvider - The wallet provider for network context
+ * @returns True if the asset is USDC, false otherwise
+ */
+function isUsdcAsset(asset, walletProvider) {
+    const walletNetwork = walletProvider.getNetwork();
+    const isEvmNetwork = walletNetwork.protocolFamily === "evm";
+    const isSvmNetwork = walletNetwork.protocolFamily === "svm";
+    if (isEvmNetwork && walletProvider instanceof wallet_providers_1.EvmWalletProvider) {
+        const networkId = walletNetwork.networkId;
+        const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
+        if (tokenSymbols && tokenSymbols.USDC) {
+            return asset.toLowerCase() === tokenSymbols.USDC.toLowerCase();
+        }
+    }
+    if (isSvmNetwork && walletProvider instanceof wallet_providers_1.SvmWalletProvider) {
+        const networkId = walletNetwork.networkId;
+        const usdcAddress = SOLANA_USDC_ADDRESSES[networkId];
+        if (usdcAddress) {
+            return asset === usdcAddress;
+        }
+    }
+    return false;
+}
+/**
+ * Converts whole units to atomic units for a given asset.
+ *
+ * @param wholeUnits - The amount in whole units (e.g., 0.1 for 0.1 USDC)
+ * @param asset - The asset address or identifier
+ * @param walletProvider - The wallet provider for token details lookup
+ * @returns The amount in atomic units as a string, or null if conversion fails
+ */
+async function convertWholeUnitsToAtomic(wholeUnits, asset, walletProvider) {
+    // Check if this is an EVM network and we can use ERC20 helpers
+    const walletNetwork = walletProvider.getNetwork();
+    const isEvmNetwork = walletNetwork.protocolFamily === "evm";
+    const isSvmNetwork = walletNetwork.protocolFamily === "svm";
+    if (isEvmNetwork && walletProvider instanceof wallet_providers_1.EvmWalletProvider) {
+        const networkId = walletNetwork.networkId;
+        const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
+        if (tokenSymbols) {
+            for (const [symbol, address] of Object.entries(tokenSymbols)) {
+                if (asset.toLowerCase() === address.toLowerCase()) {
+                    const decimals = symbol === "USDC" || symbol === "EURC" ? 6 : 18;
+                    return (0, viem_1.parseUnits)(wholeUnits.toString(), decimals).toString();
+                }
+            }
+        }
+        // Fall back to getTokenDetails for unknown tokens
+        try {
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, asset);
+            if (tokenDetails) {
+                return (0, viem_1.parseUnits)(wholeUnits.toString(), tokenDetails.decimals).toString();
+            }
+        }
+        catch {
+            // If we can't get token details, fall back to assuming 18 decimals
+        }
+    }
+    if (isSvmNetwork && walletProvider instanceof wallet_providers_1.SvmWalletProvider) {
+        // Check if the asset is USDC on Solana networks
+        const networkId = walletNetwork.networkId;
+        const usdcAddress = SOLANA_USDC_ADDRESSES[networkId];
+        if (usdcAddress && asset === usdcAddress) {
+            // USDC has 6 decimals on Solana
+            return (0, viem_1.parseUnits)(wholeUnits.toString(), 6).toString();
+        }
+    }
+    // Fallback to 18 decimals for unknown tokens or non-EVM/SVM networks
+    return (0, viem_1.parseUnits)(wholeUnits.toString(), 18).toString();
+}

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

@@ -1,17 +1,25 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { HttpRequestSchema, RetryWithX402Schema, DirectX402RequestSchema } from "./schemas";
-import { EvmWalletProvider } from "../../wallet-providers";
+import { HttpRequestSchema, RetryWithX402Schema, DirectX402RequestSchema, ListX402ServicesSchema } from "./schemas";
+import { WalletProvider } from "../../wallet-providers";
 /**
  * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
  */
-export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider> {
+export declare class X402ActionProvider extends ActionProvider<WalletProvider> {
     /**
      * Creates a new instance of X402ActionProvider.
      * Initializes the provider with x402 capabilities.
      */
     constructor();
+    /**
+     * Discovers available x402 services with optional filtering.
+     *
+     * @param walletProvider - The wallet provider to use for network filtering
+     * @param args - Optional filters: maxUsdcPrice
+     * @returns JSON string with the list of services (filtered by network and description)
+     */
+    discoverX402Services(walletProvider: WalletProvider, args: z.infer<typeof ListX402ServicesSchema>): Promise<string>;
     /**
      * Makes a basic HTTP request to an API endpoint.
      *
@@ -19,7 +27,7 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @param args - The request parameters including URL, method, headers, and body
      * @returns A JSON string containing the response or error details
      */
-    makeHttpRequest(walletProvider: EvmWalletProvider, args: z.infer<typeof HttpRequestSchema>): Promise<string>;
+    makeHttpRequest(walletProvider: WalletProvider, args: z.infer<typeof HttpRequestSchema>): Promise<string>;
     /**
      * Retries a request with x402 payment after receiving a 402 response.
      *
@@ -27,7 +35,7 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @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
      */
-    retryWithX402(walletProvider: EvmWalletProvider, args: z.infer<typeof RetryWithX402Schema>): Promise<string>;
+    retryWithX402(walletProvider: WalletProvider, args: z.infer<typeof RetryWithX402Schema>): Promise<string>;
     /**
      * Makes an HTTP request with automatic x402 payment handling.
      *
@@ -35,7 +43,7 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @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>;
+    makeHttpRequestWithX402(walletProvider: WalletProvider, args: z.infer<typeof DirectX402RequestSchema>): Promise<string>;
     /**
      * Checks if the action provider supports the given network.
      *
@@ -43,13 +51,5 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @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;