@coinbase/agentkit 0.6.1 → 0.6.2

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

@@ -24,3 +24,4 @@ export * from "./wow";
 export * from "./allora";
 export * from "./flaunch";
 export * from "./onramp";
+export * from "./vaultsfyi";

package/dist/action-providers/index.js

@@ -40,3 +40,4 @@ __exportStar(require("./wow"), exports);
 __exportStar(require("./allora"), exports);
 __exportStar(require("./flaunch"), exports);
 __exportStar(require("./onramp"), exports);
+__exportStar(require("./vaultsfyi"), exports);

package/dist/action-providers/vaultsfyi/api/actions.d.ts

@@ -0,0 +1,41 @@
+import z from "zod";
+import { claimActionSchema, depositActionSchema, redeemActionSchema } from "../schemas";
+import { ApiError } from "./types";
+import { Address, Hex } from "viem";
+type FetchVaultActionsParams = ({
+    action: "deposit";
+    args: z.infer<typeof depositActionSchema>;
+} | {
+    action: "redeem";
+    args: z.infer<typeof redeemActionSchema>;
+} | {
+    action: "claim-rewards";
+    args: z.infer<typeof claimActionSchema>;
+}) & {
+    sender: string;
+    apiKey: string;
+};
+export type Actions = {
+    actions: {
+        tx: {
+            to: Address;
+            data: Hex;
+            value: string;
+            chainId: number;
+        };
+        description: string;
+    }[];
+    currentActionIndex: number;
+};
+/**
+ * Fetches a list of actions for a vault from the vaultsfyi API.
+ *
+ * @param root0 - The fetch parameters
+ * @param root0.action - The action to fetch
+ * @param root0.args - The action parameters
+ * @param root0.sender - The sender address
+ * @param root0.apiKey - The vaultsfyi API key
+ * @returns The list of actions
+ */
+export declare function fetchVaultActions({ action, args, sender, apiKey, }: FetchVaultActionsParams): Promise<Actions | ApiError>;
+export {};

package/dist/action-providers/vaultsfyi/api/actions.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVaultActions = fetchVaultActions;
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+/**
+ * Fetches a list of actions for a vault from the vaultsfyi API.
+ *
+ * @param root0 - The fetch parameters
+ * @param root0.action - The action to fetch
+ * @param root0.args - The action parameters
+ * @param root0.sender - The sender address
+ * @param root0.apiKey - The vaultsfyi API key
+ * @returns The list of actions
+ */
+async function fetchVaultActions({ action, args, sender, apiKey, }) {
+    const params = (0, utils_1.createSearchParams)({
+        ...args,
+        sender,
+    });
+    const response = await fetch(`${constants_1.VAULTS_API_URL}/transactions/vaults/${action}?${params}`, {
+        method: "GET",
+        headers: {
+            "x-api-key": apiKey,
+        },
+    });
+    return (await response.json());
+}

package/dist/action-providers/vaultsfyi/api/types.d.ts

@@ -0,0 +1,34 @@
+export type ApiError = {
+    statusCode: number;
+    error: string;
+    message: string;
+};
+export type Balances = {
+    [network: string]: {
+        address: string;
+        name: string;
+        symbol: string;
+        balance: string;
+        decimals: number;
+    }[];
+};
+export type Positions = {
+    [network: string]: {
+        vaultName: string;
+        vaultAddress: string;
+        asset: {
+            assetAddress: string;
+            name: string;
+            symbol: string;
+            decimals: number;
+        };
+        balanceNative: string;
+        balanceLp: string;
+        unclaimedUsd: string;
+        apy: {
+            base: number;
+            rewards: number;
+            total: number;
+        };
+    }[];
+};

package/dist/action-providers/vaultsfyi/api/types.js

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

package/dist/action-providers/vaultsfyi/api/vaults.d.ts

@@ -0,0 +1,38 @@
+import z from "zod";
+import { VaultsActionSchema } from "../schemas";
+import { ApiError } from "./types";
+export type ApiVault = {
+    name: string;
+    address: string;
+    network: string;
+    protocol: string;
+    tvlDetails: {
+        tvlUsd: string;
+    };
+    token: {
+        name: string;
+        assetAddress: string;
+        symbol: string;
+        decimals: number;
+    };
+    apy: {
+        base: {
+            "7day": number;
+        };
+        rewards: {
+            "7day": number;
+        };
+        total: {
+            "7day": number;
+        };
+    };
+    isTransactional: boolean;
+};
+/**
+ * Fetches a list of vaults from the vaultsfyi API.
+ *
+ * @param args - The action parameters
+ * @param apiKey - The vaultsfyi API key
+ * @returns The list of vaults
+ */
+export declare function fetchVaults(args: z.infer<typeof VaultsActionSchema>, apiKey: string): Promise<ApiVault[] | ApiError>;

package/dist/action-providers/vaultsfyi/api/vaults.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVaults = fetchVaults;
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+/**
+ * Fetches a list of vaults from the vaultsfyi API.
+ *
+ * @param args - The action parameters
+ * @param apiKey - The vaultsfyi API key
+ * @returns The list of vaults
+ */
+async function fetchVaults(args, apiKey) {
+    const vaults = [];
+    const params = (0, utils_1.createSearchParams)({
+        per_page: 250,
+        token: args.token,
+        network: args.network,
+        tvl_min: args.minTvl ?? 100000,
+        transactional_only: true,
+    });
+    for (let i = 0; i < 10; i++) {
+        const response = await fetch(`${constants_1.VAULTS_API_URL}/detailed/vaults?${params}`, {
+            method: "GET",
+            headers: {
+                "x-api-key": apiKey,
+            },
+        });
+        const data = (await response.json());
+        if ("error" in data)
+            return data;
+        vaults.push(...data.data);
+        if (!data.next_page)
+            break;
+        else
+            params.set("page", data.next_page);
+    }
+    return vaults;
+}

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

@@ -0,0 +1,12 @@
+export declare const VAULTS_API_URL = "https://api.vaults.fyi/v1";
+export declare const VAULTSFYI_SUPPORTED_CHAINS: {
+    readonly 1: "mainnet";
+    readonly 42161: "arbitrum";
+    readonly 10: "optimism";
+    readonly 137: "polygon";
+    readonly 100: "gnosis";
+    readonly 8453: "base";
+    readonly 130: "unichain";
+    readonly 1923: "swellchain";
+    readonly 42220: "celo";
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VAULTSFYI_SUPPORTED_CHAINS = exports.VAULTS_API_URL = void 0;
+exports.VAULTS_API_URL = "https://api.vaults.fyi/v1";
+exports.VAULTSFYI_SUPPORTED_CHAINS = {
+    1: "mainnet",
+    42161: "arbitrum",
+    10: "optimism",
+    137: "polygon",
+    100: "gnosis",
+    8453: "base",
+    130: "unichain",
+    1923: "swellchain",
+    42220: "celo",
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Exports for vaultsfyi action provider
+ *
+ * @module vaultsfyi
+ */
+export * from "./vaultsfyiActionProvider";
+export * from "./schemas";

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

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Exports for vaultsfyi action provider
+ *
+ * @module vaultsfyi
+ */
+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("./vaultsfyiActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

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

@@ -0,0 +1,94 @@
+import { z } from "zod";
+/**
+ * Vaults list action schema.
+ */
+export declare const VaultsActionSchema: z.ZodObject<{
+    token: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodString>;
+    network: z.ZodOptional<z.ZodEnum<[string, ...string[]]>>;
+    minTvl: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodObject<{
+        field: z.ZodOptional<z.ZodEnum<["tvl", "apy", "name"]>>;
+        direction: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    }, "strip", z.ZodTypeAny, {
+        field?: "name" | "tvl" | "apy" | undefined;
+        direction?: "asc" | "desc" | undefined;
+    }, {
+        field?: "name" | "tvl" | "apy" | undefined;
+        direction?: "asc" | "desc" | undefined;
+    }>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sort?: {
+        field?: "name" | "tvl" | "apy" | undefined;
+        direction?: "asc" | "desc" | undefined;
+    } | undefined;
+    network?: string | undefined;
+    token?: string | undefined;
+    protocol?: string | undefined;
+    minTvl?: number | undefined;
+    take?: number | undefined;
+    page?: number | undefined;
+}, {
+    sort?: {
+        field?: "name" | "tvl" | "apy" | undefined;
+        direction?: "asc" | "desc" | undefined;
+    } | undefined;
+    network?: string | undefined;
+    token?: string | undefined;
+    protocol?: string | undefined;
+    minTvl?: number | undefined;
+    take?: number | undefined;
+    page?: number | undefined;
+}>;
+export declare const depositActionSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    assetAddress: z.ZodString;
+    network: z.ZodEnum<[string, ...string[]]>;
+    amount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    network: string;
+    vaultAddress: string;
+    assetAddress: string;
+}, {
+    amount: number;
+    network: string;
+    vaultAddress: string;
+    assetAddress: string;
+}>;
+export declare const redeemActionSchema: z.ZodObject<z.objectUtil.extendShape<{
+    vaultAddress: z.ZodString;
+    assetAddress: z.ZodString;
+    network: z.ZodEnum<[string, ...string[]]>;
+    amount: z.ZodNumber;
+}, {
+    all: z.ZodOptional<z.ZodBoolean>;
+}>, "strip", z.ZodTypeAny, {
+    amount: number;
+    network: string;
+    vaultAddress: string;
+    assetAddress: string;
+    all?: boolean | undefined;
+}, {
+    amount: number;
+    network: string;
+    vaultAddress: string;
+    assetAddress: string;
+    all?: boolean | undefined;
+}>;
+export declare const claimActionSchema: z.ZodObject<Omit<{
+    vaultAddress: z.ZodString;
+    assetAddress: z.ZodString;
+    network: z.ZodEnum<[string, ...string[]]>;
+    amount: z.ZodNumber;
+}, "amount">, "strip", z.ZodTypeAny, {
+    network: string;
+    vaultAddress: string;
+    assetAddress: string;
+}, {
+    network: string;
+    vaultAddress: string;
+    assetAddress: string;
+}>;

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimActionSchema = exports.redeemActionSchema = exports.depositActionSchema = exports.VaultsActionSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("./constants");
+/**
+ * Action schemas for the vaultsfyi action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the vaultsfyi action provider.
+ */
+const NetworkSchema = zod_1.z.enum(Object.values(constants_1.VAULTSFYI_SUPPORTED_CHAINS));
+/**
+ * Vaults list action schema.
+ */
+exports.VaultsActionSchema = zod_1.z.object({
+    token: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional: Name or symbol of the token to filter vaults by"),
+    protocol: zod_1.z.string().optional().describe("Optional: Protocol to filter vaults by"),
+    network: NetworkSchema.optional().describe("Optional: Network name to filter vaults by. Supported networks: mainnet, arbitrum, optimism, polygon, base, gnosis, unichain"),
+    minTvl: zod_1.z.number().optional().describe("Optional: Minimum TVL to filter vaults by"),
+    sort: zod_1.z
+        .object({
+        field: zod_1.z.enum(["tvl", "apy", "name"]).optional().describe("Sort field"),
+        direction: zod_1.z.enum(["asc", "desc"]).optional().describe("Sort direction"),
+    })
+        .optional()
+        .describe("Sort options"),
+    take: zod_1.z.number().optional().describe("Optional: Limit the number of results"),
+    page: zod_1.z.number().optional().describe("Optional: Page number"),
+});
+/**
+ * Base transaction params schema.
+ */
+const TransactionActionSchema = zod_1.z.object({
+    vaultAddress: zod_1.z.string().describe("The address of the vault to interact with"),
+    assetAddress: zod_1.z.string().describe("The address of the vault's underlying token"),
+    network: NetworkSchema.describe("The network of the vault"),
+    amount: zod_1.z.number().describe("The amount of assets to use"),
+});
+exports.depositActionSchema = TransactionActionSchema;
+exports.redeemActionSchema = TransactionActionSchema.extend({
+    all: zod_1.z.boolean().optional().describe("Should redeem all assets"),
+});
+exports.claimActionSchema = TransactionActionSchema.omit({
+    amount: true,
+});

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

@@ -0,0 +1,34 @@
+import { EvmWalletProvider } from "../../wallet-providers";
+import { ApiVault } from "./api/vaults";
+import { Actions } from "./api/actions";
+/**
+ * Get the link to the vaults.fyi page for a vault
+ *
+ * @param vault - The vault
+ * @returns The link to the vaults.fyi page
+ */
+export declare function getVaultsLink(vault: ApiVault): string;
+/**
+ * Execute a list of actions
+ *
+ * @param wallet - The wallet provider
+ * @param actions - The list of actions to execute
+ * @returns nothing
+ */
+export declare function executeActions(wallet: EvmWalletProvider, actions: Actions): Promise<void>;
+/**
+ * Create a URLSearchParams object from an object
+ *
+ * @param obj - The object to convert
+ * @returns The URLSearchParams object
+ */
+export declare function createSearchParams(obj: Record<string, string | number | boolean | undefined>): URLSearchParams;
+/**
+ * Parse an asset amount with decimals
+ *
+ * @param wallet - The wallet provider
+ * @param assetAddress - The address of the asset
+ * @param amount - The amount to parse
+ * @returns The parsed amount
+ */
+export declare function parseAssetAmount(wallet: EvmWalletProvider, assetAddress: string, amount: number): Promise<number>;

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVaultsLink = getVaultsLink;
+exports.executeActions = executeActions;
+exports.createSearchParams = createSearchParams;
+exports.parseAssetAmount = parseAssetAmount;
+const viem_1 = require("viem");
+/**
+ * Get the link to the vaults.fyi page for a vault
+ *
+ * @param vault - The vault
+ * @returns The link to the vaults.fyi page
+ */
+function getVaultsLink(vault) {
+    if (vault.isTransactional) {
+        return `https://app.vaults.fyi/opportunity/${vault.network}/${vault.address}`;
+    }
+    else {
+        return `https://analytics.vaults.fyi/vaults/${vault.network}/${vault.address}`;
+    }
+}
+/**
+ * Execute a list of actions
+ *
+ * @param wallet - The wallet provider
+ * @param actions - The list of actions to execute
+ * @returns nothing
+ */
+async function executeActions(wallet, actions) {
+    for (let i = actions.currentActionIndex; i < actions.actions.length; i++) {
+        const action = actions.actions[i];
+        const txHash = await wallet.sendTransaction({
+            ...action.tx,
+            value: action.tx.value ? BigInt(action.tx.value) : undefined,
+        });
+        await wallet.waitForTransactionReceipt(txHash);
+    }
+}
+/**
+ * Create a URLSearchParams object from an object
+ *
+ * @param obj - The object to convert
+ * @returns The URLSearchParams object
+ */
+function createSearchParams(obj) {
+    const params = new URLSearchParams();
+    for (const key in obj) {
+        if (obj[key] !== undefined) {
+            params.append(key, obj[key].toString());
+        }
+    }
+    return params;
+}
+/**
+ * Parse an asset amount with decimals
+ *
+ * @param wallet - The wallet provider
+ * @param assetAddress - The address of the asset
+ * @param amount - The amount to parse
+ * @returns The parsed amount
+ */
+async function parseAssetAmount(wallet, assetAddress, amount) {
+    const decimals = await wallet.readContract({
+        address: assetAddress,
+        abi: viem_1.erc20Abi,
+        functionName: "decimals",
+    });
+    return Math.floor(amount * 10 ** decimals);
+}

package/dist/action-providers/vaultsfyi/vaultsfyiActionProvider.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Vaultsfyi Action Provider
+ *
+ * This file contains the implementation of the VaultsfyiActionProvider,
+ * which provides actions for vaultsfyi operations.
+ *
+ * @module vaultsfyi
+ */
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { claimActionSchema, depositActionSchema, redeemActionSchema, VaultsActionSchema } from "./schemas";
+/**
+ * Configuration options for the OpenseaActionProvider.
+ */
+export interface VaultsfyiActionProviderConfig {
+    /**
+     * vaults.fyi API Key.
+     */
+    apiKey?: string;
+}
+/**
+ * VaultsfyiActionProvider provides actions for vaultsfyi operations.
+ *
+ * @description
+ * This provider is designed to work with EvmWalletProvider for blockchain interactions.
+ * It supports all evm networks.
+ */
+export declare class VaultsfyiActionProvider extends ActionProvider<EvmWalletProvider> {
+    private readonly apiKey;
+    /**
+     * Constructor for the VaultsfyiActionProvider.
+     *
+     * @param config - Configuration options for the provider
+     */
+    constructor(config?: VaultsfyiActionProviderConfig);
+    /**
+     * vaults action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: token, network, transactionalOnly...
+     * @returns A list of vaults.
+     */
+    vaults(wallet: EvmWalletProvider, args: z.infer<typeof VaultsActionSchema>): Promise<string>;
+    /**
+     * Deposit action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments
+     * @returns A result message
+     */
+    deposit(wallet: EvmWalletProvider, args: z.infer<typeof depositActionSchema>): Promise<string>;
+    /**
+     * Redeem action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments
+     * @returns A result message
+     */
+    redeem(wallet: EvmWalletProvider, args: z.infer<typeof redeemActionSchema>): Promise<string>;
+    /**
+     * Claim rewards action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments
+     * @returns A result message
+     */
+    claim(wallet: EvmWalletProvider, args: z.infer<typeof claimActionSchema>): Promise<string>;
+    /**
+     * Returns the users wallet token balances.
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @returns A record of the users balances
+     */
+    balances(wallet: EvmWalletProvider): Promise<string>;
+    /**
+     * Returns the users positions.
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @returns A record of the users positions
+     */
+    positions(wallet: EvmWalletProvider): Promise<string>;
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network: Network): boolean;
+}
+/**
+ * Factory function to create a new VaultsfyiActionProvider instance.
+ *
+ * @param config - Configuration options for the provider
+ * @returns A new VaultsfyiActionProvider instance
+ */
+export declare const vaultsfyiActionProvider: (config: VaultsfyiActionProviderConfig) => VaultsfyiActionProvider;