@coinbase/agentkit 0.8.1 → 0.8.2

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

@@ -0,0 +1,469 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        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"));
+// Mock modules
+jest.mock("axios");
+jest.mock("x402-axios");
+// 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 mockWithPaymentInterceptor = jest.fn().mockReturnValue(mockAxiosInstance);
+const mockDecodeXPaymentResponse = 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);
+// Mock wallet provider
+const mockWalletProvider = {
+    toSigner: jest.fn().mockReturnValue("mock-signer"),
+};
+// 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",
+                },
+            },
+        ],
+    },
+};
+const MOCK_PAYMENT_RESPONSE = {
+    success: true,
+    transaction: "0xcbc385789d3744b52af5106c32809534f64adcbe097e050ec03d6b53fed5d305",
+    network: "base-sepolia",
+    payer: "0xa8c1a5D3C372C65c04f91f87a43F549619A9483f",
+};
+const MOCK_PAID_REQUEST_RESPONSE = {
+    success: true,
+    url: "https://www.x402.org/protected",
+    method: "GET",
+    status: 200,
+    data: "<!DOCTYPE html><html>...</html>",
+    paymentResponse: MOCK_PAYMENT_RESPONSE,
+};
+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)));
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("supportsNetwork", () => {
+        it("should support base-mainnet", () => {
+            const network = { protocolFamily: "evm", networkId: "base-mainnet" };
+            expect(provider.supportsNetwork(network)).toBe(true);
+        });
+        it("should support base-sepolia", () => {
+            const network = { protocolFamily: "evm", networkId: "base-sepolia" };
+            expect(provider.supportsNetwork(network)).toBe(true);
+        });
+        it("should not support unsupported EVM networks", () => {
+            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" };
+            expect(provider.supportsNetwork(network)).toBe(false);
+        });
+    });
+    describe("fetchPaymentInfo", () => {
+        it("should successfully fetch payment info for 402 response", async () => {
+            mockRequest.mockResolvedValue({
+                status: 402,
+                statusText: "Payment Required",
+                data: MOCK_PAYMENT_INFO_RESPONSE.data,
+                headers: {},
+                config: {},
+            });
+            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            expect(mockRequest).toHaveBeenCalledWith({
+                url: "https://www.x402.org/protected",
+                method: "GET",
+                headers: undefined,
+                validateStatus: expect.any(Function),
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.paymentRequired).toBe(true);
+            expect(parsedResult.status).toBe(402);
+            expect(parsedResult.data).toEqual(MOCK_PAYMENT_INFO_RESPONSE.data);
+        });
+        it("should handle non-payment-protected endpoints", async () => {
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: { message: "No payment required" },
+                headers: {},
+                config: {},
+            });
+            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+                url: "https://api.example.com/free",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.paymentRequired).toBe(false);
+            expect(parsedResult.status).toBe(200);
+            expect(parsedResult.data).toEqual({ message: "No payment required" });
+        });
+        it("should handle 402 errors with payment details in headers", async () => {
+            mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
+            const error = new Error("Payment required");
+            error.isAxiosError = true;
+            error.response = {
+                status: 402,
+                statusText: "Payment Required",
+                headers: {
+                    "x-payment-response": "encoded-payment-data",
+                },
+                data: MOCK_PAYMENT_INFO_RESPONSE.data,
+                config: {},
+            };
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            expect(mockDecodeXPaymentResponse).toHaveBeenCalledWith("encoded-payment-data");
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.paymentRequired).toBe(true);
+            expect(parsedResult.status).toBe(402);
+            expect(parsedResult.paymentDetails).toEqual(MOCK_PAYMENT_RESPONSE);
+        });
+        it("should fallback to JSON.parse when decodeXPaymentResponse fails", async () => {
+            const paymentDetailsJson = '{"amount": "10000"}';
+            mockDecodeXPaymentResponse.mockImplementation(() => {
+                throw new Error("Decode failed");
+            });
+            const error = new Error("Payment required");
+            error.isAxiosError = true;
+            error.response = {
+                status: 402,
+                statusText: "Payment Required",
+                headers: {
+                    "x-payment-response": paymentDetailsJson,
+                },
+                data: MOCK_PAYMENT_INFO_RESPONSE.data,
+                config: {},
+            };
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.paymentDetails).toEqual({ amount: "10000" });
+        });
+        it("should handle payment header parsing failures", async () => {
+            mockDecodeXPaymentResponse.mockImplementation(() => {
+                throw new Error("Decode failed");
+            });
+            const error = new Error("Payment required");
+            error.isAxiosError = true;
+            error.response = {
+                status: 402,
+                statusText: "Payment Required",
+                headers: {
+                    "x-payment-response": "invalid-json",
+                },
+                data: MOCK_PAYMENT_INFO_RESPONSE.data,
+                config: {},
+            };
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.paymentDetails.error).toBe("Failed to decode payment response");
+            expect(parsedResult.paymentDetails.rawHeader).toBe("invalid-json");
+        });
+        it("should handle non-402 HTTP errors", async () => {
+            const error = new Error("Server error");
+            error.isAxiosError = true;
+            error.response = {
+                status: 500,
+                statusText: "Internal Server Error",
+                headers: {},
+                data: { error: "Internal server error" },
+                config: {},
+            };
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
+                method: "GET",
+            });
+            expect(result).toContain("Error fetching payment info");
+            expect(result).toContain("HTTP 500");
+            expect(result).toContain("Internal server error");
+        });
+        it("should handle network errors", async () => {
+            const error = new Error("Network error");
+            error.isAxiosError = true;
+            error.request = {};
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
+                method: "GET",
+            });
+            expect(result).toContain("Error fetching payment info");
+            expect(result).toContain("Network error");
+        });
+    });
+    describe("paidRequest", () => {
+        it("should successfully make a paid request with payment response", async () => {
+            mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: MOCK_PAID_REQUEST_RESPONSE.data,
+                headers: {
+                    "x-payment-response": "encoded-payment-response",
+                },
+                config: {},
+            });
+            const result = await provider.paidRequest(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer");
+            expect(mockRequest).toHaveBeenCalledWith({
+                url: "https://www.x402.org/protected",
+                method: "GET",
+                headers: undefined,
+                data: undefined,
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.status).toBe(200);
+            expect(parsedResult.paymentResponse).toEqual(MOCK_PAYMENT_RESPONSE);
+        });
+        it("should handle successful request without payment", async () => {
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: { message: "Success" },
+                headers: {},
+                config: {},
+            });
+            const result = await provider.paidRequest(mockWalletProvider, {
+                url: "https://api.example.com/free",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.status).toBe(200);
+            expect(parsedResult.paymentResponse).toBe(null);
+        });
+        it("should fallback to JSON.parse when decodeXPaymentResponse fails", async () => {
+            const paymentResponseJson = '{"transaction": "0x123"}';
+            mockDecodeXPaymentResponse.mockImplementation(() => {
+                throw new Error("Decode failed");
+            });
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: "Success",
+                headers: {
+                    "x-payment-response": paymentResponseJson,
+                },
+                config: {},
+            });
+            const result = await provider.paidRequest(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.paymentResponse).toEqual({ transaction: "0x123" });
+        });
+        it("should handle payment response parsing failures", async () => {
+            mockDecodeXPaymentResponse.mockImplementation(() => {
+                throw new Error("Decode failed");
+            });
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: "Success",
+                headers: {
+                    "x-payment-response": "invalid-json",
+                },
+                config: {},
+            });
+            const result = await provider.paidRequest(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
+                method: "GET",
+            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.paymentResponse.error).toBe("Failed to decode payment response");
+            expect(parsedResult.paymentResponse.rawHeader).toBe("invalid-json");
+        });
+        it("should handle HTTP errors", async () => {
+            const error = new Error("Bad request");
+            error.isAxiosError = true;
+            error.response = {
+                status: 400,
+                statusText: "Bad Request",
+                headers: {},
+                data: { error: "Invalid parameters" },
+                config: {},
+            };
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.paidRequest(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
+                method: "POST",
+                body: { test: "data" },
+            });
+            expect(result).toContain("Error making paid request");
+            expect(result).toContain("HTTP 400");
+            expect(result).toContain("Invalid parameters");
+        });
+        it("should handle network errors", async () => {
+            const error = new Error("Connection timeout");
+            error.isAxiosError = true;
+            error.request = {};
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.paidRequest(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
+                method: "GET",
+            });
+            expect(result).toContain("Error making paid request");
+            expect(result).toContain("Network error");
+            expect(result).toContain("Connection timeout");
+        });
+        it("should handle generic errors", async () => {
+            const error = new Error("Something went wrong");
+            mockRequest.mockRejectedValue(error);
+            const result = await provider.paidRequest(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
+                method: "GET",
+            });
+            expect(result).toContain("Error making paid request");
+            expect(result).toContain("Something went wrong");
+        });
+        it("should pass through all request parameters", async () => {
+            mockRequest.mockResolvedValue({
+                status: 200,
+                data: "Success",
+                headers: {},
+            });
+            await provider.paidRequest(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: { key: "value" },
+            });
+            expect(mockRequest).toHaveBeenCalledWith({
+                url: "https://api.example.com/endpoint",
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                data: { key: "value" },
+            });
+        });
+    });
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -31,18 +31,20 @@
     "@privy-io/server-auth": "1.18.4",
     "@solana/spl-token": "^0.4.12",
     "@solana/web3.js": "^1.98.1",
+    "@zerodev/ecdsa-validator": "^5.4.5",
+    "@zerodev/intent": "^0.0.24",
+    "@zerodev/sdk": "^5.4.28",
+    "axios": "^1.9.0",
     "bs58": "^4.0.1",
     "canonicalize": "^2.1.0",
     "decimal.js": "^10.5.0",
     "ethers": "^6.13.5",
-    "@zerodev/ecdsa-validator": "^5.4.5",
-    "@zerodev/intent": "^0.0.24",
-    "@zerodev/sdk": "^5.4.28",
     "md5": "^2.3.0",
     "opensea-js": "^7.1.18",
     "reflect-metadata": "^0.2.2",
     "twitter-api-v2": "^1.18.2",
     "viem": "^2.22.16",
+    "x402-axios": "^0.3.3",
     "zod": "^3.23.8"
   },
   "devDependencies": {