@coinbase/agentkit 0.0.0-nightly-20250328174338

package/dist/action-providers/jupiter/jupiterActionProvider.js

@@ -0,0 +1,115 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jupiterActionProvider = exports.JupiterActionProvider = void 0;
+const actionProvider_1 = require("../actionProvider");
+const svmWalletProvider_1 = require("../../wallet-providers/svmWalletProvider");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const web3_js_1 = require("@solana/web3.js");
+const api_1 = require("@jup-ag/api");
+/**
+ * JupiterActionProvider handles token swaps using Jupiter's API.
+ */
+class JupiterActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Initializes Jupiter API client.
+     */
+    constructor() {
+        super("jupiter", []);
+    }
+    /**
+     * Swaps tokens using Jupiter's API.
+     *
+     * @param walletProvider - The wallet provider to use for the swap
+     * @param args - Swap parameters including input token, output token, and amount
+     * @returns A message indicating success or failure with transaction details
+     */
+    async swap(walletProvider, args) {
+        try {
+            const jupiterApi = (0, api_1.createJupiterApiClient)();
+            const userPublicKey = walletProvider.getPublicKey();
+            const inputMint = new web3_js_1.PublicKey(args.inputMint);
+            const outputMint = new web3_js_1.PublicKey(args.outputMint);
+            const { getMint } = await import("@solana/spl-token");
+            let mintInfo;
+            try {
+                mintInfo = await getMint(walletProvider.getConnection(), inputMint);
+            }
+            catch (error) {
+                return `Failed to fetch mint info for mint address ${args.inputMint}. Error: ${error}`;
+            }
+            const amount = args.amount * 10 ** mintInfo.decimals;
+            const quoteResponse = await jupiterApi.quoteGet({
+                inputMint: inputMint.toBase58(),
+                outputMint: outputMint.toBase58(),
+                amount: amount,
+                slippageBps: args.slippageBps || 50, // 0.5% default slippage
+            });
+            if (!quoteResponse) {
+                throw new Error("Failed to get a swap quote.");
+            }
+            const swapRequest = {
+                userPublicKey: userPublicKey.toBase58(),
+                wrapAndUnwrapSol: true,
+                useSharedAccounts: true, // Optimize for low transaction costs
+                quoteResponse,
+            };
+            const swapResponse = await jupiterApi.swapPost({ swapRequest });
+            if (!swapResponse || !swapResponse.swapTransaction) {
+                throw new Error("Failed to generate swap transaction.");
+            }
+            const transactionBuffer = Buffer.from(swapResponse.swapTransaction, "base64");
+            const tx = web3_js_1.VersionedTransaction.deserialize(transactionBuffer);
+            const signature = await walletProvider.signAndSendTransaction(tx);
+            await walletProvider.waitForSignatureResult(signature);
+            return `Successfully swapped ${args.amount} tokens! Signature: ${signature}`;
+        }
+        catch (error) {
+            return `Error swapping tokens: ${error}`;
+        }
+    }
+    /**
+     * Checks if the action provider supports the given network.
+     * Only supports Solana networks.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is a Solana network
+     */
+    supportsNetwork(network) {
+        return network.protocolFamily == "svm" && network.networkId === "solana-mainnet";
+    }
+}
+exports.JupiterActionProvider = JupiterActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "swap",
+        description: `
+    Swaps tokens using Jupiter's DEX aggregator.
+    - Input and output tokens must be valid SPL token mints.
+    - Ensures sufficient balance before executing swap.
+    - If says "SOL" as the input or output, use the mint address So11111111111111111111111111111111111111112
+    NOTE: Only available on Solana mainnet.
+    `,
+        schema: schemas_1.SwapTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [svmWalletProvider_1.SvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], JupiterActionProvider.prototype, "swap", null);
+/**
+ * Factory function to create a new JupiterActionProvider instance.
+ *
+ * @returns A new JupiterActionProvider instance
+ */
+const jupiterActionProvider = () => new JupiterActionProvider();
+exports.jupiterActionProvider = jupiterActionProvider;

package/dist/action-providers/jupiter/jupiterActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/jupiter/jupiterActionProvider.test.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const jupiterActionProvider_1 = require("./jupiterActionProvider");
+const api_1 = require("@jup-ag/api");
+// Default SPL token decimals for tests
+const DECIMALS = 6;
+// Mock the @solana/web3.js module
+jest.mock("@solana/web3.js", () => ({
+    // Preserve the actual implementation of @solana/web3.js while overriding specific methods
+    ...jest.requireActual("@solana/web3.js"),
+    // Mock the Solana Connection class to prevent real network calls
+    Connection: jest.fn(),
+    // Mock the VersionedTransaction class and its deserialize method
+    VersionedTransaction: {
+        deserialize: jest.fn().mockReturnValue({
+            // Mock the sign method to prevent actual signing operations
+            sign: jest.fn(),
+        }),
+    },
+    // Mock the MessageV0 class and its compile method to return an empty object
+    MessageV0: {
+        compile: jest.fn().mockReturnValue({}),
+    },
+}));
+// Mock the @solana/spl-token module
+jest.mock("@solana/spl-token", () => ({
+    // Preserve the actual implementation of @solana/spl-token while overriding specific methods
+    ...jest.requireActual("@solana/spl-token"),
+    // Mock getMint to always return a fixed decimal value for tokens
+    getMint: jest.fn().mockReturnValue({ decimals: DECIMALS }),
+}));
+// Mock the @jup-ag/api module
+jest.mock("@jup-ag/api", () => ({
+    // Mock the createJupiterApiClient function to return an object with mocked methods
+    createJupiterApiClient: jest.fn().mockReturnValue({
+        // Mock the quoteGet method, which fetches the best swap route
+        quoteGet: jest.fn(),
+        // Mock the swapPost method, which generates the swap transaction
+        swapPost: jest.fn(),
+    }),
+}));
+// Mock the custom wallet provider used for Solana transactions
+jest.mock("../../wallet-providers/svmWalletProvider");
+describe("JupiterActionProvider", () => {
+    let actionProvider;
+    let mockWallet;
+    let mockConnection;
+    let mockJupiterApi;
+    let mockQuoteGet;
+    let mockSwapPost;
+    beforeEach(() => {
+        jest.clearAllMocks(); // Reset mocks before each test to ensure no test interference
+        // Create a mock Jupiter API client with mocked methods
+        mockJupiterApi = (0, api_1.createJupiterApiClient)();
+        mockQuoteGet = mockJupiterApi.quoteGet;
+        mockSwapPost = mockJupiterApi.swapPost;
+        // Initialize the action provider
+        actionProvider = new jupiterActionProvider_1.JupiterActionProvider();
+        // Mock the Solana connection to avoid real network requests
+        mockConnection = {
+            getLatestBlockhash: jest.fn().mockResolvedValue({ blockhash: "mockedBlockhash" }),
+        };
+        // Mock the wallet provider with necessary methods
+        mockWallet = {
+            getConnection: jest.fn().mockReturnValue(mockConnection), // Return the mocked connection
+            getPublicKey: jest.fn().mockReturnValue(new web3_js_1.PublicKey("11111111111111111111111111111111")),
+            signAndSendTransaction: jest.fn().mockResolvedValue("mock-signature"),
+            waitForSignatureResult: jest.fn().mockResolvedValue({
+                context: { slot: 1234 },
+                value: { err: null },
+            }),
+            getAddress: jest.fn().mockReturnValue("11111111111111111111111111111111"),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "svm", networkId: "solana-mainnet" }),
+            getName: jest.fn().mockReturnValue("mock-wallet"),
+            getBalance: jest.fn().mockResolvedValue(BigInt(1000000000)),
+            nativeTransfer: jest.fn(),
+        };
+    });
+    /**
+     * Test cases for the swap function of JupiterActionProvider
+     */
+    describe("swap", () => {
+        const INPUT_MINT = "So11111111111111111111111111111111111111112"; // Mock SOL mint address
+        const OUTPUT_MINT = "BXXkv6FbfHZmKbMmy6KvaakKt6bYjhbjmhvJ92kp92Mw"; // Mock token mint address
+        const MOCK_SIGNATURE = "mock-signature";
+        // Mock arguments for swapping tokens
+        const swapArgs = {
+            inputMint: INPUT_MINT,
+            outputMint: OUTPUT_MINT,
+            amount: 1000, // User-specified amount
+            slippageBps: 50, // Slippage tolerance
+        };
+        /**
+         * Test successful token swap execution
+         */
+        it("should successfully swap tokens", async () => {
+            // Mock a successful quote response from Jupiter
+            mockQuoteGet.mockResolvedValue({ route: "mock-route" });
+            // Mock a successful swap transaction response from Jupiter
+            mockSwapPost.mockResolvedValue({
+                swapTransaction: Buffer.from("mock-transaction").toString("base64"),
+            });
+            // Call the swap function
+            const result = await actionProvider.swap(mockWallet, swapArgs);
+            // Verify that Jupiter was called with correct parameters
+            expect(mockQuoteGet).toHaveBeenCalledWith({
+                inputMint: INPUT_MINT,
+                outputMint: OUTPUT_MINT,
+                amount: swapArgs.amount * 10 ** DECIMALS, // Ensure correct decimal conversion
+                slippageBps: swapArgs.slippageBps,
+            });
+            expect(mockSwapPost).toHaveBeenCalled();
+            expect(mockWallet.waitForSignatureResult).toHaveBeenCalledWith(MOCK_SIGNATURE);
+            expect(result).toContain("Successfully swapped");
+        });
+        /**
+         * Test handling of errors when retrieving a swap quote
+         */
+        it("should handle swap quote errors", async () => {
+            mockQuoteGet.mockRejectedValue(new Error("Quote error")); // Simulate an API failure
+            const result = await actionProvider.swap(mockWallet, swapArgs);
+            expect(result).toBe("Error swapping tokens: Error: Quote error");
+        });
+        /**
+         * Test handling of errors when posting a swap transaction
+         */
+        it("should handle swap transaction errors", async () => {
+            mockQuoteGet.mockResolvedValue({ route: "mock-route" });
+            mockSwapPost.mockRejectedValue(new Error("Swap transaction error")); // Simulate a failure
+            const result = await actionProvider.swap(mockWallet, swapArgs);
+            expect(result).toBe("Error swapping tokens: Error: Swap transaction error");
+        });
+    });
+    describe("supportsNetwork", () => {
+        test.each([
+            [{ protocolFamily: "svm", networkId: "solana-mainnet" }, true, "solana mainnet"],
+            [{ protocolFamily: "svm", networkId: "solana-devnet" }, false, "solana devnet"],
+            [{ protocolFamily: "evm", networkId: "ethereum-mainnet" }, false, "ethereum mainnet"],
+            [{ protocolFamily: "evm", networkId: "solana-mainnet" }, false, "wrong protocol family"],
+            [{ protocolFamily: "svm", networkId: "ethereum-mainnet" }, false, "wrong network id"],
+        ])("should return %p for %s", (network, expected) => {
+            expect(actionProvider.supportsNetwork(network)).toBe(expected);
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+import { z } from "zod";
+/**
+ * Schema for swapping tokens using Jupiter.
+ */
+export declare const SwapTokenSchema: z.ZodObject<{
+    inputMint: z.ZodString;
+    outputMint: z.ZodString;
+    amount: z.ZodNumber;
+    slippageBps: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    inputMint: string;
+    outputMint: string;
+    slippageBps: number;
+}, {
+    amount: number;
+    inputMint: string;
+    outputMint: string;
+    slippageBps?: number | undefined;
+}>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapTokenSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Schema for swapping tokens using Jupiter.
+ */
+exports.SwapTokenSchema = zod_1.z
+    .object({
+    inputMint: zod_1.z.string().describe("The mint address of the token to swap from"),
+    outputMint: zod_1.z.string().describe("The mint address of the token to swap to"),
+    amount: zod_1.z.number().positive().describe("Amount of tokens to swap"),
+    slippageBps: zod_1.z
+        .number()
+        .int()
+        .positive()
+        .default(50)
+        .describe("Slippage tolerance in basis points (e.g., 50 = 0.5%)"),
+})
+    .describe("Swap tokens using Jupiter DEX aggregator");

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

@@ -0,0 +1,17 @@
+/**
+ * Base URL for the Messari API
+ */
+export declare const MESSARI_BASE_URL = "https://api.messari.io/ai/v1";
+/**
+ * Default error message when API key is missing
+ */
+export declare const API_KEY_MISSING_ERROR = "MESSARI_API_KEY is not configured.";
+/**
+ * Rate limits by subscription tier
+ */
+export declare const RATE_LIMITS: {
+    FREE: string;
+    LITE: string;
+    PRO: string;
+    ENTERPRISE: string;
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RATE_LIMITS = exports.API_KEY_MISSING_ERROR = exports.MESSARI_BASE_URL = void 0;
+/**
+ * Base URL for the Messari API
+ */
+exports.MESSARI_BASE_URL = "https://api.messari.io/ai/v1";
+/**
+ * Default error message when API key is missing
+ */
+exports.API_KEY_MISSING_ERROR = "MESSARI_API_KEY is not configured.";
+/**
+ * Rate limits by subscription tier
+ */
+exports.RATE_LIMITS = {
+    FREE: "2 requests per day",
+    LITE: "10 requests per day",
+    PRO: "20 requests per day",
+    ENTERPRISE: "50 requests per day",
+};

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

@@ -0,0 +1,5 @@
+export * from "./messariActionProvider";
+export * from "./schemas";
+export * from "./types";
+export * from "./constants";
+export * from "./utils";

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

@@ -0,0 +1,21 @@
+"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("./messariActionProvider"), exports);
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./utils"), exports);

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

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { MessariResearchQuestionSchema } from "./schemas";
+import { MessariActionProviderConfig } from "./types";
+/**
+ * MessariActionProvider is an action provider for Messari AI toolkit interactions.
+ * It enables AI agents to ask research questions about crypto markets, protocols, and tokens.
+ *
+ * @augments ActionProvider
+ */
+export declare class MessariActionProvider extends ActionProvider {
+    private readonly apiKey;
+    /**
+     * Constructor for the MessariActionProvider class.
+     *
+     * @param config - The configuration options for the MessariActionProvider
+     */
+    constructor(config?: MessariActionProviderConfig);
+    /**
+     * Makes a request to the Messari AI API with a research question
+     *
+     * @param args - The arguments containing the research question
+     * @returns A string containing the research results or an error message
+     */
+    researchQuestion(args: z.infer<typeof MessariResearchQuestionSchema>): Promise<string>;
+    /**
+     * Checks if the action provider supports the given network.
+     * Messari research is network-agnostic, so it supports all networks.
+     *
+     * @param _ - The network to check
+     * @returns Always returns true as Messari research is network-agnostic
+     */
+    supportsNetwork(_: Network): boolean;
+}
+/**
+ * Factory function to create a new MessariActionProvider instance.
+ *
+ * @param config - The configuration options for the MessariActionProvider
+ * @returns A new instance of MessariActionProvider
+ */
+export declare const messariActionProvider: (config?: MessariActionProviderConfig) => MessariActionProvider;

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

@@ -0,0 +1,128 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messariActionProvider = exports.MessariActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+/**
+ * MessariActionProvider is an action provider for Messari AI toolkit interactions.
+ * It enables AI agents to ask research questions about crypto markets, protocols, and tokens.
+ *
+ * @augments ActionProvider
+ */
+class MessariActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the MessariActionProvider class.
+     *
+     * @param config - The configuration options for the MessariActionProvider
+     */
+    constructor(config = {}) {
+        super("messari", []);
+        config.apiKey || (config.apiKey = process.env.MESSARI_API_KEY);
+        if (!config.apiKey) {
+            throw new Error(constants_1.API_KEY_MISSING_ERROR);
+        }
+        this.apiKey = config.apiKey;
+    }
+    /**
+     * Makes a request to the Messari AI API with a research question
+     *
+     * @param args - The arguments containing the research question
+     * @returns A string containing the research results or an error message
+     */
+    async researchQuestion(args) {
+        try {
+            // Make API request
+            const response = await fetch(`${constants_1.MESSARI_BASE_URL}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-messari-api-key": this.apiKey,
+                },
+                body: JSON.stringify({
+                    messages: [
+                        {
+                            role: "user",
+                            content: args.question,
+                        },
+                    ],
+                }),
+            });
+            if (!response.ok) {
+                throw await (0, utils_1.createMessariError)(response);
+            }
+            // Parse and validate response
+            let data;
+            try {
+                data = (await response.json());
+            }
+            catch (jsonError) {
+                throw new Error(`Failed to parse API response: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`);
+            }
+            if (!data.data?.messages?.[0]?.content) {
+                throw new Error("Received invalid response format from Messari API");
+            }
+            const result = data.data.messages[0].content;
+            return `Messari Research Results:\n\n${result}`;
+        }
+        catch (error) {
+            if (error instanceof Error && "responseText" in error) {
+                return (0, utils_1.formatMessariApiError)(error);
+            }
+            return (0, utils_1.formatGenericError)(error);
+        }
+    }
+    /**
+     * Checks if the action provider supports the given network.
+     * Messari research is network-agnostic, so it supports all networks.
+     *
+     * @param _ - The network to check
+     * @returns Always returns true as Messari research is network-agnostic
+     */
+    supportsNetwork(_) {
+        return true; // Messari research is network-agnostic
+    }
+}
+exports.MessariActionProvider = MessariActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "research_question",
+        description: `
+This tool queries Messari AI for comprehensive crypto research across these datasets:
+1. News/Content - Latest crypto news, blogs, podcasts
+2. Exchanges - CEX/DEX volumes, market share, assets listed
+3. Onchain Data - Active addresses, transaction fees, total transactions.
+4. Token Unlocks - Upcoming supply unlocks, vesting schedules, and token emission details
+5. Market Data - Asset prices, trading volume, market cap, TVL, and historical performance
+6. Fundraising - Investment data, funding rounds, venture capital activity.
+7. Protocol Research - Technical analysis of how protocols work, tokenomics, and yield mechanisms
+8. Social Data - Twitter followers and Reddit subscribers metrics, growth trends
+
+Examples: "Which DEXs have the highest trading volume this month?", "When is Arbitrum's next major token unlock?", "How does Morpho generate yield for users?", "Which cryptocurrency has gained the most Twitter followers in 2023?", "What did Vitalik Buterin say about rollups in his recent blog posts?"
+    `,
+        schema: schemas_1.MessariResearchQuestionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], MessariActionProvider.prototype, "researchQuestion", null);
+/**
+ * Factory function to create a new MessariActionProvider instance.
+ *
+ * @param config - The configuration options for the MessariActionProvider
+ * @returns A new instance of MessariActionProvider
+ */
+const messariActionProvider = (config = {}) => new MessariActionProvider(config);
+exports.messariActionProvider = messariActionProvider;

package/dist/action-providers/messari/messariActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};