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

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/utils.d.ts

@@ -1,6 +1,6 @@
 import { Network } from "../../network";
 import { AxiosError } from "axios";
-import { EvmWalletProvider } from "../../wallet-providers";
+import { WalletProvider } from "../../wallet-providers";
 /**
  * Supported network types for x402 protocol
  */
@@ -35,7 +35,7 @@ export declare function formatPaymentOption(option: {
     asset: string;
     maxAmountRequired: string;
     network: string;
-}, walletProvider: EvmWalletProvider): Promise<string>;
+}, walletProvider: WalletProvider): Promise<string>;
 /**
  * Checks if an asset is USDC on any supported network.
  *
@@ -43,7 +43,7 @@ export declare function formatPaymentOption(option: {
  * @param walletProvider - The wallet provider for network context
  * @returns True if the asset is USDC, false otherwise
  */
-export declare function isUsdcAsset(asset: string, walletProvider: EvmWalletProvider): boolean;
+export declare function isUsdcAsset(asset: string, walletProvider: WalletProvider): boolean;
 /**
  * Converts whole units to atomic units for a given asset.
  *
@@ -52,4 +52,4 @@ export declare function isUsdcAsset(asset: string, walletProvider: EvmWalletProv
  * @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: EvmWalletProvider): Promise<string | null>;
+export declare function convertWholeUnitsToAtomic(wholeUnits: number, asset: string, walletProvider: WalletProvider): Promise<string | null>;

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

@@ -8,6 +8,14 @@ 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.
  *
@@ -75,7 +83,8 @@ async function formatPaymentOption(option, walletProvider) {
     // Check if this is an EVM network and we can use ERC20 helpers
     const walletNetwork = walletProvider.getNetwork();
     const isEvmNetwork = walletNetwork.protocolFamily === "evm";
-    if (isEvmNetwork) {
+    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) {
@@ -99,7 +108,17 @@ async function formatPaymentOption(option, walletProvider) {
             // If we can't get token details, fall back to raw format
         }
     }
-    // Fallback to original format for non-EVM networks or when token details can't be fetched
+    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`;
 }
 /**
@@ -112,13 +131,21 @@ async function formatPaymentOption(option, walletProvider) {
 function isUsdcAsset(asset, walletProvider) {
     const walletNetwork = walletProvider.getNetwork();
     const isEvmNetwork = walletNetwork.protocolFamily === "evm";
-    if (isEvmNetwork) {
+    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;
 }
 /**
@@ -133,7 +160,8 @@ 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";
-    if (isEvmNetwork) {
+    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) {
@@ -155,6 +183,15 @@ async function convertWholeUnitsToAtomic(wholeUnits, asset, walletProvider) {
             // If we can't get token details, fall back to assuming 18 decimals
         }
     }
-    // Fallback to 18 decimals for unknown tokens or non-EVM networks
+    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

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
 import { HttpRequestSchema, RetryWithX402Schema, DirectX402RequestSchema, ListX402ServicesSchema } from "./schemas";
-import { EvmWalletProvider } from "../../wallet-providers";
+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.
@@ -19,7 +19,7 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @param args - Optional filters: maxUsdcPrice
      * @returns JSON string with the list of services (filtered by network and description)
      */
-    discoverX402Services(walletProvider: EvmWalletProvider, args: z.infer<typeof ListX402ServicesSchema>): Promise<string>;
+    discoverX402Services(walletProvider: WalletProvider, args: z.infer<typeof ListX402ServicesSchema>): Promise<string>;
     /**
      * Makes a basic HTTP request to an API endpoint.
      *
@@ -27,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.
      *
@@ -35,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.
      *
@@ -43,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.
      *

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

@@ -40,7 +40,7 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
          * @param network - The network to check support for
          * @returns True if the network is supported, false otherwise
          */
-        this.supportsNetwork = (network) => network.protocolFamily === "evm" && SUPPORTED_NETWORKS.includes(network.networkId);
+        this.supportsNetwork = (network) => SUPPORTED_NETWORKS.includes(network.networkId);
     }
     /**
      * Discovers available x402 services with optional filtering.
@@ -224,8 +224,16 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     details: `Wallet is on ${walletNetwork} but payment requires ${selectedNetwork}`,
                 }, null, 2);
             }
+            // Check if wallet provider is supported
+            if (!(walletProvider instanceof wallet_providers_1.SvmWalletProvider || walletProvider instanceof wallet_providers_1.EvmWalletProvider)) {
+                return JSON.stringify({
+                    error: true,
+                    message: "Unsupported wallet provider",
+                    details: "Only SvmWalletProvider and EvmWalletProvider are supported",
+                }, null, 2);
+            }
             // Make the request with payment handling
-            const account = walletProvider.toSigner();
+            const account = await walletProvider.toSigner();
             const paymentSelector = (accepts) => {
                 const { scheme, network, maxAmountRequired, asset } = args.selectedPaymentOption;
                 let paymentRequirements = accepts.find(accept => accept.scheme === scheme &&
@@ -292,7 +300,14 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
      */
     async makeHttpRequestWithX402(walletProvider, args) {
         try {
-            const account = walletProvider.toSigner();
+            if (!(walletProvider instanceof wallet_providers_1.SvmWalletProvider || walletProvider instanceof wallet_providers_1.EvmWalletProvider)) {
+                return JSON.stringify({
+                    error: true,
+                    message: "Unsupported wallet provider",
+                    details: "Only SvmWalletProvider and EvmWalletProvider are supported",
+                }, null, 2);
+            }
+            const account = await walletProvider.toSigner();
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account);
             const response = await api.request({
@@ -330,11 +345,11 @@ exports.X402ActionProvider = X402ActionProvider;
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "discover_x402_services",
-        description: "Discover available x402 services. Optionally filter by a maximum price in whole units of USDC (only USDC payment options will be considered when filter is applied).",
+        description: "Discover available x402 services. Only services available on the current network will be returned. Optionally filter by a maximum price in whole units of USDC (only USDC payment options will be considered when filter is applied).",
         schema: schemas_1.ListX402ServicesSchema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], X402ActionProvider.prototype, "discoverX402Services", null);
 __decorate([
@@ -353,7 +368,7 @@ If you receive a 402 Payment Required response, use retry_http_request_with_x402
         schema: schemas_1.HttpRequestSchema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], X402ActionProvider.prototype, "makeHttpRequest", null);
 __decorate([
@@ -372,7 +387,7 @@ DO NOT use this action directly without first trying make_http_request!`,
         schema: schemas_1.RetryWithX402Schema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], X402ActionProvider.prototype, "retryWithX402", null);
 __decorate([
@@ -400,7 +415,7 @@ Unless specifically instructed otherwise, prefer the two-step approach with make
         schema: schemas_1.DirectX402RequestSchema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], X402ActionProvider.prototype, "makeHttpRequestWithX402", null);
 const x402ActionProvider = () => new X402ActionProvider();

package/dist/action-providers/x402/x402ActionProvider.test.js

@@ -37,9 +37,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const x402ActionProvider_1 = require("./x402ActionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
 const axios_1 = __importDefault(require("axios"));
 const x402axios = __importStar(require("x402-axios"));
 const x402Verify = __importStar(require("x402/verify"));
+const utils = __importStar(require("./utils"));
 // Mock external facilitator dependency
 jest.mock("@coinbase/x402", () => ({
     facilitator: {},
@@ -48,6 +50,7 @@ jest.mock("@coinbase/x402", () => ({
 jest.mock("axios");
 jest.mock("x402-axios");
 jest.mock("x402/verify");
+jest.mock("./utils");
 // Create mock functions
 const mockRequest = jest.fn();
 // Create a complete mock axios instance
@@ -90,6 +93,10 @@ const mockAxios = {
 const mockWithPaymentInterceptor = jest.fn().mockReturnValue(mockAxiosInstance);
 const mockDecodeXPaymentResponse = jest.fn();
 const mockUseFacilitator = jest.fn();
+const mockIsUsdcAsset = jest.fn();
+const mockConvertWholeUnitsToAtomic = jest.fn();
+const mockFormatPaymentOption = jest.fn();
+const mockGetX402Network = jest.fn();
 // Override the mocked modules
 axios_1.default.create = mockAxios.create;
 axios_1.default.request = mockRequest;
@@ -98,11 +105,25 @@ axios_1.default.isAxiosError = mockAxios.isAxiosError;
 jest.mocked(x402axios.withPaymentInterceptor).mockImplementation(mockWithPaymentInterceptor);
 jest.mocked(x402axios.decodeXPaymentResponse).mockImplementation(mockDecodeXPaymentResponse);
 jest.mocked(x402Verify.useFacilitator).mockImplementation(mockUseFacilitator);
-// Mock wallet provider
-const makeMockWalletProvider = (networkId) => ({
-    toSigner: jest.fn().mockReturnValue("mock-signer"),
-    getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId }),
+// Mock utils functions
+jest.mocked(utils.isUsdcAsset).mockImplementation(mockIsUsdcAsset);
+jest.mocked(utils.convertWholeUnitsToAtomic).mockImplementation(mockConvertWholeUnitsToAtomic);
+jest.mocked(utils.formatPaymentOption).mockImplementation(mockFormatPaymentOption);
+jest.mocked(utils.getX402Network).mockImplementation(mockGetX402Network);
+jest.mocked(utils.handleHttpError).mockImplementation((error, url) => {
+    return JSON.stringify({
+        error: true,
+        message: error instanceof Error ? error.message : "Network error",
+        url: url,
+    });
 });
+// Mock wallet provider
+const makeMockWalletProvider = (networkId) => {
+    const mockProvider = Object.create(wallet_providers_1.EvmWalletProvider.prototype);
+    mockProvider.toSigner = jest.fn().mockReturnValue("mock-signer");
+    mockProvider.getNetwork = jest.fn().mockReturnValue({ protocolFamily: "evm", networkId });
+    return mockProvider;
+};
 // Sample responses based on real examples
 const MOCK_PAYMENT_INFO_RESPONSE = {
     paymentRequired: true,
@@ -150,6 +171,11 @@ describe("X402ActionProvider", () => {
             .mockImplementation((error) => Boolean(error &&
             typeof error === "object" &&
             ("isAxiosError" in error || "response" in error || "request" in error)));
+        // Reset all utility mocks to default behavior
+        mockGetX402Network.mockImplementation(network => network.networkId);
+        mockIsUsdcAsset.mockReturnValue(false);
+        mockConvertWholeUnitsToAtomic.mockResolvedValue("100000");
+        mockFormatPaymentOption.mockResolvedValue("mocked payment option");
     });
     afterEach(() => {
         jest.clearAllMocks();
@@ -167,8 +193,12 @@ describe("X402ActionProvider", () => {
             const network = { protocolFamily: "evm", networkId: "ethereum" };
             expect(provider.supportsNetwork(network)).toBe(false);
         });
-        it("should not support non-EVM networks", () => {
-            const network = { protocolFamily: "solana", networkId: "mainnet" };
+        it("should support SVM networks", () => {
+            const network = { protocolFamily: "svm", networkId: "solana-mainnet" };
+            expect(provider.supportsNetwork(network)).toBe(true);
+        });
+        it("should not support non-EVM/SVM networks", () => {
+            const network = { protocolFamily: "bitcoin", networkId: "mainnet" };
             expect(provider.supportsNetwork(network)).toBe(false);
         });
     });
@@ -190,6 +220,8 @@ describe("X402ActionProvider", () => {
             expect(parsedResult.data).toEqual({ message: "Success" });
         });
         it("should handle 402 responses with payment options", async () => {
+            mockGetX402Network.mockReturnValue("base-sepolia");
+            mockFormatPaymentOption.mockResolvedValue("10000 USDC on base-sepolia network");
             mockRequest.mockResolvedValue({
                 status: 402,
                 data: MOCK_PAYMENT_INFO_RESPONSE.data,
@@ -241,6 +273,7 @@ describe("X402ActionProvider", () => {
                 ],
             });
             mockUseFacilitator.mockReturnValue({ list: mockList });
+            mockGetX402Network.mockReturnValue("base-sepolia");
             const result = await provider.discoverX402Services(makeMockWalletProvider("base-sepolia"), {});
             const parsed = JSON.parse(result);
             expect(parsed.success).toBe(true);
@@ -299,6 +332,14 @@ describe("X402ActionProvider", () => {
                 ],
             });
             mockUseFacilitator.mockReturnValue({ list: mockList });
+            // Mock the utility functions for this test
+            mockGetX402Network.mockReturnValue("base-sepolia");
+            mockIsUsdcAsset.mockReturnValue(true); // All assets are USDC
+            mockConvertWholeUnitsToAtomic
+                .mockResolvedValueOnce("100000") // 0.1 USDC in atomic units
+                .mockResolvedValueOnce("100000")
+                .mockResolvedValueOnce("100000");
+            mockFormatPaymentOption.mockResolvedValue("formatted payment option");
             const result = await provider.discoverX402Services(makeMockWalletProvider("base-sepolia"), {
                 maxUsdcPrice: 0.1,
             });
@@ -319,6 +360,7 @@ describe("X402ActionProvider", () => {
     describe("retryHttpRequestWithX402", () => {
         it("should successfully retry with payment", async () => {
             mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
+            mockGetX402Network.mockReturnValue("base-sepolia");
             mockRequest.mockResolvedValue({
                 status: 200,
                 statusText: "OK",
@@ -353,6 +395,7 @@ describe("X402ActionProvider", () => {
             error.isAxiosError = true;
             error.request = {};
             mockRequest.mockRejectedValue(error);
+            mockGetX402Network.mockReturnValue("base-sepolia");
             const result = await provider.retryWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
@@ -395,6 +438,7 @@ describe("X402ActionProvider", () => {
             });
         });
         it("should handle successful non-payment requests", async () => {
+            mockDecodeXPaymentResponse.mockReturnValue(null); // No payment made
             mockRequest.mockResolvedValue({
                 status: 200,
                 statusText: "OK",

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

@@ -0,0 +1,64 @@
+export declare const YELAY_BACKEND_URL = "https://lite.api.yelay.io/v2";
+export declare const RETAIL_POOL_ID = 10;
+export declare const YELAY_VAULT_ABI: {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+}[];
+export declare const YIELD_EXTRACTOR_ABI: ({
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+})[];
+export declare const CONTRACTS_BY_CHAIN: {
+    readonly 1: {
+        readonly YieldExtractor: "0x226239384EB7d78Cdf279BA6Fb458E2A4945E275";
+    };
+    readonly 146: {
+        readonly YieldExtractor: "0xB84B621D3da3E5e47A1927883C685455Ad731D7C";
+    };
+    readonly 8453: {
+        readonly YieldExtractor: "0x4d6a89dc55d8bacc0cbc3824bd7e44fa051c3958";
+    };
+    readonly 42161: {
+        readonly YieldExtractor: "0x79b7e90F1BAe837362DBD2c83Bd0715c2De5E47f";
+    };
+    readonly 43114: {
+        readonly YieldExtractor: "0x98732e2FEb854bAd400D4b5336f4439E7E53fe88";
+    };
+};