@coinbase/agentkit 0.0.0-nightly-20250328174338

package/dist/action-providers/messari/messariActionProvider.test.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const messariActionProvider_1 = require("./messariActionProvider");
+const constants_1 = require("./constants");
+const MOCK_API_KEY = "messari-test-key";
+const MOCK_RESEARCH_RESPONSE = {
+    data: {
+        messages: [
+            {
+                role: "assistant",
+                content: "Ethereum (ETH) has shown strong performance over the past month with a 15% price increase. The current price is approximately $3,500, up from $3,000 at the beginning of the month. Trading volume has also increased by 20% in the same period.",
+            },
+        ],
+    },
+};
+const MOCK_ERROR_RESPONSE = {
+    error: "Internal server error, please try again. If the problem persists, please contact support",
+    data: null,
+};
+describe("MessariActionProvider", () => {
+    let provider;
+    beforeEach(() => {
+        process.env.MESSARI_API_KEY = MOCK_API_KEY;
+        provider = (0, messariActionProvider_1.messariActionProvider)({ apiKey: MOCK_API_KEY });
+        jest.restoreAllMocks();
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+        delete process.env.MESSARI_API_KEY;
+    });
+    describe("constructor", () => {
+        it("should initialize with API key from constructor", () => {
+            const customProvider = (0, messariActionProvider_1.messariActionProvider)({ apiKey: "custom-key" });
+            expect(customProvider["apiKey"]).toBe("custom-key");
+        });
+        it("should initialize with API key from environment variable", () => {
+            process.env.MESSARI_API_KEY = "env-key";
+            const envProvider = (0, messariActionProvider_1.messariActionProvider)();
+            expect(envProvider["apiKey"]).toBe("env-key");
+        });
+        it("should throw error if API key is not provided", () => {
+            delete process.env.MESSARI_API_KEY;
+            expect(() => (0, messariActionProvider_1.messariActionProvider)()).toThrow(constants_1.API_KEY_MISSING_ERROR);
+        });
+    });
+    describe("researchQuestion", () => {
+        it("should successfully fetch research results", async () => {
+            const fetchMock = jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => MOCK_RESEARCH_RESPONSE,
+            });
+            const question = "What is the current price of Ethereum?";
+            const response = await provider.researchQuestion({ question });
+            expect(fetchMock).toHaveBeenCalled();
+            const [url, options] = fetchMock.mock.calls[0];
+            expect(url).toBe("https://api.messari.io/ai/v1/chat/completions");
+            expect(options).toEqual(expect.objectContaining({
+                method: "POST",
+                headers: expect.objectContaining({
+                    "Content-Type": "application/json",
+                    "x-messari-api-key": MOCK_API_KEY,
+                }),
+                body: JSON.stringify({
+                    messages: [
+                        {
+                            role: "user",
+                            content: question,
+                        },
+                    ],
+                }),
+            }));
+            expect(response).toContain("Messari Research Results:");
+            expect(response).toContain(MOCK_RESEARCH_RESPONSE.data.messages[0].content);
+        });
+        it("should handle non-ok response with structured error format", async () => {
+            const errorResponseText = JSON.stringify(MOCK_ERROR_RESPONSE);
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: false,
+                status: 500,
+                statusText: "Internal Server Error",
+                text: async () => errorResponseText,
+            });
+            const response = await provider.researchQuestion({
+                question: "What is the current price of Bitcoin?",
+            });
+            expect(response).toContain("Messari API Error: Internal server error");
+            expect(response).not.toContain("500");
+        });
+        it("should handle non-ok response with non-JSON error format", async () => {
+            const plainTextError = "Rate limit exceeded";
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: false,
+                status: 429,
+                statusText: "Too Many Requests",
+                text: async () => plainTextError,
+            });
+            const response = await provider.researchQuestion({
+                question: "What is the current price of Bitcoin?",
+            });
+            expect(response).toContain("Messari API Error:");
+            expect(response).toContain("429");
+            expect(response).toContain("Too Many Requests");
+            expect(response).toContain(plainTextError);
+        });
+        it("should handle JSON parsing error in successful response", async () => {
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => {
+                    throw new Error("Invalid JSON");
+                },
+            });
+            const response = await provider.researchQuestion({
+                question: "What is the market cap of Solana?",
+            });
+            expect(response).toContain("Unexpected error: Failed to parse API response");
+            expect(response).toContain("Invalid JSON");
+        });
+        it("should handle invalid response format", async () => {
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => ({ data: { messages: [] } }),
+            });
+            const response = await provider.researchQuestion({
+                question: "What is the market cap of Solana?",
+            });
+            expect(response).toContain("Unexpected error: Received invalid response format from Messari API");
+        });
+        it("should handle fetch error", async () => {
+            const error = new Error("Network error");
+            jest.spyOn(global, "fetch").mockRejectedValue(error);
+            const response = await provider.researchQuestion({
+                question: "What is the market cap of Solana?",
+            });
+            expect(response).toContain("Unexpected error: Network error");
+        });
+        it("should handle string error with JSON content", async () => {
+            const stringifiedError = JSON.stringify(MOCK_ERROR_RESPONSE);
+            jest.spyOn(global, "fetch").mockRejectedValue(stringifiedError);
+            const response = await provider.researchQuestion({
+                question: "What is the market cap of Solana?",
+            });
+            expect(response).toContain("Messari API Error: Internal server error");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should always return true as research is network-agnostic", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+            expect(provider.supportsNetwork({ protocolFamily: "solana" })).toBe(true);
+            expect(provider.supportsNetwork({ protocolFamily: "unknown" })).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/**
+ * Input schema for submitting a research question to Messari AI.
+ */
+export declare const MessariResearchQuestionSchema: z.ZodObject<{
+    question: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    question: string;
+}, {
+    question: string;
+}>;

package/dist/action-providers/messari/schemas.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessariResearchQuestionSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for submitting a research question to Messari AI.
+ */
+exports.MessariResearchQuestionSchema = zod_1.z
+    .object({
+    question: zod_1.z
+        .string()
+        .min(1, "Research question is required.")
+        .describe("The research question about crypto markets, protocols, or tokens"),
+})
+    .strip()
+    .describe("Input schema for submitting a research question to Messari AI");

package/dist/action-providers/messari/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Configuration options for the MessariActionProvider.
+ */
+export interface MessariActionProviderConfig {
+    /**
+     * Messari API Key
+     */
+    apiKey?: string;
+}
+/**
+ * Message format in Messari API responses
+ */
+export interface MessariMessage {
+    content: string;
+    role: string;
+}
+/**
+ * Response format from Messari API
+ */
+export interface MessariAPIResponse {
+    data: {
+        messages: MessariMessage[];
+    };
+}
+/**
+ * Error response format from Messari API
+ */
+export interface MessariErrorResponse {
+    error?: string;
+    data?: null | unknown;
+}
+/**
+ * Extended Error interface for Messari API errors
+ */
+export interface MessariError extends Error {
+    status?: number;
+    statusText?: string;
+    responseText?: string;
+    errorResponse?: MessariErrorResponse;
+}

package/dist/action-providers/messari/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import { MessariError } from "./types";
+/**
+ * Creates a MessariError from an HTTP response
+ *
+ * @param response - The fetch Response object
+ * @returns A MessariError with response details
+ */
+export declare function createMessariError(response: Response): Promise<MessariError>;
+/**
+ * Formats error details for API errors
+ *
+ * @param error - The MessariError to format
+ * @returns Formatted error message
+ */
+export declare function formatMessariApiError(error: MessariError): string;
+/**
+ * Formats generic errors
+ *
+ * @param error - The error to format
+ * @returns Formatted error message
+ */
+export declare function formatGenericError(error: unknown): string;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessariError = createMessariError;
+exports.formatMessariApiError = formatMessariApiError;
+exports.formatGenericError = formatGenericError;
+/**
+ * Creates a MessariError from an HTTP response
+ *
+ * @param response - The fetch Response object
+ * @returns A MessariError with response details
+ */
+async function createMessariError(response) {
+    const error = new Error(`Messari API returned ${response.status} ${response.statusText}`);
+    error.status = response.status;
+    error.statusText = response.statusText;
+    const responseText = await response.text();
+    error.responseText = responseText;
+    try {
+        const errorJson = JSON.parse(responseText);
+        error.errorResponse = errorJson;
+    }
+    catch {
+        // If parsing fails, just use the raw text
+    }
+    return error;
+}
+/**
+ * Formats error details for API errors
+ *
+ * @param error - The MessariError to format
+ * @returns Formatted error message
+ */
+function formatMessariApiError(error) {
+    if (error.errorResponse?.error) {
+        return `Messari API Error: ${error.errorResponse.error}`;
+    }
+    const errorDetails = {
+        status: error.status,
+        statusText: error.statusText,
+        responseText: error.responseText,
+        message: error.message,
+    };
+    return `Messari API Error: ${JSON.stringify(errorDetails, null, 2)}`;
+}
+/**
+ * Formats generic errors
+ *
+ * @param error - The error to format
+ * @returns Formatted error message
+ */
+function formatGenericError(error) {
+    // Check if this might be a JSON string containing an error message
+    if (typeof error === "string") {
+        try {
+            const parsedError = JSON.parse(error);
+            if (parsedError.error) {
+                return `Messari API Error: ${parsedError.error}`;
+            }
+        }
+        catch {
+            // Not valid JSON, continue with normal handling
+        }
+    }
+    return `Unexpected error: ${error instanceof Error ? error.message : String(error)}`;
+}

package/dist/action-providers/moonwell/constants.d.ts

@@ -0,0 +1,78 @@
+export declare const MOONWELL_BASE_ADDRESSES: {
+    "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22": string;
+    "0x73b06D8d18De422E269645eaCe15400DE7462417": string;
+    "0x628ff693426583D9a7FB391E54366292F509D457": string;
+    "0x3bf93770f2d4a794c3d9EBEfBAeBAE2a8f09A5E5": string;
+    "0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b": string;
+    "0x73902f619CEB9B31FD8EFecf435CbDf89E369Ba6": string;
+    "0xb8051464C8c92209C92F3a4CD9C73746C4c3CFb3": string;
+    "0xF877ACaFA28c19b96727966690b2f44d35aD5976": string;
+    "0xb682c840B5F4FC58B20769E691A6fa1305A501a2": string;
+    "0xfC41B49d064Ac646015b459C522820DB9472F4B5": string;
+    "0xdC7810B47eAAb250De623F0eE07764afa5F71ED1": string;
+    "0xb6419c6C2e60c4025D6D06eE4F913ce89425a357": string;
+    "0x9A858ebfF1bEb0D3495BB0e2897c1528eD84A218": string;
+    "0x70778cfcFC475c7eA0f24cC625Baf6EaE475D0c9": string;
+};
+export declare const MOONWELL_BASE_SEPOLIA_ADDRESSES: {
+    "0x876852425331a113d8E432eFFB3aC5BEf38f033a": string;
+    "0x5302EbD8BC32435C823c2e22B04Cd6c45f593e89": string;
+    "0x2F39a349A79492a70E152760ce7123A1933eCf28": string;
+};
+export declare const WETH_ROUTER_ADDRESS = "0x70778cfcFC475c7eA0f24cC625Baf6EaE475D0c9";
+export declare const TOKEN_DECIMALS: {
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": number;
+    "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42": number;
+    "0x04C0599Ae5A44757c0af6F9eC3b93da8976c150A": number;
+    "0xEDfa23602D0EC14714057867A78d01e94176BEA0": number;
+    "0x236aa50979D5f3De3Bd1Eeb40E81137F22ab794b": number;
+    "0xA88594D404727625A9437C3f886C7643872296AE": number;
+    "0x820C137fa70C8691f0e44Dc420a5e53c168921Dc": number;
+    "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb": number;
+    "0x4200000000000000000000000000000000000006": number;
+    "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22": number;
+    "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452": number;
+    "0x940181a94a35a4569e4529a3cdfb74e38fd98631": number;
+    "0x0000000000000000000000000000000000000000": number;
+};
+export declare const MTOKENS_UNDERLYING_DECIMALS: {
+    MOONWELL_USDC: number;
+    MOONWELL_DAI: number;
+    MOONWELL_WETH: number;
+    MOONWELL_cbETH: number;
+    MOONWELL_wstETH: number;
+    MOONWELL_AERO: number;
+    MOONWELL_weETH: number;
+    MOONWELL_cbBTC: number;
+    MOONWELL_EURC: number;
+    MOONWELL_wrsETH: number;
+    MOONWELL_WELL: number;
+    MOONWELL_USDS: number;
+    MOONWELL_TBTC: number;
+};
+export declare const ETH_ROUTER_ABI: {
+    name: string;
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];
+export declare const MTOKEN_ABI: {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+}[];

package/dist/action-providers/moonwell/constants.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MTOKEN_ABI = exports.ETH_ROUTER_ABI = exports.MTOKENS_UNDERLYING_DECIMALS = exports.TOKEN_DECIMALS = exports.WETH_ROUTER_ADDRESS = exports.MOONWELL_BASE_SEPOLIA_ADDRESSES = exports.MOONWELL_BASE_ADDRESSES = void 0;
+exports.MOONWELL_BASE_ADDRESSES = {
+    "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22": "MOONWELL_USDC",
+    "0x73b06D8d18De422E269645eaCe15400DE7462417": "MOONWELL_DAI",
+    "0x628ff693426583D9a7FB391E54366292F509D457": "MOONWELL_WETH",
+    "0x3bf93770f2d4a794c3d9EBEfBAeBAE2a8f09A5E5": "MOONWELL_cbETH",
+    "0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b": "MOONWELL_wstETH",
+    "0x73902f619CEB9B31FD8EFecf435CbDf89E369Ba6": "MOONWELL_AERO",
+    "0xb8051464C8c92209C92F3a4CD9C73746C4c3CFb3": "MOONWELL_weETH",
+    "0xF877ACaFA28c19b96727966690b2f44d35aD5976": "MOONWELL_cbBTC",
+    "0xb682c840B5F4FC58B20769E691A6fa1305A501a2": "MOONWELL_EURC",
+    "0xfC41B49d064Ac646015b459C522820DB9472F4B5": "MOONWELL_wrsETH",
+    "0xdC7810B47eAAb250De623F0eE07764afa5F71ED1": "MOONWELL_WELL",
+    "0xb6419c6C2e60c4025D6D06eE4F913ce89425a357": "MOONWELL_USDS",
+    "0x9A858ebfF1bEb0D3495BB0e2897c1528eD84A218": "MOONWELL_TBTC",
+    "0x70778cfcFC475c7eA0f24cC625Baf6EaE475D0c9": "WETH_ROUTER",
+};
+exports.MOONWELL_BASE_SEPOLIA_ADDRESSES = {
+    "0x876852425331a113d8E432eFFB3aC5BEf38f033a": "MOONWELL_USDBC",
+    "0x5302EbD8BC32435C823c2e22B04Cd6c45f593e89": "MOONWELL_cbETH",
+    "0x2F39a349A79492a70E152760ce7123A1933eCf28": "MOONWELL_WETH",
+};
+exports.WETH_ROUTER_ADDRESS = "0x70778cfcFC475c7eA0f24cC625Baf6EaE475D0c9";
+// Token decimals mapping
+exports.TOKEN_DECIMALS = {
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": 6, // USDC
+    "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42": 6, // EURC
+    "0x04C0599Ae5A44757c0af6F9eC3b93da8976c150A": 18, // weETH
+    "0xEDfa23602D0EC14714057867A78d01e94176BEA0": 18, // wrsETH
+    "0x236aa50979D5f3De3Bd1Eeb40E81137F22ab794b": 18, // tBTC
+    "0xA88594D404727625A9437C3f886C7643872296AE": 18, // WELL
+    "0x820C137fa70C8691f0e44Dc420a5e53c168921Dc": 18, // USDS
+    "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb": 18, // DAI
+    "0x4200000000000000000000000000000000000006": 18, // WETH
+    "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22": 18, // cbETH
+    "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452": 18, // wstETH
+    "0x940181a94a35a4569e4529a3cdfb74e38fd98631": 18, // AERO
+    "0x0000000000000000000000000000000000000000": 18, // ETH (native)
+};
+exports.MTOKENS_UNDERLYING_DECIMALS = {
+    MOONWELL_USDC: 6,
+    MOONWELL_DAI: 18,
+    MOONWELL_WETH: 18,
+    MOONWELL_cbETH: 18,
+    MOONWELL_wstETH: 18,
+    MOONWELL_AERO: 18,
+    MOONWELL_weETH: 18,
+    MOONWELL_cbBTC: 18,
+    MOONWELL_EURC: 6,
+    MOONWELL_wrsETH: 18,
+    MOONWELL_WELL: 18,
+    MOONWELL_USDS: 18,
+    MOONWELL_TBTC: 18,
+};
+exports.ETH_ROUTER_ABI = [
+    {
+        name: "mint",
+        inputs: [
+            {
+                internalType: "address",
+                name: "receiver",
+                type: "address",
+            },
+        ],
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+];
+exports.MTOKEN_ABI = [
+    {
+        type: "function",
+        name: "mint",
+        inputs: [
+            {
+                name: "mintAmount",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+        outputs: [
+            {
+                name: "",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "redeemUnderlying",
+        inputs: [
+            {
+                name: "redeemAmount",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+        outputs: [
+            {
+                name: "",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+    },
+];

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

@@ -0,0 +1 @@
+export { moonwellActionProvider } from "./moonwellActionProvider";

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moonwellActionProvider = void 0;
+var moonwellActionProvider_1 = require("./moonwellActionProvider");
+Object.defineProperty(exports, "moonwellActionProvider", { enumerable: true, get: function () { return moonwellActionProvider_1.moonwellActionProvider; } });

package/dist/action-providers/moonwell/moonwellActionProvider.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { MintSchema, RedeemSchema } from "./schemas";
+import { Network } from "../../network";
+export declare const SUPPORTED_NETWORKS: string[];
+/**
+ * MoonwellActionProvider is an action provider for Moonwell MToken interactions.
+ */
+export declare class MoonwellActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the MoonwellActionProvider class.
+     */
+    constructor();
+    /**
+     * Deposits assets into a Moonwell MToken
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    mint(wallet: EvmWalletProvider, args: z.infer<typeof MintSchema>): Promise<string>;
+    /**
+     * Redeems assets from a Moonwell MToken
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    redeem(wallet: EvmWalletProvider, args: z.infer<typeof RedeemSchema>): Promise<string>;
+    /**
+     * Checks if the Moonwell action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Moonwell action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const moonwellActionProvider: () => MoonwellActionProvider;