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

@coinbase/agentkit 0.8.2 → 0.9.1

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 (103) 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/action-providers/zora/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export * from "./zoraActionProvider";
+export * from "./schemas";
+export * from "./utils";

package/dist/action-providers/{cdp-v2 → zora}/index.js RENAMED Viewed

@@ -14,5 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./zoraActionProvider"), exports);
 __exportStar(require("./schemas"), exports);
-__exportStar(require("./cdpApiV2ActionProvider"), exports);
+__exportStar(require("./utils"), exports);

package/dist/action-providers/zora/schemas.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const CreateCoinSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodString;
+    category: z.ZodDefault<z.ZodString>;
+    payoutRecipient: z.ZodOptional<z.ZodString>;
+    platformReferrer: z.ZodOptional<z.ZodString>;
+    currency: z.ZodDefault<z.ZodEnum<["ZORA", "ETH"]>>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    description: string;
+    currency: "ETH" | "ZORA";
+    image: string;
+    category: string;
+    platformReferrer?: string | undefined;
+    payoutRecipient?: string | undefined;
+}, {
+    symbol: string;
+    name: string;
+    description: string;
+    image: string;
+    currency?: "ETH" | "ZORA" | undefined;
+    platformReferrer?: string | undefined;
+    category?: string | undefined;
+    payoutRecipient?: string | undefined;
+}>;

package/dist/action-providers/zora/schemas.js ADDED Viewed

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCoinSchema = void 0;
+const zod_1 = require("zod");
+exports.CreateCoinSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().describe("The name of the coin to create"),
+    symbol: zod_1.z.string().describe("The symbol of the coin to create"),
+    description: zod_1.z.string().describe("The description of the coin"),
+    image: zod_1.z.string().describe("Local image file path or URI (ipfs:// or https://)"),
+    category: zod_1.z
+        .string()
+        .default("social")
+        .describe("The category of the coin, optional, defaults to 'social'"),
+    payoutRecipient: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The address that will receive creator earnings, defaults to wallet address"),
+    platformReferrer: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The address that will receive platform referrer fees, optional"),
+    currency: zod_1.z
+        .enum(["ZORA", "ETH"])
+        .default("ZORA")
+        .describe("Currency to be used for the trading pair, optional, defaults to 'ZORA'."),
+})
+    .strip()
+    .describe("Instructions for creating a new coin on Zora");

package/dist/action-providers/zora/utils.d.ts ADDED Viewed

@@ -0,0 +1,28 @@
+/**
+ * Configuration for Pinata
+ */
+interface PinataConfig {
+    jwt: string;
+}
+/**
+ * Parameters for generating token URI
+ */
+interface TokenUriParams {
+    name: string;
+    symbol: string;
+    description: string;
+    image: string;
+    category?: string;
+    pinataConfig: PinataConfig;
+}
+/**
+ * Generates a Zora token URI by handling local file or URI
+ *
+ * @param params - Parameters for generating the token URI
+ * @returns A promise that resolves to object containing the IPFS URI
+ */
+export declare function generateZoraTokenUri(params: TokenUriParams): Promise<{
+    uri: string;
+    imageUri: string;
+}>;
+export {};