npm - @coinbase/agentkit - Versions diffs - 0.8.2 → 0.9.0 - Mend

@coinbase/agentkit 0.8.2 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (65) hide show

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

@@ -127,14 +127,6 @@ const MOCK_PAYMENT_RESPONSE = {
     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(() => {
@@ -171,299 +163,160 @@ describe("X402ActionProvider", () => {
             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 () => {
+    describe("makeHttpRequest", () => {
+        it("should handle successful non-payment requests", async () => {
             mockRequest.mockResolvedValue({
                 status: 200,
-                statusText: "OK",
-                data: { message: "No payment required" },
+                data: { message: "Success" },
                 headers: {},
                 config: {},
             });
-            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+            const result = await provider.makeHttpRequest(mockWalletProvider, {
                 url: "https://api.example.com/free",
                 method: "GET",
             });
             const parsedResult = JSON.parse(result);
-            expect(parsedResult.paymentRequired).toBe(false);
+            expect(parsedResult.success).toBe(true);
             expect(parsedResult.status).toBe(200);
-            expect(parsedResult.data).toEqual({ message: "No payment required" });
+            expect(parsedResult.data).toEqual({ message: "Success" });
         });
-        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 = {
+        it("should handle 402 responses with payment options", async () => {
+            mockRequest.mockResolvedValue({
                 status: 402,
-                statusText: "Payment Required",
-                headers: {
-                    "x-payment-response": "encoded-payment-data",
-                },
                 data: MOCK_PAYMENT_INFO_RESPONSE.data,
+                headers: {},
                 config: {},
-            };
-            mockRequest.mockRejectedValue(error);
-            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+            });
+            const result = await provider.makeHttpRequest(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);
+            expect(parsedResult.status).toBe("error_402_payment_required");
+            expect(parsedResult.acceptablePaymentOptions).toEqual(MOCK_PAYMENT_INFO_RESPONSE.data.accepts);
+            expect(parsedResult.nextSteps).toBeDefined();
         });
-        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");
+        it("should handle network errors", async () => {
+            const error = new Error("Network error");
             error.isAxiosError = true;
-            error.response = {
-                status: 402,
-                statusText: "Payment Required",
-                headers: {
-                    "x-payment-response": paymentDetailsJson,
-                },
-                data: MOCK_PAYMENT_INFO_RESPONSE.data,
-                config: {},
-            };
+            error.request = {};
             mockRequest.mockRejectedValue(error);
-            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
-                url: "https://www.x402.org/protected",
+            const result = await provider.makeHttpRequest(mockWalletProvider, {
+                url: "https://api.example.com/endpoint",
                 method: "GET",
             });
             const parsedResult = JSON.parse(result);
-            expect(parsedResult.paymentDetails).toEqual({ amount: "10000" });
+            expect(parsedResult.error).toBe(true);
+            expect(parsedResult.message).toContain("Network error");
         });
-        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",
+    });
+    describe("retryHttpRequestWithX402", () => {
+        it("should successfully retry with payment", async () => {
+            mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
+            mockRequest.mockResolvedValue({
+                status: 200,
+                statusText: "OK",
+                data: { message: "Paid content" },
                 headers: {
-                    "x-payment-response": "invalid-json",
+                    "x-payment-response": "encoded-payment-data",
                 },
-                data: MOCK_PAYMENT_INFO_RESPONSE.data,
                 config: {},
-            };
-            mockRequest.mockRejectedValue(error);
-            const result = await provider.fetchPaymentInfo(mockWalletProvider, {
+            });
+            const result = await provider.retryWithX402(mockWalletProvider, {
                 url: "https://www.x402.org/protected",
                 method: "GET",
+                selectedPaymentOption: {
+                    scheme: "exact",
+                    network: "base-sepolia",
+                    maxAmountRequired: "10000",
+                    asset: "0x456",
+                },
             });
+            // Update expectation to accept the payment selector function
+            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer", expect.any(Function));
             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(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(result).toContain("Error fetching payment info");
-            expect(result).toContain("HTTP 500");
-            expect(result).toContain("Internal server error");
         });
-        it("should handle network errors", async () => {
+        it("should handle network errors during payment", 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",
+            const result = await provider.retryWithX402(mockWalletProvider, {
+                url: "https://www.x402.org/protected",
                 method: "GET",
+                selectedPaymentOption: {
+                    scheme: "exact",
+                    network: "base-sepolia",
+                    maxAmountRequired: "10000",
+                    asset: "0x456",
+                },
             });
-            expect(result).toContain("Error fetching payment info");
-            expect(result).toContain("Network error");
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.error).toBe(true);
+            expect(parsedResult.message).toContain("Network error");
         });
     });
-    describe("paidRequest", () => {
-        it("should successfully make a paid request with payment response", async () => {
+    describe("makeHttpRequestWithX402", () => {
+        it("should handle successful direct payment requests", async () => {
             mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
             mockRequest.mockResolvedValue({
                 status: 200,
                 statusText: "OK",
-                data: MOCK_PAID_REQUEST_RESPONSE.data,
+                data: { message: "Paid content" },
                 headers: {
-                    "x-payment-response": "encoded-payment-response",
+                    "x-payment-response": "encoded-payment-data",
                 },
                 config: {},
             });
-            const result = await provider.paidRequest(mockWalletProvider, {
+            const result = await provider.makeHttpRequestWithX402(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);
+            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,
+            });
         });
-        it("should handle successful request without payment", async () => {
+        it("should handle successful non-payment requests", async () => {
             mockRequest.mockResolvedValue({
                 status: 200,
                 statusText: "OK",
-                data: { message: "Success" },
+                data: { message: "Free content" },
                 headers: {},
                 config: {},
             });
-            const result = await provider.paidRequest(mockWalletProvider, {
+            const result = await provider.makeHttpRequestWithX402(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");
+            expect(parsedResult.data).toEqual({ message: "Free content" });
+            expect(parsedResult.paymentProof).toBeNull();
         });
         it("should handle network errors", async () => {
-            const error = new Error("Connection timeout");
+            const error = new Error("Network error");
             error.isAxiosError = true;
             error.request = {};
             mockRequest.mockRejectedValue(error);
-            const result = await provider.paidRequest(mockWalletProvider, {
+            const result = await provider.makeHttpRequestWithX402(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" },
-            });
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.error).toBe(true);
+            expect(parsedResult.message).toContain("Network error");
         });
     });
 });

package/dist/agentkit.d.ts CHANGED Viewed

@@ -6,6 +6,7 @@ import { Action, ActionProvider } from "./action-providers";
 export type AgentKitOptions = {
     cdpApiKeyId?: string;
     cdpApiKeySecret?: string;
+    cdpWalletSecret?: string;
     walletProvider?: WalletProvider;
     actionProviders?: ActionProvider[];
 };

package/dist/agentkit.js CHANGED Viewed

@@ -32,12 +32,13 @@ class AgentKit {
     static async from(config = { actionProviders: [(0, action_providers_1.walletActionProvider)()] }) {
         let walletProvider = config.walletProvider;
         if (!config.walletProvider) {
-            if (!config.cdpApiKeyId || !config.cdpApiKeySecret) {
+            if (!config.cdpApiKeyId || !config.cdpApiKeySecret || !config.cdpWalletSecret) {
                 throw new Error("cdpApiKeyId and cdpApiKeySecret are required if not providing a walletProvider");
             }
-            walletProvider = await wallet_providers_1.CdpWalletProvider.configureWithWallet({
+            walletProvider = await wallet_providers_1.CdpSmartWalletProvider.configureWithWallet({
                 apiKeyId: config.cdpApiKeyId,
                 apiKeySecret: config.cdpApiKeySecret,
+                walletSecret: config.cdpWalletSecret,
             });
         }
         return new AgentKit({ ...config, walletProvider: walletProvider });

package/dist/wallet-providers/{cdpV2EvmWalletProvider.d.ts → cdpEvmWalletProvider.d.ts} RENAMED Viewed

@@ -2,26 +2,35 @@ import { CdpClient } from "@coinbase/cdp-sdk";
 import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
 import { Network } from "../network";
 import { EvmWalletProvider } from "./evmWalletProvider";
-import { WalletProviderWithClient, CdpV2WalletProviderConfig } from "./cdpV2Shared";
+import { WalletProviderWithClient, CdpWalletProviderConfig } from "./cdpShared";
 /**
  * A wallet provider that uses the Coinbase SDK.
  */
-export declare class CdpV2EvmWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
+export declare class CdpEvmWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
     #private;
     /**
-     * Constructs a new CdpWalletProvider.
+     * Constructs a new CdpEvmWalletProvider.
      *
-     * @param config - The configuration options for the CdpWalletProvider.
+     * @param config - The configuration options for the CdpEvmWalletProvider.
      */
     private constructor();
     /**
-     * Configures a new CdpWalletProvider with a wallet.
+     * Configures a new CdpEvmWalletProvider with a wallet.
      *
      * @param config - Optional configuration parameters
-     * @returns A Promise that resolves to a new CdpWalletProvider instance
+     * @returns A Promise that resolves to a new CdpEvmWalletProvider instance
      * @throws Error if required environment variables are missing or wallet initialization fails
      */
-    static configureWithWallet(config?: CdpV2WalletProviderConfig): Promise<CdpV2EvmWalletProvider>;
+    static configureWithWallet(config?: CdpWalletProviderConfig): Promise<CdpEvmWalletProvider>;
+    /**
+     * Exports the wallet.
+     *
+     * @returns The wallet's data.
+     */
+    exportWallet(): Promise<{
+        name: string | undefined;
+        address: `0x${string}`;
+    }>;
     /**
      * Signs a message.
      *