@coinbase/agentkit 0.3.0 → 0.4.0

package/README.md

@@ -192,6 +192,23 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>DefiLlama</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>find_protocol</code></td>
+    <td width="768">Searches for DeFi protocols on DefiLlama by name, returning protocol metadata including TVL, chain, and category.</td>
+</tr>
+<tr>
+    <td width="200"><code>get_protocol</code></td>
+    <td width="768">Fetches detailed information about a specific protocol from DefiLlama, including TVL, description, and historical data.</td>
+</tr>
+<tr>
+    <td width="200"><code>get_token_prices</code></td>
+    <td width="768">Fetches current token prices from DefiLlama for specified token addresses with chain prefixes.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>ERC20</strong></summary>
 <table width="100%">
 <tr>

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

@@ -0,0 +1,8 @@
+/**
+ * Base URL for the DefiLlama API
+ */
+export declare const DEFILLAMA_BASE_URL = "https://api.llama.fi";
+/**
+ * URL for the DefiLlama price API
+ */
+export declare const DEFILLAMA_PRICES_URL = "https://coins.llama.fi";

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFILLAMA_PRICES_URL = exports.DEFILLAMA_BASE_URL = void 0;
+/**
+ * Base URL for the DefiLlama API
+ */
+exports.DEFILLAMA_BASE_URL = "https://api.llama.fi";
+/**
+ * URL for the DefiLlama price API
+ */
+exports.DEFILLAMA_PRICES_URL = "https://coins.llama.fi";

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

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { GetTokenPricesSchema, GetProtocolSchema, SearchProtocolsSchema } from "./schemas";
+/**
+ * DefiLlamaActionProvider is an action provider for DefiLlama API interactions.
+ * Provides functionality to fetch token prices, protocol information, and search protocols.
+ */
+export declare class DefiLlamaActionProvider extends ActionProvider {
+    /**
+     * Constructor for the DefiLlamaActionProvider class.
+     */
+    constructor();
+    /**
+     * 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
+     */
+    searchProtocols(args: z.infer<typeof SearchProtocolsSchema>): Promise<string>;
+    /**
+     * 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
+     */
+    getProtocol(args: z.infer<typeof GetProtocolSchema>): Promise<string>;
+    /**
+     * 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
+     */
+    getTokenPrices(args: z.infer<typeof GetTokenPricesSchema>): Promise<string>;
+    /**
+     * 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(): boolean;
+}
+/**
+ * Creates a new instance of the DefiLlama action provider.
+ *
+ * @returns A new DefiLlamaActionProvider instance
+ */
+export declare const defillamaActionProvider: () => DefiLlamaActionProvider;

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

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+describe("DefiLlama Utilities", () => {
+    describe("pruneGetProtocolResponse", () => {
+        it("should handle null input", () => {
+            expect((0, utils_1.pruneGetProtocolResponse)(null)).toBeNull();
+        });
+        it("should not modify objects without time-series data", () => {
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                symbol: "ABC",
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input);
+            expect(result).not.toBeNull();
+            expect(result).toEqual(input);
+        });
+        it("should prune time-series arrays", () => {
+            const timeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...timeSeriesData],
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 5);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.name).toBe("Protocol");
+                expect(result.tvl).toHaveLength(5);
+                const resultDates = result.tvl.map(entry => entry.date);
+                const sortedDates = [...resultDates].sort((a, b) => b - a);
+                expect(resultDates).toEqual(sortedDates);
+            }
+        });
+        it("should prune nested time-series arrays in chainTvls", () => {
+            const timeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const tokenTimeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                tokens: { ETH: 1000 + i },
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                chainTvls: {
+                    Ethereum: {
+                        tvl: [...timeSeriesData],
+                        tokens: [...tokenTimeSeriesData],
+                    },
+                    Polygon: {
+                        tvl: [...timeSeriesData],
+                        tokensInUsd: [...tokenTimeSeriesData],
+                    },
+                },
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 3);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.name).toBe("Protocol");
+                expect(result.chainTvls).toBeDefined();
+                if (result.chainTvls) {
+                    expect(result.chainTvls.Ethereum.tvl).toHaveLength(3);
+                    expect(result.chainTvls.Ethereum.tokens).toHaveLength(3);
+                    expect(result.chainTvls.Polygon.tvl).toHaveLength(3);
+                    expect(result.chainTvls.Polygon.tokensInUsd).toHaveLength(3);
+                    const ethereumTvlDates = result.chainTvls.Ethereum.tvl.map(entry => entry.date);
+                    const sortedDates = [...ethereumTvlDates].sort((a, b) => b - a);
+                    expect(ethereumTvlDates).toEqual(sortedDates);
+                }
+            }
+        });
+        it("should respect the maxEntries parameter", () => {
+            const timeSeriesData = Array.from({ length: 50 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const tokenTimeSeriesData = Array.from({ length: 50 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                tokens: { ETH: 1000 + i },
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...timeSeriesData],
+                tokens: [...tokenTimeSeriesData],
+            };
+            const result1 = (0, utils_1.pruneGetProtocolResponse)(input, 1);
+            expect(result1).not.toBeNull();
+            if (result1) {
+                expect(result1.tvl).toHaveLength(1);
+                expect(result1.tokens).toHaveLength(1);
+            }
+            const result10 = (0, utils_1.pruneGetProtocolResponse)(input, 10);
+            expect(result10).not.toBeNull();
+            if (result10) {
+                expect(result10.tvl).toHaveLength(10);
+                expect(result10.tokens).toHaveLength(10);
+            }
+        });
+        it("should handle arrays without date property", () => {
+            const nonDateArray = Array.from({ length: 20 }, (_, i) => ({
+                value: 1000 + i,
+                name: `Item ${i}`,
+            }));
+            // Using a type assertion for this test case as it's testing a specific behavior
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...nonDateArray],
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 5);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.tvl).toHaveLength(5);
+            }
+        });
+    });
+});

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

@@ -5,6 +5,7 @@ export * from "./alchemy";
 export * from "./basename";
 export * from "./cdp";
 export * from "./compound";
+export * from "./defillama";
 export * from "./erc20";
 export * from "./erc721";
 export * from "./farcaster";

package/dist/action-providers/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./alchemy"), exports);
 __exportStar(require("./basename"), exports);
 __exportStar(require("./cdp"), exports);
 __exportStar(require("./compound"), exports);
+__exportStar(require("./defillama"), exports);
 __exportStar(require("./erc20"), exports);
 __exportStar(require("./erc721"), exports);
 __exportStar(require("./farcaster"), exports);

package/dist/action-providers/morpho/morphoActionProvider.js

@@ -13,11 +13,12 @@ exports.morphoActionProvider = exports.MorphoActionProvider = exports.SUPPORTED_
 const zod_1 = require("zod");
 const decimal_js_1 = require("decimal.js");
 const viem_1 = require("viem");
+const constants_1 = require("../erc20/constants");
 const actionProvider_1 = require("../actionProvider");
 const wallet_providers_1 = require("../../wallet-providers");
 const actionDecorator_1 = require("../actionDecorator");
 const utils_1 = require("../../utils");
-const constants_1 = require("./constants");
+const constants_2 = require("./constants");
 const schemas_1 = require("./schemas");
 exports.SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
 /**
@@ -50,13 +51,19 @@ class MorphoActionProvider extends actionProvider_1.ActionProvider {
             return "Error: Assets amount must be greater than 0";
         }
         try {
-            const atomicAssets = (0, viem_1.parseEther)(args.assets);
+            const decimals = await wallet.readContract({
+                address: args.tokenAddress,
+                abi: constants_1.abi,
+                functionName: "decimals",
+                args: [],
+            });
+            const atomicAssets = (0, viem_1.parseUnits)(args.assets, decimals);
             const approvalResult = await (0, utils_1.approve)(wallet, args.tokenAddress, args.vaultAddress, atomicAssets);
             if (approvalResult.startsWith("Error")) {
                 return `Error approving Morpho Vault as spender: ${approvalResult}`;
             }
             const data = (0, viem_1.encodeFunctionData)({
-                abi: constants_1.METAMORPHO_ABI,
+                abi: constants_2.METAMORPHO_ABI,
                 functionName: "deposit",
                 args: [atomicAssets, args.receiver],
             });
@@ -84,7 +91,7 @@ class MorphoActionProvider extends actionProvider_1.ActionProvider {
         }
         try {
             const data = (0, viem_1.encodeFunctionData)({
-                abi: constants_1.METAMORPHO_ABI,
+                abi: constants_2.METAMORPHO_ABI,
                 functionName: "withdraw",
                 args: [BigInt(args.assets), args.receiver, args.receiver],
             });

package/dist/action-providers/morpho/morphoActionProvider.test.js

@@ -11,6 +11,7 @@ const MOCK_RECEIVER_ID = "0x9876543210987654321098765432109876543210";
 const MOCK_TOKEN_ADDRESS = "0x4200000000000000000000000000000000000006";
 const MOCK_TX_HASH = "0xabcdef1234567890";
 const MOCK_RECEIPT = { status: 1, blockNumber: 1234567 };
+const MOCK_DECIMALS = 18;
 jest.mock("../../utils");
 const mockApprove = utils_1.approve;
 describe("Morpho Action Provider", () => {
@@ -22,6 +23,7 @@ describe("Morpho Action Provider", () => {
             getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId: "1" }),
             sendTransaction: jest.fn().mockResolvedValue(MOCK_TX_HASH),
             waitForTransactionReceipt: jest.fn().mockResolvedValue(MOCK_RECEIPT),
+            readContract: jest.fn().mockResolvedValue(MOCK_DECIMALS),
         };
         mockApprove.mockResolvedValue("Approval successful");
     });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",