@coinbase/agentkit 0.8.0 → 0.8.2

package/dist/action-providers/vaultsfyi/vaultsfyiActionProvider.js

@@ -27,6 +27,7 @@ const utils_1 = require("./utils");
 const constants_1 = require("./constants");
 const actions_1 = require("./api/actions");
 const vaults_1 = require("./api/vaults");
+const historicalData_1 = require("./api/historicalData");
 /**
  * VaultsfyiActionProvider provides actions for vaultsfyi operations.
  *
@@ -52,10 +53,11 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
      * vaults action
      *
      * @param wallet - The wallet provider instance for blockchain interactions
-     * @param args - Input arguments: token, network, transactionalOnly...
+     * @param args - Input arguments: token, network...
      * @returns A list of vaults.
      */
     async vaults(wallet, args) {
+        const apyRange = args.apyRange ?? "7day";
         const vaults = await (0, vaults_1.fetchVaults)(args, this.apiKey);
         if ("error" in vaults) {
             return `Failed to fetch vaults: ${vaults.error}, ${vaults.message}`;
@@ -66,24 +68,7 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
                 .filter((value, index, self) => self.indexOf(value) === index);
             return `Protocol ${args.protocol} is not supported. Supported protocols are: ${supportedProtocols.join(", ")}`;
         }
-        const transformedVaults = vaults.map(vault => ({
-            name: vault.name,
-            address: vault.address,
-            network: vault.network,
-            protocol: vault.protocol,
-            tvlInUsd: Number(vault.tvlDetails.tvlUsd),
-            apy: {
-                base: vault.apy.base["7day"] / 100,
-                rewards: vault.apy.rewards?.["7day"] ? vault.apy.rewards["7day"] / 100 : undefined,
-                total: vault.apy.total["7day"] / 100,
-            },
-            token: {
-                address: vault.token.assetAddress,
-                name: vault.token.name,
-                symbol: vault.token.symbol,
-            },
-            link: (0, utils_1.getVaultsLink)(vault),
-        }));
+        const transformedVaults = vaults.map(vault => (0, utils_1.transformVault)(vault, apyRange));
         const filteredVaults = transformedVaults.filter(vault => args.protocol ? vault.protocol === args.protocol : true);
         const sortedVaults = filteredVaults.sort((a, b) => {
             if (args.sort?.field === "tvl") {
@@ -107,6 +92,49 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
             results,
         });
     }
+    /**
+     * vault details action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: address, network, apyRange
+     * @returns A detailed view of a single vault.
+     */
+    async vaultDetails(wallet, args) {
+        const vault = await (0, vaults_1.fetchVault)(args, this.apiKey);
+        if ("error" in vault) {
+            return `Failed to fetch vault: ${vault.error}, ${vault.message}`;
+        }
+        return JSON.stringify((0, utils_1.transformDetailedVault)(vault, args.apyRange ?? "7day"));
+    }
+    /**
+     * vault historical data action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: address, network, date, apyRange
+     * @returns A detailed view of a single vault.
+     */
+    async vaultHistoricalData(wallet, args) {
+        const data = await (0, historicalData_1.fetchVaultHistoricalData)(args, this.apiKey);
+        if ("error" in data) {
+            return `Failed to fetch vault: ${data.error}, ${data.message}`;
+        }
+        return JSON.stringify({
+            apy: {
+                apy: {
+                    base: data.apy.apy.base / 100,
+                    rewards: data.apy.apy.rewards ? data.apy.apy.rewards / 100 : undefined,
+                    total: data.apy.apy.total / 100,
+                },
+                date: new Date(data.apy.timestamp * 1000).toISOString(),
+                blockNumber: data.apy.blockNumber,
+            },
+            tvl: {
+                tvlInUsd: data.tvl.tvlDetails.tvlUsd,
+                date: new Date(data.tvl.timestamp * 1000).toISOString(),
+                blockNumber: data.tvl.blockNumber,
+            },
+        });
+    }
     /**
      * Deposit action
      *
@@ -260,7 +288,7 @@ __decorate([
       This action returns a list of available vaults.
       Small vaults (under 100k TVL) are probably best avoided as they may be more risky. Unless the user is looking for high-risk, high-reward opportunities, don't include them.
       When the user asks for best vaults, optimize for apy, and if the user asks for safest/reliable vaults, optimize for TVL.
-      Try to take a reasonable number of results so its easier to analyze the data.
+      Try to take a reasonable number of results so its easier to analyze the data. Include vaults.fyi links for each vault.
       Format result apys as: x% (base: x%, rewards: x%) if rewards apy is available, otherwise: x%
       Examples:
       User: "Show me the best vaults"
@@ -275,6 +303,7 @@ __decorate([
       args: { network: 'polygon', sort: { field: 'apy', direction: 'desc' }, take: 5, minTvl: 0 }
       User: "Show me some more of those"
       args: { network: 'polygon', sort: { field: 'apy', direction: 'desc' }, take: 5, minTvl: 0, page: 2 }
+      All optional fields should be null if not specified.
     `,
         schema: schemas_1.VaultsActionSchema,
     }),
@@ -282,6 +311,44 @@ __decorate([
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], VaultsfyiActionProvider.prototype, "vaults", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "vault_details",
+        description: `
+      This action returns a more detailed view of a single vault. Additional details include:
+      - Description
+      - Additional incentives (points etc)
+      - Rewards breakdown
+      Params: 
+      - vaultAddress: The address of the vault to fetch details for
+      - network: The network of the vault
+      - apyRange: The APY moving average range (default: 7day)
+    `,
+        schema: schemas_1.VaultDetailsActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "vaultDetails", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "vault_historical_data",
+        description: `
+      This action returns a historical data of a vault. It returns the APY and TVL data closest to the given date.
+      Always check if the results date is close to the requested date, as the data may not be available for the exact date.
+      If there is a more than 7 day difference between the requested date and the resulting date, don't provide the data, but rather with a message explaining the missing data.
+      If the resulting date is a lot later than the requested date, the reason for missing data might be that the vault has not been deployed yet.
+      Example queries:
+      params: { vaultAddress: "0x1234567890abcdef1234567890abcdef12345678", network: "arbitrum", date: "2025-01-01T00:00:00Z" }
+      result: { ..., date: "2025-02-16T14:59:59.000Z" }
+      response: "The requested date was 2025-01-01T00:00:00Z, but the closest data available is from 2025-02-16T14:59:59.000Z. This may indicate that the vault was not deployed at the requested date."
+    `,
+        schema: schemas_1.VaultHistoricalDataActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "vaultHistoricalData", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "deposit",

package/dist/action-providers/vaultsfyi/vaultsfyiActionProvider.test.js

@@ -35,6 +35,30 @@ const mockVault = (num) => ({
                 "7day": num * 100,
             },
         },
+        numberOfHolders: num,
+        rewards: [
+            {
+                apy: {
+                    "7day": num * 100,
+                },
+                asset: {
+                    name: `reward-token-${num}`,
+                    symbol: `RT${num}`,
+                    assetAddress: `0x${num.toString(16).padStart(40, "0")}`,
+                    decimals: 18,
+                },
+            },
+        ],
+        description: `Description for vault-${num}`,
+        additionalIncentives: `Incentives for vault-${num}`,
+        score: {
+            vaultScore: num,
+            vaultTvlScore: num,
+            protocolTvlScore: num,
+            holderScore: num,
+            networkScore: num,
+            assetScore: num,
+        },
         isTransactional: true,
     },
     transformedResult: {
@@ -53,6 +77,8 @@ const mockVault = (num) => ({
             rewards: num,
             total: num,
         },
+        vaultsFyiScore: num,
+        numberOfHolders: num,
         link: `https://app.vaults.fyi/opportunity/network-${num}/0x${num.toString(16).padStart(40, "0")}`,
     },
 });
@@ -435,4 +461,143 @@ describe("VaultsfyiActionProvider", () => {
             expect(await provider.positions(mockWalletProvider)).toBe("Failed to fetch positions: Internal Server Error, some more info");
         });
     });
+    describe("vault_details action", () => {
+        it("should transform vault details correctly", async () => {
+            const detailedVault = mockVault(1);
+            mockedFetch.mockResolvedValue(mockFetchResult(200, detailedVault.apiResult));
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+            };
+            const result = await provider.vaultDetails(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toStrictEqual({
+                ...detailedVault.transformedResult,
+                description: detailedVault.apiResult.description,
+                additionalIncentives: detailedVault.apiResult.additionalIncentives,
+                rewards: [
+                    {
+                        apy: detailedVault.apiResult.rewards[0].apy["7day"] / 100,
+                        asset: {
+                            name: detailedVault.apiResult.rewards[0].asset.name,
+                            symbol: detailedVault.apiResult.rewards[0].asset.symbol,
+                            address: detailedVault.apiResult.rewards[0].asset.assetAddress,
+                        },
+                    },
+                ],
+            });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+            };
+            expect(await provider.vaultDetails(mockWalletProvider, args)).toBe("Failed to fetch vault: Internal Server Error, some more info");
+        });
+    });
+    describe("vault_historical_data action", () => {
+        it("should fetch and transform historical data correctly", async () => {
+            // Mock API responses for both TVL and APY data
+            const mockApyData = {
+                timestamp: 1704067200, // Jan 1, 2024
+                blockNumber: 12345678,
+                apy: {
+                    base: 500,
+                    rewards: 300,
+                    total: 800,
+                },
+            };
+            const mockTvlData = {
+                timestamp: 1704067200, // Jan 1, 2024
+                blockNumber: 12345678,
+                tvlDetails: {
+                    tvlUsd: 1000000,
+                },
+            };
+            // Set up the mock to return appropriate data for each call
+            mockedFetch.mockImplementation(url => {
+                if (url.includes("/historical-apy/")) {
+                    return Promise.resolve(mockFetchResult(200, mockApyData));
+                }
+                else if (url.includes("/historical-tvl/")) {
+                    return Promise.resolve(mockFetchResult(200, mockTvlData));
+                }
+                return Promise.resolve(mockFetchResult(500, { error: "Unexpected URL" }));
+            });
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+                date: "2024-01-01T00:00:00Z",
+            };
+            const result = await provider.vaultHistoricalData(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toEqual({
+                apy: {
+                    apy: {
+                        base: 5,
+                        rewards: 3,
+                        total: 8,
+                    },
+                    date: "2024-01-01T00:00:00.000Z",
+                    blockNumber: 12345678,
+                },
+                tvl: {
+                    tvlInUsd: 1000000,
+                    date: "2024-01-01T00:00:00.000Z",
+                    blockNumber: 12345678,
+                },
+            });
+        });
+        it("should return an error if the APY API request fails", async () => {
+            // Set up the mock to fail for APY but succeed for TVL
+            mockedFetch.mockImplementation(url => {
+                if (url.includes("/historical-apy/")) {
+                    return Promise.resolve(mockFetchResult(500, {
+                        error: "Internal Server Error",
+                        message: "Failed to get historical APY data",
+                    }));
+                }
+                else if (url.includes("/historical-tvl/")) {
+                    return Promise.resolve(mockFetchResult(200, {
+                        timestamp: 1704067200,
+                        blockNumber: 12345678,
+                        tvlDetails: { tvlUsd: 1000000 },
+                    }));
+                }
+                return Promise.resolve(mockFetchResult(500, { error: "Unexpected URL" }));
+            });
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+                date: "2024-01-01T00:00:00Z",
+            };
+            expect(await provider.vaultHistoricalData(mockWalletProvider, args)).toBe("Failed to fetch vault: Internal Server Error, Failed to get historical APY data");
+        });
+        it("should return an error if the TVL API request fails", async () => {
+            // Set up the mock to succeed for APY but fail for TVL
+            mockedFetch.mockImplementation(url => {
+                if (url.includes("/historical-apy/")) {
+                    return Promise.resolve(mockFetchResult(200, {
+                        timestamp: 1704067200,
+                        blockNumber: 12345678,
+                        apy: { base: 500, rewards: 300, total: 800 },
+                    }));
+                }
+                else if (url.includes("/historical-tvl/")) {
+                    return Promise.resolve(mockFetchResult(500, {
+                        error: "Internal Server Error",
+                        message: "Failed to get historical TVL data",
+                    }));
+                }
+                return Promise.resolve(mockFetchResult(500, { error: "Unexpected URL" }));
+            });
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+                date: "2024-01-01T00:00:00Z",
+            };
+            expect(await provider.vaultHistoricalData(mockWalletProvider, args)).toBe("Failed to fetch vault: Internal Server Error, Failed to get historical TVL data");
+        });
+    });
 });

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

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

package/dist/action-providers/x402/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("./x402ActionProvider"), exports);

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const PaidRequestSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH";
+    url: string;
+    body?: any;
+    headers?: Record<string, string> | undefined;
+}, {
+    url: string;
+    method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | undefined;
+    body?: any;
+    headers?: Record<string, string> | undefined;
+}>;
+export declare const FetchPaymentInfoSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH";
+    url: string;
+    headers?: Record<string, string> | undefined;
+}, {
+    url: string;
+    method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | undefined;
+    headers?: Record<string, string> | undefined;
+}>;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchPaymentInfoSchema = exports.PaidRequestSchema = void 0;
+const zod_1 = require("zod");
+exports.PaidRequestSchema = zod_1.z
+    .object({
+    url: zod_1.z.string().url().describe("The URL of the x402-protected API endpoint"),
+    method: zod_1.z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .default("GET")
+        .describe("The HTTP method to use for the request"),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe("Optional headers to include in the request"),
+    body: zod_1.z.any().optional().describe("Optional request body for POST/PUT/PATCH requests"),
+})
+    .strip()
+    .describe("Instructions for making a paid request to an x402-protected API");
+exports.FetchPaymentInfoSchema = zod_1.z
+    .object({
+    url: zod_1.z.string().url().describe("The URL of the x402-protected API endpoint"),
+    method: zod_1.z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .default("GET")
+        .describe("The HTTP method to use for the request"),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe("Optional headers to include in the request"),
+})
+    .strip()
+    .describe("Instructions for fetching payment information from an x402-protected API endpoint");

package/dist/action-providers/x402/x402ActionProvider.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { PaidRequestSchema, FetchPaymentInfoSchema } from "./schemas";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * X402ActionProvider is an action provider for making paid requests to x402-protected APIs.
+ */
+export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the X402ActionProvider.
+     */
+    constructor();
+    /**
+     * Makes a paid request to an x402-protected API endpoint.
+     *
+     * @param walletProvider - The wallet provider to use for payment signing.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the API response data.
+     */
+    paidRequest(walletProvider: EvmWalletProvider, args: z.infer<typeof PaidRequestSchema>): Promise<string>;
+    /**
+     * Fetches payment information from an x402-protected API endpoint without making the payment.
+     *
+     * @param walletProvider - The wallet provider (not used for this action but required by interface).
+     * @param args - The input arguments for the action.
+     * @returns A message containing the payment requirements and endpoint information.
+     */
+    fetchPaymentInfo(walletProvider: EvmWalletProvider, args: z.infer<typeof FetchPaymentInfoSchema>): Promise<string>;
+    /**
+     * Checks if the X402 action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the X402 action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const x402ActionProvider: () => X402ActionProvider;