@coinbase/agentkit 0.10.1 → 0.10.3

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

@@ -20,7 +20,10 @@ const schemas_1 = require("./schemas");
 const wallet_providers_1 = require("../../wallet-providers");
 const axios_1 = __importDefault(require("axios"));
 const x402_axios_1 = require("x402-axios");
-const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+const verify_1 = require("x402/verify");
+const x402_1 = require("@coinbase/x402");
+const utils_1 = require("./utils");
+const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia", "solana-mainnet", "solana-devnet"];
 /**
  * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
  */
@@ -37,7 +40,117 @@ 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.
+     *
+     * @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)
+     */
+    async discoverX402Services(walletProvider, args) {
+        try {
+            const { list } = (0, verify_1.useFacilitator)(x402_1.facilitator);
+            const services = await list();
+            if (!services || !services.items) {
+                return JSON.stringify({
+                    error: true,
+                    message: "No services found",
+                });
+            }
+            // Get the current wallet network
+            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
+            // Filter services by network, description, and optional USDC price
+            const hasValidMaxUsdcPrice = typeof args.maxUsdcPrice === "number" &&
+                Number.isFinite(args.maxUsdcPrice) &&
+                args.maxUsdcPrice > 0;
+            const filteredServices = services.items.filter(item => {
+                // Filter by network - only include services that accept the current wallet network
+                const accepts = Array.isArray(item.accepts) ? item.accepts : [];
+                const hasMatchingNetwork = accepts.some(req => req.network === walletNetwork);
+                // Filter out services with empty or default descriptions
+                const hasDescription = accepts.some(req => req.description &&
+                    req.description.trim() !== "" &&
+                    req.description.trim() !== "Access to protected content");
+                return hasMatchingNetwork && hasDescription;
+            });
+            // Apply USDC price filtering if maxUsdcPrice is provided (only consider USDC assets)
+            let priceFilteredServices = filteredServices;
+            if (hasValidMaxUsdcPrice) {
+                priceFilteredServices = [];
+                for (const item of filteredServices) {
+                    const accepts = Array.isArray(item.accepts) ? item.accepts : [];
+                    let shouldInclude = false;
+                    for (const req of accepts) {
+                        if (req.network === walletNetwork && req.asset && req.maxAmountRequired) {
+                            // Only consider USDC assets when maxUsdcPrice filter is applied
+                            if ((0, utils_1.isUsdcAsset)(req.asset, walletProvider)) {
+                                try {
+                                    const maxUsdcPriceAtomic = await (0, utils_1.convertWholeUnitsToAtomic)(args.maxUsdcPrice, req.asset, walletProvider);
+                                    if (maxUsdcPriceAtomic) {
+                                        const requirement = BigInt(req.maxAmountRequired);
+                                        const maxUsdcPriceAtomicBigInt = BigInt(maxUsdcPriceAtomic);
+                                        if (requirement <= maxUsdcPriceAtomicBigInt) {
+                                            shouldInclude = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                                catch {
+                                    // If conversion fails, skip this requirement
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    if (shouldInclude) {
+                        priceFilteredServices.push(item);
+                    }
+                }
+            }
+            // Format the filtered services
+            const filtered = await Promise.all(priceFilteredServices.map(async (item) => {
+                const accepts = Array.isArray(item.accepts) ? item.accepts : [];
+                const matchingAccept = accepts.find(req => req.network === walletNetwork);
+                // Format amount if available
+                let formattedMaxAmount = matchingAccept?.maxAmountRequired;
+                if (matchingAccept?.maxAmountRequired && matchingAccept?.asset) {
+                    formattedMaxAmount = await (0, utils_1.formatPaymentOption)({
+                        asset: matchingAccept.asset,
+                        maxAmountRequired: matchingAccept.maxAmountRequired,
+                        network: matchingAccept.network,
+                    }, walletProvider);
+                }
+                return {
+                    resource: item.resource,
+                    description: matchingAccept?.description || "",
+                    cost: formattedMaxAmount,
+                    ...(matchingAccept?.outputSchema?.input && {
+                        input: matchingAccept.outputSchema.input,
+                    }),
+                    ...(matchingAccept?.outputSchema?.output && {
+                        output: matchingAccept.outputSchema.output,
+                    }),
+                    ...(item.metadata && item.metadata.length > 0 && { metadata: item.metadata }),
+                };
+            }));
+            return JSON.stringify({
+                success: true,
+                walletNetwork,
+                total: services.items.length,
+                returned: filtered.length,
+                items: filtered,
+            }, null, 2);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return JSON.stringify({
+                error: true,
+                message: "Failed to list x402 services",
+                details: message,
+            }, null, 2);
+        }
     }
     /**
      * Makes a basic HTTP request to an API endpoint.
@@ -64,19 +177,32 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     data: response.data,
                 }, null, 2);
             }
+            // Check if wallet network matches any available payment options
+            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
+            const availableNetworks = response.data.accepts.map(option => option.network);
+            const hasMatchingNetwork = availableNetworks.includes(walletNetwork);
+            let paymentOptionsText = `The wallet network ${walletNetwork} does not match any available payment options (${availableNetworks.join(", ")}).`;
+            // Format payment options for matching networks
+            if (hasMatchingNetwork) {
+                const matchingOptions = response.data.accepts.filter(option => option.network === walletNetwork);
+                const formattedOptions = await Promise.all(matchingOptions.map(option => (0, utils_1.formatPaymentOption)(option, walletProvider)));
+                paymentOptionsText = `The payment options are: ${formattedOptions.join(", ")}`;
+            }
             return JSON.stringify({
                 status: "error_402_payment_required",
                 acceptablePaymentOptions: response.data.accepts,
                 nextSteps: [
                     "Inform the user that the requested server replied with a 402 Payment Required response.",
-                    `The payment options are: ${response.data.accepts.map(option => `${option.asset} ${option.maxAmountRequired} ${option.network}`).join(", ")}`,
-                    "Ask the user if they want to retry the request with payment.",
-                    `Use retry_http_request_with_x402 to retry the request with payment.`,
+                    paymentOptionsText,
+                    hasMatchingNetwork ? "Ask the user if they want to retry the request with payment." : "",
+                    hasMatchingNetwork
+                        ? `Use retry_http_request_with_x402 to retry the request with payment.`
+                        : "",
                 ],
             });
         }
         catch (error) {
-            return this.handleHttpError(error, args.url);
+            return (0, utils_1.handleHttpError)(error, args.url);
         }
     }
     /**
@@ -88,8 +214,26 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
      */
     async retryWithX402(walletProvider, args) {
         try {
+            // Check network compatibility before attempting payment
+            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
+            const selectedNetwork = args.selectedPaymentOption.network;
+            if (walletNetwork !== selectedNetwork) {
+                return JSON.stringify({
+                    error: true,
+                    message: "Network mismatch",
+                    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 &&
@@ -108,7 +252,9 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                 }
                 return accepts[0];
             };
-            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account, paymentSelector);
+            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            account, paymentSelector);
             const response = await api.request({
                 url: args.url,
                 method: args.method ?? "GET",
@@ -142,7 +288,7 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
             });
         }
         catch (error) {
-            return this.handleHttpError(error, args.url);
+            return (0, utils_1.handleHttpError)(error, args.url);
         }
     }
     /**
@@ -154,7 +300,15 @@ 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({
                 url: args.url,
@@ -183,42 +337,21 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
             }, null, 2);
         }
         catch (error) {
-            return this.handleHttpError(error, args.url);
+            return (0, utils_1.handleHttpError)(error, args.url);
         }
     }
-    /**
-     * 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
-     */
-    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);
-    }
 }
 exports.X402ActionProvider = X402ActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "discover_x402_services",
+        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.WalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], X402ActionProvider.prototype, "discoverX402Services", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "make_http_request",
@@ -235,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([
@@ -254,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([
@@ -272,6 +405,7 @@ This action combines both steps into one, which means:
 - No chance to review payment details before paying
 - No confirmation step
 - Automatic payment processing
+- Assumes payment option is compatible with wallet network
 
 EXAMPLES:
 - Production: make_http_request_with_x402("https://api.example.com/data")
@@ -281,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,11 +37,20 @@ 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: {},
+}));
 // Mock modules
 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
@@ -83,6 +92,11 @@ 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;
@@ -90,9 +104,25 @@ axios_1.default.isAxiosError = mockAxios.isAxiosError;
 // Mock x402-axios functions
 jest.mocked(x402axios.withPaymentInterceptor).mockImplementation(mockWithPaymentInterceptor);
 jest.mocked(x402axios.decodeXPaymentResponse).mockImplementation(mockDecodeXPaymentResponse);
+jest.mocked(x402Verify.useFacilitator).mockImplementation(mockUseFacilitator);
+// 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 mockWalletProvider = {
-    toSigner: jest.fn().mockReturnValue("mock-signer"),
+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 = {
@@ -141,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();
@@ -158,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);
         });
     });
@@ -171,7 +210,7 @@ describe("X402ActionProvider", () => {
                 headers: {},
                 config: {},
             });
-            const result = await provider.makeHttpRequest(mockWalletProvider, {
+            const result = await provider.makeHttpRequest(makeMockWalletProvider("base-sepolia"), {
                 url: "https://api.example.com/free",
                 method: "GET",
             });
@@ -181,13 +220,15 @@ 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,
                 headers: {},
                 config: {},
             });
-            const result = await provider.makeHttpRequest(mockWalletProvider, {
+            const result = await provider.makeHttpRequest(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
             });
@@ -201,7 +242,7 @@ describe("X402ActionProvider", () => {
             error.isAxiosError = true;
             error.request = {};
             mockRequest.mockRejectedValue(error);
-            const result = await provider.makeHttpRequest(mockWalletProvider, {
+            const result = await provider.makeHttpRequest(makeMockWalletProvider("base-sepolia"), {
                 url: "https://api.example.com/endpoint",
                 method: "GET",
             });
@@ -210,9 +251,116 @@ describe("X402ActionProvider", () => {
             expect(parsedResult.message).toContain("Network error");
         });
     });
+    describe("listX402Services", () => {
+        it("should list services without filters", async () => {
+            const mockList = jest.fn().mockResolvedValue({
+                items: [
+                    {
+                        resource: "https://example.com/service1",
+                        metadata: { category: "test" },
+                        accepts: [
+                            {
+                                asset: "0xUSDC",
+                                maxAmountRequired: "90000",
+                                network: "base-sepolia",
+                                scheme: "exact",
+                                description: "Test service 1",
+                                outputSchema: { type: "object" },
+                                extra: { name: "USDC" },
+                            },
+                        ],
+                    },
+                ],
+            });
+            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);
+            expect(parsed.total).toBe(1);
+            expect(parsed.returned).toBe(1);
+            expect(parsed.items.length).toBe(1);
+        });
+        it("should filter services by asset and maxPrice", async () => {
+            const mockList = jest.fn().mockResolvedValue({
+                items: [
+                    {
+                        resource: "https://example.com/service1",
+                        metadata: { category: "test" },
+                        accepts: [
+                            {
+                                asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e", // Real USDC address for base-sepolia
+                                maxAmountRequired: "90000", // 0.09 USDC (should pass 0.1 filter)
+                                network: "base-sepolia",
+                                scheme: "exact",
+                                description: "Test service 1",
+                                outputSchema: { type: "object" },
+                                extra: { name: "USDC" },
+                            },
+                        ],
+                    },
+                    {
+                        resource: "https://example.com/service2",
+                        metadata: { category: "test" },
+                        accepts: [
+                            {
+                                asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e", // Real USDC address for base-sepolia
+                                maxAmountRequired: "150000", // 0.15 USDC (should fail 0.1 filter)
+                                network: "base-sepolia",
+                                scheme: "exact",
+                                description: "Test service 2",
+                                outputSchema: { type: "object" },
+                                extra: { name: "USDC" },
+                            },
+                        ],
+                    },
+                    {
+                        resource: "https://example.com/service3",
+                        metadata: { category: "test" },
+                        accepts: [
+                            {
+                                asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e", // Real USDC address for base-sepolia
+                                maxAmountRequired: "50000", // 0.05 USDC (should pass 0.1 filter)
+                                network: "base-sepolia",
+                                scheme: "exact",
+                                description: "Test service 3",
+                                outputSchema: { type: "object" },
+                                extra: { name: "USDC" },
+                            },
+                        ],
+                    },
+                ],
+            });
+            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,
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.returned).toBe(2);
+            expect(parsed.items.map(item => item.resource)).toEqual(expect.arrayContaining(["https://example.com/service1", "https://example.com/service3"]));
+        });
+        it("should handle errors from facilitator", async () => {
+            const mockList = jest.fn().mockRejectedValue(new Error("boom"));
+            mockUseFacilitator.mockReturnValue({ list: mockList });
+            const result = await provider.discoverX402Services(makeMockWalletProvider("base-sepolia"), {});
+            const parsed = JSON.parse(result);
+            expect(parsed.error).toBe(true);
+            expect(parsed.message).toContain("Failed to list x402 services");
+        });
+    });
     describe("retryHttpRequestWithX402", () => {
         it("should successfully retry with payment", async () => {
             mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
+            mockGetX402Network.mockReturnValue("base-sepolia");
             mockRequest.mockResolvedValue({
                 status: 200,
                 statusText: "OK",
@@ -222,7 +370,7 @@ describe("X402ActionProvider", () => {
                 },
                 config: {},
             });
-            const result = await provider.retryWithX402(mockWalletProvider, {
+            const result = await provider.retryWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
                 selectedPaymentOption: {
@@ -247,7 +395,8 @@ describe("X402ActionProvider", () => {
             error.isAxiosError = true;
             error.request = {};
             mockRequest.mockRejectedValue(error);
-            const result = await provider.retryWithX402(mockWalletProvider, {
+            mockGetX402Network.mockReturnValue("base-sepolia");
+            const result = await provider.retryWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
                 selectedPaymentOption: {
@@ -274,7 +423,7 @@ describe("X402ActionProvider", () => {
                 },
                 config: {},
             });
-            const result = await provider.makeHttpRequestWithX402(mockWalletProvider, {
+            const result = await provider.makeHttpRequestWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
             });
@@ -289,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",
@@ -296,7 +446,7 @@ describe("X402ActionProvider", () => {
                 headers: {},
                 config: {},
             });
-            const result = await provider.makeHttpRequestWithX402(mockWalletProvider, {
+            const result = await provider.makeHttpRequestWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://api.example.com/free",
                 method: "GET",
             });
@@ -310,7 +460,7 @@ describe("X402ActionProvider", () => {
             error.isAxiosError = true;
             error.request = {};
             mockRequest.mockRejectedValue(error);
-            const result = await provider.makeHttpRequestWithX402(mockWalletProvider, {
+            const result = await provider.makeHttpRequestWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://api.example.com/endpoint",
                 method: "GET",
             });

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";
+    };
+};