@coinbase/agentkit 0.0.0-nightly-20250724210458 → 0.0.0-nightly-20250806210443

package/dist/action-providers/truemarkets/truemarketsActionProvider.test.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const truemarketsActionProvider_1 = require("./truemarketsActionProvider");
+const constants_1 = require("./constants");
+const viem_1 = require("viem");
+// Mock viem's createPublicClient
+jest.mock("viem", () => {
+    const originalModule = jest.requireActual("viem");
+    return {
+        ...originalModule,
+        createPublicClient: jest.fn().mockImplementation(() => ({
+            // Mock public client methods as needed
+            multicall: jest.fn().mockImplementation(({ contracts }) => {
+                // Create mock responses with success status
+                return contracts.map(() => ({
+                    status: "success",
+                    result: "mock result",
+                }));
+            }),
+            readContract: jest.fn(),
+        })),
+        http: jest.fn().mockImplementation(url => ({ url })),
+    };
+});
+describe("TrueMarketsActionProvider", () => {
+    let provider;
+    let mockWallet;
+    // Mock addresses and data for tests
+    const MOCK_MARKET_ADDRESS = "0x1234567890123456789012345678901234567890";
+    const MOCK_YES_POOL_ADDRESS = "0x2345678901234567890123456789012345678901";
+    const MOCK_NO_POOL_ADDRESS = "0x3456789012345678901234567890123456789012";
+    const MOCK_YES_TOKEN_ADDRESS = "0x4567890123456789012345678901234567890123";
+    const MOCK_NO_TOKEN_ADDRESS = "0x5678901234567890123456789012345678901234";
+    const MOCK_MARKET_QUESTION = "Will this test pass?";
+    const MOCK_ADDITIONAL_INFO = "Test additional info";
+    const MOCK_MARKET_SOURCE = "Test source";
+    const MOCK_STATUS_NUM = 0n; // Created status
+    const MOCK_END_OF_TRADING = 1717171717n; // Unix timestamp
+    describe("constructor", () => {
+        it("should use the provided RPC_URL for the public client", () => {
+            const customRpcUrl = "https://custom-rpc.example.com";
+            (0, truemarketsActionProvider_1.truemarketsActionProvider)({ RPC_URL: customRpcUrl });
+            // Verify createPublicClient was called with the correct URL
+            expect(viem_1.createPublicClient).toHaveBeenCalledWith(expect.objectContaining({
+                chain: expect.anything(),
+                transport: expect.objectContaining({ url: customRpcUrl }),
+            }));
+        });
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        provider = (0, truemarketsActionProvider_1.truemarketsActionProvider)();
+        mockWallet = {
+            readContract: jest.fn(),
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            getNetwork: jest.fn().mockReturnValue({
+                networkId: "base-mainnet",
+            }),
+        };
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("getPredictionMarkets", () => {
+        it("should successfully fetch active markets", async () => {
+            // Mock readContract calls
+            mockWallet.readContract
+                // First call: numberOfActiveMarkets
+                .mockResolvedValueOnce(2n);
+            // Create a spy on the actual implementation
+            const getPredictionMarketsSpy = jest.spyOn(provider, "getPredictionMarkets");
+            // Replace the original implementation with our mocked version to return JSON string
+            getPredictionMarketsSpy.mockImplementation(async () => {
+                return JSON.stringify({
+                    success: true,
+                    totalMarkets: 2,
+                    markets: [
+                        {
+                            id: 1,
+                            address: MOCK_MARKET_ADDRESS,
+                            marketQuestion: MOCK_MARKET_QUESTION,
+                        },
+                        {
+                            id: 0,
+                            address: "0x6789012345678901234567890123456789012345",
+                            marketQuestion: "Will this other test pass?",
+                        },
+                    ],
+                });
+            });
+            const args = {
+                limit: 10,
+                offset: 0,
+                sortOrder: "desc",
+            };
+            const responseString = await provider.getPredictionMarkets(mockWallet, args);
+            const response = JSON.parse(responseString);
+            // Verify response contains expected data
+            expect(response.success).toBe(true);
+            expect(response.totalMarkets).toBe(2);
+            expect(response.markets.length).toBe(2);
+            expect(response.markets[0].marketQuestion).toBe(MOCK_MARKET_QUESTION);
+            expect(response.markets[0].address).toBe(MOCK_MARKET_ADDRESS);
+            // Restore the original implementation
+            getPredictionMarketsSpy.mockRestore();
+        });
+        it("should handle no active markets", async () => {
+            mockWallet.readContract.mockResolvedValueOnce(0n);
+            const args = {
+                limit: 10,
+                offset: 0,
+                sortOrder: "desc",
+            };
+            const responseString = await provider.getPredictionMarkets(mockWallet, args);
+            const response = JSON.parse(responseString);
+            expect(response.success).toBe(true);
+            expect(response.totalMarkets).toBe(0);
+            expect(response.markets.length).toBe(0);
+        });
+        it("should handle errors", async () => {
+            const error = new Error("Failed to fetch active markets");
+            mockWallet.readContract.mockRejectedValueOnce(error);
+            const args = {
+                limit: 10,
+                offset: 0,
+                sortOrder: "desc",
+            };
+            const responseString = await provider.getPredictionMarkets(mockWallet, args);
+            const response = JSON.parse(responseString);
+            expect(response.success).toBe(false);
+            expect(response.error).toBe("Error retrieving active markets: Error: Failed to fetch active markets");
+        });
+    });
+    describe("getPredictionMarketDetails", () => {
+        let mockPublicClient;
+        beforeEach(() => {
+            // Access the mocked public client
+            mockPublicClient = viem_1.createPublicClient.mock.results[0].value;
+            // Setup multicall mock responses
+            mockPublicClient.multicall
+                // Basic info calls
+                .mockResolvedValueOnce([
+                { status: "success", result: MOCK_MARKET_QUESTION },
+                { status: "success", result: MOCK_ADDITIONAL_INFO },
+                { status: "success", result: MOCK_MARKET_SOURCE },
+                { status: "success", result: MOCK_STATUS_NUM },
+                { status: "success", result: MOCK_END_OF_TRADING },
+                { status: "success", result: [MOCK_YES_POOL_ADDRESS, MOCK_NO_POOL_ADDRESS] },
+                { status: "success", result: 0n },
+            ])
+                // Pool info calls
+                .mockResolvedValueOnce([
+                { status: "success", result: constants_1.USDC_ADDRESS },
+                { status: "success", result: MOCK_YES_TOKEN_ADDRESS },
+                { status: "success", result: MOCK_NO_TOKEN_ADDRESS },
+                { status: "success", result: constants_1.USDC_ADDRESS },
+                { status: "success", result: [79228162514264337593543950336n, 0, 0, 0, 0, 0, true] },
+                { status: "success", result: [79228162514264337593543950336n, 0, 0, 0, 0, 0, true] },
+            ])
+                // Balance calls
+                .mockResolvedValueOnce([
+                { status: "success", result: 1000000n },
+                { status: "success", result: 500000000000000000000n },
+                { status: "success", result: 2000000n },
+                { status: "success", result: 1000000000000000000000n },
+            ]);
+        });
+        it("should successfully fetch market details", async () => {
+            const args = MOCK_MARKET_ADDRESS;
+            const responseString = await provider.getPredictionMarketDetails(mockWallet, args);
+            const response = JSON.parse(responseString);
+            // Verify the expected JSON structure
+            expect(response.success).toBe(true);
+            expect(response.marketAddress).toBe(MOCK_MARKET_ADDRESS);
+            expect(response.question).toBe(MOCK_MARKET_QUESTION);
+            expect(response.additionalInfo).toBe(MOCK_ADDITIONAL_INFO);
+            expect(response.source).toBe(MOCK_MARKET_SOURCE);
+            expect(response.status).toBe(0);
+            // Verify tokens
+            expect(response.tokens.yes.lpAddress).toBe(MOCK_YES_POOL_ADDRESS);
+            expect(response.tokens.yes.tokenAddress).toBe(MOCK_YES_TOKEN_ADDRESS);
+            expect(response.tokens.no.lpAddress).toBe(MOCK_NO_POOL_ADDRESS);
+            expect(response.tokens.no.tokenAddress).toBe(MOCK_NO_TOKEN_ADDRESS);
+            // Verify prices and tvl exist
+            expect(typeof response.prices.yes).toBe("number");
+            expect(typeof response.prices.no).toBe("number");
+            expect(typeof response.tvl).toBe("number");
+        });
+        it("should handle errors", async () => {
+            const error = new Error("Failed to fetch market details");
+            mockWallet.readContract.mockReset();
+            mockPublicClient.multicall.mockReset();
+            mockPublicClient.multicall.mockRejectedValueOnce(error);
+            const args = MOCK_MARKET_ADDRESS;
+            const responseString = await provider.getPredictionMarketDetails(mockWallet, args);
+            const response = JSON.parse(responseString);
+            expect(response.success).toBe(false);
+            expect(response.error).toBe("Error retrieving market details: Error: Failed to fetch market details");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for base-mainnet", () => {
+            const network = {
+                networkId: "base-mainnet",
+                protocolFamily: "evm",
+            };
+            expect(provider.supportsNetwork(network)).toBe(true);
+        });
+        it("should return false for other networks", () => {
+            const network = {
+                networkId: "ethereum-mainnet",
+                protocolFamily: "evm",
+            };
+            expect(provider.supportsNetwork(network)).toBe(false);
+        });
+    });
+});

package/dist/action-providers/truemarkets/utils.d.ts

@@ -0,0 +1,10 @@
+export type Slot0Result = readonly [bigint, number, number, number, number, number, boolean];
+export declare const GetMarketStatus: Record<number, string>;
+/**
+ * Interface representing a TruthMarket
+ */
+export interface TruthMarket {
+    id: number;
+    address: string;
+    marketQuestion: string;
+}

package/dist/action-providers/truemarkets/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMarketStatus = void 0;
+const constants_1 = require("./constants");
+// Create mapping for status lookup
+exports.GetMarketStatus = Object.entries(constants_1.MarketStatus).reduce((acc, [key, value]) => {
+    acc[value] = key;
+    return acc;
+}, {});

package/dist/action-providers/zora/index.d.ts

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

package/dist/action-providers/zora/index.js

@@ -0,0 +1,19 @@
+"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 __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("./utils"), exports);

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

@@ -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

@@ -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

@@ -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 {};

package/dist/action-providers/zora/utils.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZoraTokenUri = generateZoraTokenUri;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Reads a local file and converts it to base64
+ *
+ * @param imageFileName - Path to the local file
+ * @returns Base64 encoded file and mime type
+ */
+async function readFileAsBase64(imageFileName) {
+    return new Promise((resolve, reject) => {
+        fs_1.default.readFile(imageFileName, (err, data) => {
+            if (err) {
+                reject(new Error(`Failed to read file: ${err.message}`));
+                return;
+            }
+            // Determine mime type based on file extension
+            const extension = path_1.default.extname(imageFileName).toLowerCase();
+            let mimeType = "application/octet-stream"; // default
+            if (extension === ".png")
+                mimeType = "image/png";
+            else if (extension === ".jpg" || extension === ".jpeg")
+                mimeType = "image/jpeg";
+            else if (extension === ".gif")
+                mimeType = "image/gif";
+            else if (extension === ".svg")
+                mimeType = "image/svg+xml";
+            const base64 = data.toString("base64");
+            resolve({ base64, mimeType });
+        });
+    });
+}
+/**
+ * Uploads a file to IPFS using Pinata
+ *
+ * @param params - Configuration and file data
+ * @param params.pinataConfig - Pinata configuration including JWT
+ * @param params.fileData - Base64 encoded file data
+ * @param params.fileName - Name for the uploaded file
+ * @param params.mimeType - MIME type of the file
+ * @returns Upload response with CID and other details
+ */
+async function uploadFileToIPFS(params) {
+    try {
+        const formData = new FormData();
+        // Convert base64 to Blob and then to File
+        const byteCharacters = atob(params.fileData);
+        const byteArrays = [];
+        for (let offset = 0; offset < byteCharacters.length; offset += 1024) {
+            const slice = byteCharacters.slice(offset, offset + 1024);
+            const byteNumbers = new Array(slice.length);
+            for (let i = 0; i < slice.length; i++) {
+                byteNumbers[i] = slice.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            byteArrays.push(byteArray);
+        }
+        const blob = new Blob(byteArrays, { type: params.mimeType });
+        const file = new File([blob], params.fileName, { type: params.mimeType });
+        formData.append("file", file);
+        const pinataMetadata = {
+            name: params.fileName,
+        };
+        formData.append("pinataMetadata", JSON.stringify(pinataMetadata));
+        const pinataOptions = {
+            cidVersion: 1,
+        };
+        formData.append("pinataOptions", JSON.stringify(pinataOptions));
+        const response = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${params.pinataConfig.jwt}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to upload file to IPFS: ${error.message || response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            IpfsHash: data.IpfsHash,
+            PinSize: data.PinSize,
+            Timestamp: data.Timestamp,
+            isDuplicate: data.isDuplicate || false,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to upload file to IPFS: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Uploads JSON data to IPFS using Pinata
+ *
+ * @param params - Configuration and JSON data
+ * @param params.pinataConfig - Pinata configuration including JWT
+ * @param params.json - JSON data to upload
+ * @returns Upload response with CID and other details
+ */
+async function uploadJsonToIPFS(params) {
+    try {
+        const requestBody = {
+            pinataOptions: {
+                cidVersion: 1,
+            },
+            pinataMetadata: {
+                name: `${params.json.name}-metadata.json`,
+            },
+            pinataContent: params.json,
+        };
+        const response = await fetch("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${params.pinataConfig.jwt}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to upload JSON to IPFS: ${error.message || response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            IpfsHash: data.IpfsHash,
+            PinSize: data.PinSize,
+            Timestamp: data.Timestamp,
+            isDuplicate: data.isDuplicate || false,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to upload JSON to IPFS: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * 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
+ */
+async function generateZoraTokenUri(params) {
+    try {
+        let imageUri;
+        // Check if image is already a URI (ipfs:// or https://)
+        if (params.image.startsWith("ipfs://") || params.image.startsWith("https://")) {
+            imageUri = params.image;
+        }
+        else {
+            // Handle local file
+            const { base64, mimeType } = await readFileAsBase64(params.image);
+            const fileName = path_1.default.basename(params.image);
+            const imageRes = await uploadFileToIPFS({
+                pinataConfig: params.pinataConfig,
+                fileData: base64,
+                fileName,
+                mimeType,
+            });
+            imageUri = `ipfs://${imageRes.IpfsHash}`;
+        }
+        // Create and upload the metadata
+        const metadata = {
+            name: params.name,
+            description: params.description,
+            symbol: params.symbol,
+            image: imageUri,
+            content: {
+                uri: imageUri,
+                mime: imageUri.startsWith("ipfs://") || imageUri.startsWith("https://")
+                    ? "image/*"
+                    : "image/png",
+            },
+            properties: {
+                category: params.category || "social",
+            },
+        };
+        const metadataRes = await uploadJsonToIPFS({
+            pinataConfig: params.pinataConfig,
+            json: metadata,
+        });
+        const uri = `ipfs://${metadataRes.IpfsHash}`;
+        return { uri, imageUri };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to generate Zora token URI: ${error.message}`);
+        }
+        throw error;
+    }
+}

package/dist/action-providers/zora/zoraActionProvider.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers/evmWalletProvider";
+import { CreateCoinSchema } from "./schemas";
+import { Network } from "../../network";
+/**
+ * ZoraActionProvider provides actions for interacting with the Zora protocol.
+ */
+export declare class ZoraActionProvider extends ActionProvider<EvmWalletProvider> {
+    #private;
+    /**
+     * Constructor for the ZoraActionProvider.
+     */
+    constructor();
+    /**
+     * Creates a new Zora coin.
+     *
+     * @param walletProvider - The wallet provider to use for the transaction.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the coin creation details.
+     */
+    createCoin(walletProvider: EvmWalletProvider, args: z.infer<typeof CreateCoinSchema>): Promise<string>;
+    /**
+     * Checks if the Zora action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Zora action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+/**
+ * Factory function to create a new ZoraActionProvider instance.
+ *
+ * @returns A new ZoraActionProvider instance
+ */
+export declare const zoraActionProvider: () => ZoraActionProvider;