@coinbase/agentkit 0.9.0 → 0.10.0

package/dist/action-providers/zerion/zerionActionProvider.test.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zerionActionProvider_1 = require("./zerionActionProvider");
+const utils_1 = require("./utils");
+// Mocks for fetch and utils
+global.fetch = jest.fn();
+jest.mock("./utils", () => ({
+    formatPortfolioData: jest.fn(() => "formatted portfolio"),
+    formatPositionsData: jest.fn(() => "formatted positions"),
+}));
+describe("ZerionActionProvider", () => {
+    const mockApiKey = "test-api-key";
+    const originalEnv = process.env.ZERION_API_KEY;
+    const mockFungiblePositionResponse = {
+        links: {
+            self: "https://api.zerion.io/v1/wallets/0x42b9df65b219b3dd36ff330a4dd8f327a6ada990/positions/",
+        },
+        data: [
+            {
+                type: "positions",
+                id: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa-polygon-asset-none-",
+                attributes: {
+                    parent: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa-polygon-asset-none-",
+                    protocol: null,
+                    pool_address: "0x109830a1aaad605bbf02a9dfa7b0b92ec2fb7daa",
+                    name: "Asset",
+                    group_id: "0a771a0064dad468045899032c7fb01a971f973f7dff0a5cdc3ce199f45e94d7",
+                    position_type: "deposit",
+                    quantity: {
+                        int: "12345678",
+                        decimals: 5,
+                        float: 123.45678,
+                        numeric: "123.45678",
+                    },
+                    value: 5.384656557642683,
+                    price: 0.043615722,
+                    changes: {
+                        absolute_1d: 0.272309794,
+                        percent_1d: 5.326512552079021,
+                    },
+                    fungible_info: {
+                        name: "Bankless BED Index",
+                        symbol: "BED",
+                        description: "The BED index is meant to track crypto’s top 3 investab...",
+                        icon: {
+                            url: "https://token-icons.s3.amazonaws.com/0x0391d2021f89dc339f60fff84546ea23e337750f.png",
+                        },
+                        flags: {
+                            verified: true,
+                        },
+                        implementations: [
+                            {
+                                chain_id: "ethereum",
+                                address: "0x2af1df3ab0ab157e1e2ad8f88a7d04fbea0c7dc6",
+                                decimals: 18,
+                            },
+                        ],
+                    },
+                    flags: {
+                        displayable: true,
+                        is_trash: true,
+                    },
+                    updated_at: "2023-11-10T23:00:00Z",
+                    updated_at_block: 0,
+                    application_metadata: {
+                        name: "AAVE",
+                        icon: {
+                            url: "https://token-icons.s3.amazonaws.com/0x0391d2021f89dc339f60fff84546ea23e337750f.png",
+                        },
+                        url: "https://app.aave.com/",
+                    },
+                },
+                relationships: {
+                    chain: {
+                        links: {
+                            related: "https://api.zerion.io/v1/chains/polygon",
+                        },
+                        data: {
+                            type: "chains",
+                            id: "polygon",
+                        },
+                    },
+                    fungible: {
+                        links: {
+                            related: "https://api.zerion.io/v1/fungibles/0x111c47865ade3b172a928df8f990bc7f2a3b9aaa",
+                        },
+                        data: {
+                            type: "fungibles",
+                            id: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa",
+                        },
+                    },
+                    dapp: {
+                        data: {
+                            type: "dapps",
+                            id: "aave-v3",
+                        },
+                    },
+                },
+            },
+        ],
+    };
+    const mockPortfolioResponse = {
+        links: {
+            self: "https://api.zerion.io/v1/wallets/0x42b9df65b219b3dd36ff330a4dd8f327a6ada990/portfolio",
+        },
+        data: {
+            type: "portfolio",
+            id: "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990",
+            attributes: {
+                positions_distribution_by_type: {
+                    wallet: 1864.774102420957,
+                    deposited: 78.04192492782934,
+                    borrowed: 0.9751475798305564,
+                    locked: 5.780032725068765,
+                    staked: 66.13183205505294,
+                },
+                positions_distribution_by_chain: {
+                    arbitrum: 458.3555051522226,
+                    aurora: 72.01031337463428,
+                    avalanche: 17.128850607339444,
+                    base: 55.01550749900544,
+                    "binance-smart-chain": 5.561075880033699,
+                    celo: 31.293849330045006,
+                    ethereum: 1214.009900354964,
+                    fantom: 84.58514074264951,
+                    linea: 8.258227109505139,
+                    optimism: 573.032664994399,
+                    polygon: 64.31407562634853,
+                    xdai: 113.1679493137936,
+                    "zksync-era": 9.451002156306377,
+                },
+                total: {
+                    positions: 2017.4858230069574,
+                },
+                changes: {
+                    absolute_1d: 102.0271468171374,
+                    percent_1d: 5.326512552079021,
+                },
+            },
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.ZERION_API_KEY = mockApiKey;
+    });
+    afterAll(() => {
+        process.env.ZERION_API_KEY = originalEnv;
+    });
+    it("should throw if no API key is provided", () => {
+        delete process.env.ZERION_API_KEY;
+        expect(() => new zerionActionProvider_1.ZerionActionProvider()).toThrow("ZERION_API_KEY is not configured.");
+    });
+    it("should use provided API key from config", () => {
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: "foo" });
+        expect(provider).toBeDefined();
+    });
+    // supportsNetwork tests
+    const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+    it("should support the protocol family", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+    });
+    it("should not support other protocol families", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "other-protocol-family" })).toBe(false);
+    });
+    it("should handle invalid network objects", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "invalid-protocol" })).toBe(false);
+        expect(provider.supportsNetwork({})).toBe(false);
+    });
+    describe("getPortfolioOverview", () => {
+        const validAddress = "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990";
+        const invalidAddress = "invalid-address";
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+        it("returns error for invalid address", async () => {
+            const result = await provider.getPortfolioOverview({ walletAddress: invalidAddress });
+            expect(result).toMatch(/Invalid wallet address/);
+        });
+        it("returns formatted data for valid address", async () => {
+            global.fetch.mockResolvedValueOnce({
+                json: jest.fn().mockResolvedValue(mockPortfolioResponse),
+            });
+            const result = await provider.getPortfolioOverview({ walletAddress: validAddress });
+            expect(utils_1.formatPortfolioData).toHaveBeenCalledWith(mockPortfolioResponse.data);
+            expect(result).toBe("formatted portfolio");
+        });
+        it("returns error on fetch failure", async () => {
+            global.fetch.mockRejectedValueOnce(new Error("fail"));
+            const result = await provider.getPortfolioOverview({ walletAddress: validAddress });
+            expect(result).toMatch(/Error fetching portfolio overview/);
+        });
+    });
+    describe("getFungiblePositions", () => {
+        const validAddress = "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990";
+        const invalidAddress = "invalid-address";
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+        it("returns error for invalid address", async () => {
+            const result = await provider.getFungiblePositions({ walletAddress: invalidAddress });
+            expect(result).toMatch(/Invalid wallet address/);
+        });
+        it("returns formatted data for valid address", async () => {
+            global.fetch.mockResolvedValueOnce({
+                json: jest.fn().mockResolvedValue(mockFungiblePositionResponse),
+            });
+            const result = await provider.getFungiblePositions({ walletAddress: validAddress });
+            expect(utils_1.formatPositionsData).toHaveBeenCalledWith(mockFungiblePositionResponse.data);
+            expect(result).toBe("formatted positions");
+        });
+        it("returns error on fetch failure", async () => {
+            global.fetch.mockRejectedValueOnce(new Error("fail"));
+            const result = await provider.getFungiblePositions({ walletAddress: validAddress });
+            expect(result).toMatch(/Error fetching fungible positions/);
+        });
+    });
+});

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;