@coinbase/agentkit 0.2.3 → 0.4.0

package/dist/action-providers/defillama/defillamaActionProvider.js

@@ -0,0 +1,180 @@
+"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.defillamaActionProvider = exports.DefiLlamaActionProvider = 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");
+/**
+ * DefiLlamaActionProvider is an action provider for DefiLlama API interactions.
+ * Provides functionality to fetch token prices, protocol information, and search protocols.
+ */
+class DefiLlamaActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the DefiLlamaActionProvider class.
+     */
+    constructor() {
+        super("defillama", []);
+    }
+    /**
+     * Searches for protocols on DefiLlama.
+     * Note: This performs a case-insensitive search on protocol names.
+     * Returns all protocols whose names contain the search query.
+     *
+     * @param args - The protocol search parameters
+     * @returns A JSON string containing matching protocols or error message
+     */
+    async searchProtocols(args) {
+        try {
+            const url = `${constants_1.DEFILLAMA_BASE_URL}/protocols`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const protocols = await response.json();
+            const searchResults = protocols.filter((protocol) => protocol.name.toLowerCase().includes(args.query.toLowerCase()));
+            if (searchResults.length === 0) {
+                return `No protocols found matching "${args.query}"`;
+            }
+            return JSON.stringify(searchResults, null, 2);
+        }
+        catch (error) {
+            return `Error searching protocols: ${error}`;
+        }
+    }
+    /**
+     * Gets detailed information about a specific protocol.
+     * Note: Returns null if the protocol is not found.
+     * The response includes TVL, description, category, and other metadata.
+     * Time-series data is pruned to keep response size manageable.
+     *
+     * @param args - The protocol request parameters
+     * @returns A JSON string containing time-series pruned protocol information
+     */
+    async getProtocol(args) {
+        try {
+            const url = `${constants_1.DEFILLAMA_BASE_URL}/protocol/${args.protocolId}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            const prunedData = (0, utils_1.pruneGetProtocolResponse)(data);
+            return JSON.stringify(prunedData, null, 2);
+        }
+        catch (error) {
+            return `Error fetching protocol information: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /**
+     * Gets current token prices from DefiLlama.
+     * Note: Token addresses must include chain prefix (e.g., 'ethereum:0x...')
+     * The searchWidth parameter can be used to specify a time range in minutes.
+     *
+     * @param args - The token price request parameters
+     * @returns A JSON string containing token prices or error message
+     */
+    async getTokenPrices(args) {
+        try {
+            const params = new URLSearchParams({});
+            const tokens = args.tokens.join(",");
+            if (args.searchWidth) {
+                params.set("searchWidth", args.searchWidth);
+            }
+            const url = `${constants_1.DEFILLAMA_PRICES_URL}/prices/current/${tokens}?${params.toString()}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            return JSON.stringify(data, null, 2);
+        }
+        catch (error) {
+            return `Error fetching token prices: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /**
+     * Checks if the DefiLlama action provider supports the given network.
+     * DefiLlama is network-agnostic, so this always returns true.
+     *
+     * @returns True, as DefiLlama actions are supported on all networks.
+     */
+    supportsNetwork() {
+        return true;
+    }
+}
+exports.DefiLlamaActionProvider = DefiLlamaActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "find_protocol",
+        description: `This tool will search for DeFi protocols on DefiLlama by name.
+It takes the following inputs:
+- A search query string to match against protocol names
+
+Important notes:
+- The search is case-insensitive
+- Returns all protocols whose names contain the search query
+- Returns metadata including TVL, chain, category, and other protocol details
+- Returns a "No protocols found" message if no matches are found`,
+        schema: schemas_1.SearchProtocolsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], DefiLlamaActionProvider.prototype, "searchProtocols", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_protocol",
+        description: `This tool will fetch detailed information about a specific protocol from DefiLlama.
+It takes the following inputs:
+- The protocol identifier from DefiLlama (e.g. uniswap)
+
+Important notes:
+- Returns null if the protocol is not found
+- Returns comprehensive data including TVL, description, category, and other metadata
+- Includes historical TVL data and chain-specific breakdowns where available
+- Returns error message if the protocol ID is invalid or the request fails
+- Prunes time-series data to 5 most recent entries to make the response more manageable`,
+        schema: schemas_1.GetProtocolSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], DefiLlamaActionProvider.prototype, "getProtocol", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_token_prices",
+        description: `This tool will fetch current token prices from DefiLlama.
+It takes the following inputs:
+- An array of token addresses with chain prefixes
+- Optional time range in minutes for historical prices
+
+Important notes:
+- Token addresses MUST include chain prefix (e.g., 'ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
+- The searchWidth parameter is optional, it's default api value is '4h', leave this blank if unspecified
+- Returns current prices for all specified tokens
+- Returns error message if any token address is invalid or the request fails`,
+        schema: schemas_1.GetTokenPricesSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], DefiLlamaActionProvider.prototype, "getTokenPrices", null);
+/**
+ * Creates a new instance of the DefiLlama action provider.
+ *
+ * @returns A new DefiLlamaActionProvider instance
+ */
+const defillamaActionProvider = () => new DefiLlamaActionProvider();
+exports.defillamaActionProvider = defillamaActionProvider;

package/dist/action-providers/defillama/defillamaActionProvider.test.d.ts

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

package/dist/action-providers/defillama/defillamaActionProvider.test.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const defillamaActionProvider_1 = require("./defillamaActionProvider");
+describe("DefiLlamaActionProvider", () => {
+    const fetchMock = jest.fn();
+    global.fetch = fetchMock;
+    const provider = (0, defillamaActionProvider_1.defillamaActionProvider)();
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+    describe("getTokenPrices", () => {
+        it("should return token prices when API call is successful", async () => {
+            const mockResponse = {
+                "ethereum:0x1234": { price: 1800 },
+            };
+            fetchMock.mockResolvedValue({ ok: true, json: jest.fn().mockResolvedValue(mockResponse) });
+            const result = await provider.getTokenPrices({
+                tokens: ["ethereum:0x1234"],
+            });
+            expect(JSON.parse(result)).toEqual(mockResponse);
+        });
+        it("should handle API errors gracefully", async () => {
+            fetchMock.mockResolvedValue({ ok: false, status: 404 });
+            const result = await provider.getTokenPrices({
+                tokens: ["ethereum:0x1234"],
+            });
+            expect(result).toContain("Error fetching token prices");
+        });
+        it("should handle network errors", async () => {
+            const error = new Error("Network error");
+            fetchMock.mockRejectedValue(error);
+            const result = await provider.getTokenPrices({
+                tokens: ["ethereum:0x1234"],
+            });
+            expect(result).toContain("Error fetching token prices");
+            expect(result).toContain("Network error");
+        });
+    });
+    describe("getProtocol", () => {
+        const mockProtocol = {
+            name: "Uniswap",
+            symbol: "UNI",
+            description: "Decentralized exchange protocol",
+            category: "DEX",
+            chain: "Ethereum",
+            tvl: 1000000,
+            url: "https://uniswap.org",
+            logo: "https://example.com/logo.png",
+        };
+        it("should return protocol information when API call is successful", async () => {
+            fetchMock.mockResolvedValue({ ok: true, json: jest.fn().mockResolvedValue(mockProtocol) });
+            const result = await provider.getProtocol({ protocolId: "uniswap" });
+            expect(JSON.parse(result)).toEqual(mockProtocol);
+        });
+        it("should handle API errors gracefully", async () => {
+            fetchMock.mockResolvedValue({ ok: false, status: 500 });
+            const result = await provider.getProtocol({ protocolId: "invalid-protocol" });
+            expect(result).toContain("Error fetching protocol information");
+            expect(result).toContain("500");
+        });
+        it("should handle empty response", async () => {
+            fetchMock.mockResolvedValue({ ok: true, json: jest.fn().mockResolvedValue(null) });
+            const result = await provider.getProtocol({ protocolId: "non-existent" });
+            expect(JSON.parse(result)).toEqual(null);
+        });
+    });
+    describe("searchProtocols", () => {
+        const mockProtocols = [
+            {
+                name: "Uniswap",
+                symbol: "UNI",
+                category: "DEX",
+                chain: "Ethereum",
+                tvl: 1000000,
+            },
+            {
+                name: "UniswapV3",
+                symbol: "UNI",
+                category: "DEX",
+                chain: "Ethereum",
+                tvl: 2000000,
+            },
+        ];
+        it("should return matching protocols", async () => {
+            fetchMock.mockResolvedValue({ ok: true, json: jest.fn().mockResolvedValue(mockProtocols) });
+            const result = await provider.searchProtocols({ query: "uniswap" });
+            expect(JSON.parse(result)).toEqual(mockProtocols);
+        });
+        it("should handle API errors gracefully", async () => {
+            fetchMock.mockResolvedValue({ ok: false, status: 429 });
+            const result = await provider.searchProtocols({ query: "uniswap" });
+            expect(result).toContain("Error searching protocols");
+            expect(result).toContain("429");
+        });
+        it("should handle empty search results", async () => {
+            fetchMock.mockResolvedValue({ ok: true, json: jest.fn().mockResolvedValue([]) });
+            const result = await provider.searchProtocols({ query: "nonexistentprotocol" });
+            expect(result).toContain('No protocols found matching "nonexistentprotocol"');
+        });
+        it("should handle malformed response", async () => {
+            fetchMock.mockResolvedValue({
+                ok: true,
+                json: jest.fn().mockResolvedValue({ invalid: "response" }),
+            });
+            const result = await provider.searchProtocols({ query: "uniswap" });
+            expect(result).toContain("Error searching protocols");
+        });
+        it("should filter protocols case-insensitively", async () => {
+            fetchMock.mockResolvedValue({ ok: true, json: jest.fn().mockResolvedValue(mockProtocols) });
+            const result = await provider.searchProtocols({ query: "UNISWAP" });
+            expect(JSON.parse(result)).toEqual(mockProtocols);
+        });
+    });
+});

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

@@ -0,0 +1 @@
+export * from "./defillamaActionProvider";

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

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

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

@@ -0,0 +1,34 @@
+import { z } from "zod";
+/**
+ * Input schema for getting protocol information
+ */
+export declare const GetProtocolSchema: z.ZodObject<{
+    protocolId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    protocolId: string;
+}, {
+    protocolId: string;
+}>;
+/**
+ * Input schema for getting token prices
+ */
+export declare const GetTokenPricesSchema: z.ZodObject<{
+    tokens: z.ZodArray<z.ZodString, "many">;
+    searchWidth: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    tokens: string[];
+    searchWidth?: string | undefined;
+}, {
+    tokens: string[];
+    searchWidth?: string | undefined;
+}>;
+/**
+ * Input schema for searching protocols
+ */
+export declare const SearchProtocolsSchema: z.ZodObject<{
+    query: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchProtocolsSchema = exports.GetTokenPricesSchema = exports.GetProtocolSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for getting protocol information
+ */
+exports.GetProtocolSchema = zod_1.z
+    .object({
+    protocolId: zod_1.z.string().describe("The protocol identifier from DefiLlama"),
+})
+    .strict();
+/**
+ * Input schema for getting token prices
+ */
+exports.GetTokenPricesSchema = zod_1.z
+    .object({
+    tokens: zod_1.z
+        .array(zod_1.z.string())
+        .describe("Array of token addresses with chain prefix, e.g., ['ethereum:0x...']"),
+    searchWidth: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional time range in minutes to search for prices, default api value is '4h'"),
+})
+    .strict();
+/**
+ * Input schema for searching protocols
+ */
+exports.SearchProtocolsSchema = zod_1.z
+    .object({
+    query: zod_1.z.string().describe("Search query to find protocols"),
+})
+    .strict();

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

@@ -0,0 +1,73 @@
+/**
+ * Interface representing a DeFi protocol from DefiLlama
+ */
+export interface Protocol {
+    name: string;
+    address?: string;
+    symbol?: string;
+    url?: string;
+    description?: string;
+    chain?: string;
+    logo?: string;
+    audits?: string;
+    category?: string;
+    tvl?: number;
+}
+/**
+ * Interface representing a time-series data point with a date
+ */
+export interface TimeSeriesDataPoint {
+    date: number;
+    totalLiquidityUSD: number;
+}
+/**
+ * Interface representing a time-series data point with tokens
+ */
+export interface TokenTimeSeriesDataPoint {
+    date: number;
+    tokens: Record<string, number>;
+}
+/**
+ * Type for representing generic metadata values that can be returned by DefiLlama API
+ */
+export type MetadataValue = string | number | boolean | null | Record<string, unknown> | unknown[];
+/**
+ * Interface representing DefiLlama protocol response
+ */
+export interface ProtocolResponse {
+    id: string;
+    name: string;
+    address?: string;
+    symbol?: string;
+    url?: string;
+    description?: string;
+    chain?: string;
+    logo?: string;
+    audits?: string;
+    audit_note?: string | null;
+    gecko_id?: string | null;
+    cmcId?: string | null;
+    category?: string;
+    chains?: string[];
+    oracles?: string[];
+    forkedFrom?: string[];
+    audit_links?: string[];
+    github?: string[];
+    tvl?: TimeSeriesDataPoint[];
+    tokensInUsd?: TokenTimeSeriesDataPoint[];
+    tokens?: TokenTimeSeriesDataPoint[];
+    chainTvls?: Record<string, {
+        tvl?: TimeSeriesDataPoint[];
+        tokensInUsd?: TokenTimeSeriesDataPoint[];
+        tokens?: TokenTimeSeriesDataPoint[];
+    }>;
+    currentChainTvls?: Record<string, number>;
+    raises?: Record<string, MetadataValue>[];
+    metrics?: Record<string, MetadataValue>;
+    mcap?: number;
+    methodology?: string;
+}
+/**
+ * Type for the pruned protocol response - same structure as the input
+ */
+export type PrunedProtocolResponse = ProtocolResponse;

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

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

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

@@ -0,0 +1,10 @@
+import { ProtocolResponse, PrunedProtocolResponse } from "./types";
+/**
+ * Prunes the protocol response by limiting time-series data arrays
+ * to show only the most recent entries.
+ *
+ * @param data - The original protocol data from DefiLlama API
+ * @param maxEntries - The maximum number of time-series entries to keep (default: 5)
+ * @returns A pruned copy of the protocol data
+ */
+export declare const pruneGetProtocolResponse: (data: ProtocolResponse | null, maxEntries?: number) => PrunedProtocolResponse | null;

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneGetProtocolResponse = void 0;
+/**
+ * Processes a time-series array by sorting by date (newest first) and limiting to maxEntries
+ *
+ * @param array - The time-series array to process
+ * @param maxEntries - Maximum number of entries to keep
+ * @returns The processed array (sorted and limited)
+ */
+const processTimeSeriesArray = (array, maxEntries) => {
+    if (array.length <= maxEntries) {
+        return array;
+    }
+    // Sort by date if array items have date property
+    if (array.length > 0 && typeof array[0] === "object" && array[0] !== null && "date" in array[0]) {
+        array.sort((a, b) => {
+            if (a &&
+                b &&
+                typeof a === "object" &&
+                typeof b === "object" &&
+                "date" in a &&
+                "date" in b &&
+                typeof a.date === "number" &&
+                typeof b.date === "number") {
+                return b.date - a.date;
+            }
+            return 0;
+        });
+    }
+    return array.slice(0, maxEntries);
+};
+/**
+ * Prunes the protocol response by limiting time-series data arrays
+ * to show only the most recent entries.
+ *
+ * @param data - The original protocol data from DefiLlama API
+ * @param maxEntries - The maximum number of time-series entries to keep (default: 5)
+ * @returns A pruned copy of the protocol data
+ */
+const pruneGetProtocolResponse = (data, maxEntries = 5) => {
+    if (!data) {
+        return null;
+    }
+    const result = { ...data };
+    const timeSeriesArrayPaths = ["tvl", "tokens", "tokensInUsd"];
+    const processNestedObject = (obj, currentPath = "") => {
+        if (!obj || typeof obj !== "object") {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            const isTimeSeriesArray = timeSeriesArrayPaths.some(path => currentPath === path || currentPath.endsWith(`.${path}`));
+            if (isTimeSeriesArray) {
+                return processTimeSeriesArray(obj, maxEntries);
+            }
+            for (let i = 0; i < obj.length; i++) {
+                obj[i] = processNestedObject(obj[i], `${currentPath}[${i}]`);
+            }
+        }
+        else if (obj !== null) {
+            // Safe to cast to Record<string, unknown> since we know it's an object and not null
+            const record = obj;
+            for (const key of Object.keys(record)) {
+                const newPath = currentPath ? `${currentPath}.${key}` : key;
+                const value = record[key];
+                if (value && typeof value === "object") {
+                    record[key] = processNestedObject(value, newPath);
+                }
+            }
+        }
+        return obj;
+    };
+    // Special handling for chainTvls if it exists
+    if (result.chainTvls) {
+        for (const chain of Object.keys(result.chainTvls)) {
+            const chainData = result.chainTvls[chain];
+            for (const timeSeriesKey of timeSeriesArrayPaths) {
+                if (chainData[timeSeriesKey] && Array.isArray(chainData[timeSeriesKey])) {
+                    chainData[timeSeriesKey] = processTimeSeriesArray(chainData[timeSeriesKey], maxEntries);
+                }
+            }
+        }
+    }
+    processNestedObject(result);
+    return result;
+};
+exports.pruneGetProtocolResponse = pruneGetProtocolResponse;

package/dist/action-providers/defillama/utils.test.d.ts

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