@coinbase/agentkit 0.10.2 → 0.10.4

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

@@ -32,124 +32,133 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const x402ActionProvider_1 = require("./x402ActionProvider");
-const axios_1 = __importDefault(require("axios"));
-const x402axios = __importStar(require("x402-axios"));
-const x402Verify = __importStar(require("x402/verify"));
-// Mock external facilitator dependency
-jest.mock("@coinbase/x402", () => ({
-    facilitator: {},
+const wallet_providers_1 = require("../../wallet-providers");
+const fetch_1 = require("@x402/fetch");
+const client_1 = require("@x402/evm/exact/client");
+const client_2 = require("@x402/svm/exact/client");
+const utils = __importStar(require("./utils"));
+const schemas_1 = require("./schemas");
+// Mock external modules
+jest.mock("@x402/fetch");
+jest.mock("@x402/evm/exact/client");
+jest.mock("@x402/svm/exact/client");
+jest.mock("./utils");
+jest.mock("./schemas", () => ({
+    ...jest.requireActual("./schemas"),
+    resolveFacilitatorUrl: jest.fn(),
 }));
-// Mock modules
-jest.mock("axios");
-jest.mock("x402-axios");
-jest.mock("x402/verify");
 // Create mock functions
-const mockRequest = jest.fn();
-// Create a complete mock axios instance
-const mockAxiosInstance = {
-    request: mockRequest,
-    get: jest.fn(),
-    delete: jest.fn(),
-    head: jest.fn(),
-    options: jest.fn(),
-    post: jest.fn(),
-    put: jest.fn(),
-    patch: jest.fn(),
-    getUri: jest.fn(),
-    defaults: {},
-    interceptors: {
-        request: { use: jest.fn(), eject: jest.fn(), clear: jest.fn() },
-        response: { use: jest.fn(), eject: jest.fn(), clear: jest.fn() },
-    },
-};
-// Create a complete mock axios static
-const mockAxios = {
-    create: jest.fn().mockReturnValue(mockAxiosInstance),
-    request: mockRequest,
-    get: jest.fn(),
-    delete: jest.fn(),
-    head: jest.fn(),
-    options: jest.fn(),
-    post: jest.fn(),
-    put: jest.fn(),
-    patch: jest.fn(),
-    all: jest.fn(),
-    spread: jest.fn(),
-    isAxiosError: jest.fn(),
-    isCancel: jest.fn(),
-    CancelToken: {
-        source: jest.fn(),
-    },
-    VERSION: "1.x",
+const mockFetch = jest.fn();
+const mockFetchWithPayment = jest.fn();
+// Mock x402 client
+const mockX402Client = {
+    registerScheme: jest.fn(),
 };
-const mockWithPaymentInterceptor = jest.fn().mockReturnValue(mockAxiosInstance);
-const mockDecodeXPaymentResponse = jest.fn();
-const mockUseFacilitator = jest.fn();
-// Override the mocked modules
-axios_1.default.create = mockAxios.create;
-axios_1.default.request = mockRequest;
-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
+const mockGetX402Networks = jest.fn();
+const mockHandleHttpError = jest.fn();
+const mockFormatPaymentOption = jest.fn();
+const mockFetchAllDiscoveryResources = jest.fn();
+const mockFilterByNetwork = jest.fn();
+const mockFilterByDescription = jest.fn();
+const mockFilterByX402Version = jest.fn();
+const mockFilterByKeyword = jest.fn();
+const mockFilterByMaxPrice = jest.fn();
+const mockFormatSimplifiedResources = jest.fn();
+const mockBuildUrlWithParams = jest.fn();
+const mockResolveFacilitatorUrl = jest.fn();
+// Setup mocks
+jest
+    .mocked(fetch_1.x402Client)
+    .mockImplementation(() => mockX402Client);
+jest.mocked(fetch_1.wrapFetchWithPayment).mockReturnValue(mockFetchWithPayment);
+jest
+    .mocked(client_1.registerExactEvmScheme)
+    .mockImplementation(() => mockX402Client);
+jest
+    .mocked(client_2.registerExactSvmScheme)
+    .mockImplementation(() => mockX402Client);
+jest.mocked(utils.getX402Networks).mockImplementation(mockGetX402Networks);
+jest.mocked(utils.handleHttpError).mockImplementation(mockHandleHttpError);
+jest.mocked(utils.formatPaymentOption).mockImplementation(mockFormatPaymentOption);
+jest.mocked(utils.fetchAllDiscoveryResources).mockImplementation(mockFetchAllDiscoveryResources);
+jest.mocked(utils.filterByNetwork).mockImplementation(mockFilterByNetwork);
+jest.mocked(utils.filterByDescription).mockImplementation(mockFilterByDescription);
+jest.mocked(utils.filterByX402Version).mockImplementation(mockFilterByX402Version);
+jest.mocked(utils.filterByKeyword).mockImplementation(mockFilterByKeyword);
+jest.mocked(utils.filterByMaxPrice).mockImplementation(mockFilterByMaxPrice);
+jest.mocked(utils.formatSimplifiedResources).mockImplementation(mockFormatSimplifiedResources);
+jest.mocked(utils.buildUrlWithParams).mockImplementation(mockBuildUrlWithParams);
+jest.mocked(schemas_1.resolveFacilitatorUrl).mockImplementation(mockResolveFacilitatorUrl);
+// Mock global fetch
+global.fetch = mockFetch;
 // Mock wallet provider
-const makeMockWalletProvider = (networkId) => ({
-    toSigner: jest.fn().mockReturnValue("mock-signer"),
-    getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId }),
-});
+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,
-    url: "https://www.x402.org/protected",
-    status: 402,
-    data: {
-        x402Version: 1,
-        error: "X-PAYMENT header is required",
-        accepts: [
-            {
-                scheme: "exact",
-                network: "base-sepolia",
-                maxAmountRequired: "10000",
-                resource: "https://www.x402.org/protected",
-                description: "Access to protected content",
-                mimeType: "application/json",
-                payTo: "0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
-                maxTimeoutSeconds: 300,
-                asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-                extra: {
-                    name: "USDC",
-                    version: "2",
-                },
+    x402Version: 1,
+    error: "X-PAYMENT header is required",
+    accepts: [
+        {
+            scheme: "exact",
+            network: "base-sepolia",
+            maxAmountRequired: "10000",
+            resource: "https://www.x402.org/protected",
+            description: "Access to protected content",
+            mimeType: "application/json",
+            payTo: "0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
+            maxTimeoutSeconds: 300,
+            asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+            extra: {
+                name: "USDC",
+                version: "2",
             },
-        ],
-    },
+        },
+    ],
 };
-const MOCK_PAYMENT_RESPONSE = {
-    success: true,
+const MOCK_PAYMENT_PROOF = {
     transaction: "0xcbc385789d3744b52af5106c32809534f64adcbe097e050ec03d6b53fed5d305",
     network: "base-sepolia",
     payer: "0xa8c1a5D3C372C65c04f91f87a43F549619A9483f",
 };
+// Helper to create mock Response
+const createMockResponse = (options) => {
+    const headersMap = new Map(Object.entries(options.headers ?? {}));
+    return {
+        status: options.status,
+        statusText: options.statusText ?? "OK",
+        ok: options.status >= 200 && options.status < 300,
+        headers: {
+            get: (name) => headersMap.get(name.toLowerCase()) ?? null,
+        },
+        json: jest.fn().mockResolvedValue(options.data),
+        text: jest.fn().mockResolvedValue(JSON.stringify(options.data)),
+    };
+};
 describe("X402ActionProvider", () => {
     let provider;
     beforeEach(() => {
         provider = new x402ActionProvider_1.X402ActionProvider();
         jest.clearAllMocks();
-        // Setup mocks
-        mockAxios.create.mockReturnValue(mockAxiosInstance);
-        mockWithPaymentInterceptor.mockReturnValue(mockAxiosInstance);
-        // Setup axios.isAxiosError mock
-        jest
-            .mocked(axios_1.default.isAxiosError)
-            .mockImplementation((error) => Boolean(error &&
-            typeof error === "object" &&
-            ("isAxiosError" in error || "response" in error || "request" in error)));
+        // Setup default mock behaviors
+        mockGetX402Networks.mockImplementation(network => [network.networkId]);
+        mockBuildUrlWithParams.mockImplementation(url => url);
+        mockHandleHttpError.mockImplementation((error, url) => {
+            return JSON.stringify({
+                error: true,
+                message: error instanceof Error ? error.message : "Network error",
+                url: url,
+            });
+        });
+        mockFormatPaymentOption.mockResolvedValue("mocked payment option");
+        mockResolveFacilitatorUrl.mockReturnValue("https://api.cdp.coinbase.com/platform/v2/x402");
     });
     afterEach(() => {
         jest.clearAllMocks();
@@ -167,19 +176,22 @@ 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);
         });
     });
     describe("makeHttpRequest", () => {
         it("should handle successful non-payment requests", async () => {
-            mockRequest.mockResolvedValue({
+            mockFetch.mockResolvedValue(createMockResponse({
                 status: 200,
                 data: { message: "Success" },
-                headers: {},
-                config: {},
-            });
+                headers: { "content-type": "application/json" },
+            }));
             const result = await provider.makeHttpRequest(makeMockWalletProvider("base-sepolia"), {
                 url: "https://api.example.com/free",
                 method: "GET",
@@ -190,144 +202,152 @@ describe("X402ActionProvider", () => {
             expect(parsedResult.data).toEqual({ message: "Success" });
         });
         it("should handle 402 responses with payment options", async () => {
-            mockRequest.mockResolvedValue({
+            mockGetX402Networks.mockReturnValue(["base-sepolia"]);
+            mockFormatPaymentOption.mockResolvedValue("10000 USDC on base-sepolia network");
+            mockFetch.mockResolvedValue(createMockResponse({
                 status: 402,
-                data: MOCK_PAYMENT_INFO_RESPONSE.data,
-                headers: {},
-                config: {},
-            });
+                data: MOCK_PAYMENT_INFO_RESPONSE,
+                headers: { "content-type": "application/json" },
+            }));
             const result = await provider.makeHttpRequest(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
             });
             const parsedResult = JSON.parse(result);
             expect(parsedResult.status).toBe("error_402_payment_required");
-            expect(parsedResult.acceptablePaymentOptions).toEqual(MOCK_PAYMENT_INFO_RESPONSE.data.accepts);
+            expect(parsedResult.acceptablePaymentOptions).toEqual(MOCK_PAYMENT_INFO_RESPONSE.accepts);
             expect(parsedResult.nextSteps).toBeDefined();
         });
         it("should handle network errors", async () => {
-            const error = new Error("Network error");
-            error.isAxiosError = true;
-            error.request = {};
-            mockRequest.mockRejectedValue(error);
+            const error = new TypeError("fetch failed");
+            mockFetch.mockRejectedValue(error);
             const result = await provider.makeHttpRequest(makeMockWalletProvider("base-sepolia"), {
                 url: "https://api.example.com/endpoint",
                 method: "GET",
             });
             const parsedResult = JSON.parse(result);
             expect(parsedResult.error).toBe(true);
-            expect(parsedResult.message).toContain("Network error");
+            expect(parsedResult.message).toBeDefined();
         });
     });
-    describe("listX402Services", () => {
+    describe("discoverX402Services", () => {
         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" },
-                            },
-                        ],
-                    },
-                ],
+            const mockResources = [
+                {
+                    resource: "https://example.com/service1",
+                    x402Version: 1,
+                    accepts: [
+                        {
+                            asset: "0xUSDC",
+                            maxAmountRequired: "90000",
+                            network: "base-sepolia",
+                            scheme: "exact",
+                            description: "Test service 1",
+                        },
+                    ],
+                },
+            ];
+            const mockSimplified = [
+                {
+                    url: "https://example.com/service1",
+                    price: "0.09 USDC on base-sepolia",
+                    description: "Test service 1",
+                },
+            ];
+            mockFetchAllDiscoveryResources.mockResolvedValue(mockResources);
+            mockFilterByNetwork.mockReturnValue(mockResources);
+            mockFilterByDescription.mockReturnValue(mockResources);
+            mockFilterByX402Version.mockReturnValue(mockResources);
+            mockFormatSimplifiedResources.mockResolvedValue(mockSimplified);
+            mockGetX402Networks.mockReturnValue(["base-sepolia"]);
+            const result = await provider.discoverX402Services(makeMockWalletProvider("base-sepolia"), {
+                facilitator: "cdp",
+                x402Versions: [1, 2],
             });
-            mockUseFacilitator.mockReturnValue({ list: mockList });
-            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);
+            expect(parsed.services.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 });
+        it("should filter services by maxPrice", async () => {
+            const mockResources = [
+                {
+                    resource: "https://example.com/service1",
+                    x402Version: 1,
+                    accepts: [
+                        {
+                            asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+                            maxAmountRequired: "90000",
+                            network: "base-sepolia",
+                            scheme: "exact",
+                            description: "Test service 1",
+                        },
+                    ],
+                },
+                {
+                    resource: "https://example.com/service2",
+                    x402Version: 1,
+                    accepts: [
+                        {
+                            asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+                            maxAmountRequired: "150000",
+                            network: "base-sepolia",
+                            scheme: "exact",
+                            description: "Test service 2",
+                        },
+                    ],
+                },
+            ];
+            const filteredResources = [mockResources[0]];
+            const mockSimplified = [
+                {
+                    url: "https://example.com/service1",
+                    price: "0.09 USDC on base-sepolia",
+                    description: "Test service 1",
+                },
+            ];
+            mockFetchAllDiscoveryResources.mockResolvedValue(mockResources);
+            mockFilterByNetwork.mockReturnValue(mockResources);
+            mockFilterByDescription.mockReturnValue(mockResources);
+            mockFilterByX402Version.mockReturnValue(mockResources);
+            mockFilterByMaxPrice.mockResolvedValue(filteredResources);
+            mockFormatSimplifiedResources.mockResolvedValue(mockSimplified);
+            mockGetX402Networks.mockReturnValue(["base-sepolia"]);
             const result = await provider.discoverX402Services(makeMockWalletProvider("base-sepolia"), {
+                facilitator: "cdp",
                 maxUsdcPrice: 0.1,
+                x402Versions: [1, 2],
             });
             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"]));
+            expect(parsed.returned).toBe(1);
+            expect(parsed.services[0].url).toBe("https://example.com/service1");
         });
-        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"), {});
+        it("should handle errors from discovery", async () => {
+            mockFetchAllDiscoveryResources.mockRejectedValue(new Error("boom"));
+            const result = await provider.discoverX402Services(makeMockWalletProvider("base-sepolia"), {
+                facilitator: "cdp",
+                x402Versions: [1, 2],
+            });
             const parsed = JSON.parse(result);
             expect(parsed.error).toBe(true);
             expect(parsed.message).toContain("Failed to list x402 services");
         });
     });
-    describe("retryHttpRequestWithX402", () => {
+    describe("retryWithX402", () => {
         it("should successfully retry with payment", async () => {
-            mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
-            mockRequest.mockResolvedValue({
+            mockGetX402Networks.mockReturnValue(["base-sepolia"]);
+            // Encode the payment proof as base64
+            const encodedPaymentProof = btoa(JSON.stringify(MOCK_PAYMENT_PROOF));
+            mockFetchWithPayment.mockResolvedValue(createMockResponse({
                 status: 200,
-                statusText: "OK",
                 data: { message: "Paid content" },
                 headers: {
-                    "x-payment-response": "encoded-payment-data",
+                    "content-type": "application/json",
+                    "x-payment-response": encodedPaymentProof,
                 },
-                config: {},
-            });
+            }));
             const result = await provider.retryWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
@@ -338,21 +358,15 @@ describe("X402ActionProvider", () => {
                     asset: "0x456",
                 },
             });
-            // Update expectation to accept the payment selector function
-            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer", expect.any(Function));
+            expect(fetch_1.wrapFetchWithPayment).toHaveBeenCalledWith(fetch, mockX402Client);
             const parsedResult = JSON.parse(result);
             expect(parsedResult.status).toBe("success");
-            expect(parsedResult.details.paymentProof).toEqual({
-                transaction: MOCK_PAYMENT_RESPONSE.transaction,
-                network: MOCK_PAYMENT_RESPONSE.network,
-                payer: MOCK_PAYMENT_RESPONSE.payer,
-            });
+            expect(parsedResult.details.paymentProof).toEqual(MOCK_PAYMENT_PROOF);
         });
         it("should handle network errors during payment", async () => {
-            const error = new Error("Network error");
-            error.isAxiosError = true;
-            error.request = {};
-            mockRequest.mockRejectedValue(error);
+            const error = new TypeError("fetch failed");
+            mockGetX402Networks.mockReturnValue(["base-sepolia"]);
+            mockFetchWithPayment.mockRejectedValue(error);
             const result = await provider.retryWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
@@ -365,43 +379,36 @@ describe("X402ActionProvider", () => {
             });
             const parsedResult = JSON.parse(result);
             expect(parsedResult.error).toBe(true);
-            expect(parsedResult.message).toContain("Network error");
         });
     });
     describe("makeHttpRequestWithX402", () => {
         it("should handle successful direct payment requests", async () => {
-            mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
-            mockRequest.mockResolvedValue({
+            // Encode the payment proof as base64
+            const encodedPaymentProof = btoa(JSON.stringify(MOCK_PAYMENT_PROOF));
+            mockFetchWithPayment.mockResolvedValue(createMockResponse({
                 status: 200,
-                statusText: "OK",
                 data: { message: "Paid content" },
                 headers: {
-                    "x-payment-response": "encoded-payment-data",
+                    "content-type": "application/json",
+                    "x-payment-response": encodedPaymentProof,
                 },
-                config: {},
-            });
+            }));
             const result = await provider.makeHttpRequestWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
             });
-            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer");
+            expect(fetch_1.wrapFetchWithPayment).toHaveBeenCalledWith(fetch, mockX402Client);
             const parsedResult = JSON.parse(result);
             expect(parsedResult.success).toBe(true);
             expect(parsedResult.data).toEqual({ message: "Paid content" });
-            expect(parsedResult.paymentProof).toEqual({
-                transaction: MOCK_PAYMENT_RESPONSE.transaction,
-                network: MOCK_PAYMENT_RESPONSE.network,
-                payer: MOCK_PAYMENT_RESPONSE.payer,
-            });
+            expect(parsedResult.paymentProof).toEqual(MOCK_PAYMENT_PROOF);
         });
         it("should handle successful non-payment requests", async () => {
-            mockRequest.mockResolvedValue({
+            mockFetchWithPayment.mockResolvedValue(createMockResponse({
                 status: 200,
-                statusText: "OK",
                 data: { message: "Free content" },
-                headers: {},
-                config: {},
-            });
+                headers: { "content-type": "application/json" },
+            }));
             const result = await provider.makeHttpRequestWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://api.example.com/free",
                 method: "GET",
@@ -412,17 +419,14 @@ describe("X402ActionProvider", () => {
             expect(parsedResult.paymentProof).toBeNull();
         });
         it("should handle network errors", async () => {
-            const error = new Error("Network error");
-            error.isAxiosError = true;
-            error.request = {};
-            mockRequest.mockRejectedValue(error);
+            const error = new TypeError("fetch failed");
+            mockFetchWithPayment.mockRejectedValue(error);
             const result = await provider.makeHttpRequestWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://api.example.com/endpoint",
                 method: "GET",
             });
             const parsedResult = JSON.parse(result);
             expect(parsedResult.error).toBe(true);
-            expect(parsedResult.message).toContain("Network error");
         });
     });
 });