@coinbase/agentkit 0.10.3 → 0.10.4

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

@@ -25,9 +25,7 @@ const wallet_providers_1 = require("../../wallet-providers");
 const schemas_1 = require("./schemas");
 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");
+const sdk_1 = require("./sdk");
 /**
  * VaultsfyiActionProvider provides actions for vaultsfyi operations.
  *
@@ -57,40 +55,30 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
      * @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}`;
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const vaults = await sdk.getAllVaults({
+                query: {
+                    page: args.page || 1,
+                    perPage: args.perPage || 5,
+                    allowedAssets: args.allowedAssets ? args.allowedAssets : undefined,
+                    allowedNetworks: args.allowedNetworks ? args.allowedNetworks : undefined,
+                    allowedProtocols: args.allowedProtocols ? args.allowedProtocols : undefined,
+                    minTvl: args.minTvl ?? 100000,
+                    onlyTransactional: true,
+                    sortBy: args.sort?.field,
+                    sortOrder: args.sort?.direction,
+                },
+            });
+            const transformedVaults = vaults.data.map(utils_1.transformVault);
+            return JSON.stringify({
+                ...vaults,
+                data: transformedVaults,
+            });
         }
-        if (args.protocol && !vaults.find(vault => vault.protocol === args.protocol)) {
-            const supportedProtocols = vaults
-                .map(vault => vault.protocol)
-                .filter((value, index, self) => self.indexOf(value) === index);
-            return `Protocol ${args.protocol} is not supported. Supported protocols are: ${supportedProtocols.join(", ")}`;
+        catch (error) {
+            return `Failed to fetch vaults: ${error instanceof Error ? error.message : String(error)}`;
         }
-        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") {
-                return args.sort.direction === "asc" ? a.tvlInUsd - b.tvlInUsd : b.tvlInUsd - a.tvlInUsd;
-            }
-            else if (args.sort?.field === "apy") {
-                return args.sort.direction === "asc"
-                    ? a.apy.total - b.apy.total
-                    : b.apy.total - a.apy.total;
-            }
-            return a.name.localeCompare(b.name);
-        });
-        const take = args.take || 10;
-        const page = args.page || 1;
-        const start = (page - 1) * take;
-        const end = start + take;
-        const results = sortedVaults.slice(start, end);
-        return JSON.stringify({
-            totalResults: sortedVaults.length,
-            nextPage: end < sortedVaults.length,
-            results,
-        });
     }
     /**
      * vault details action
@@ -100,11 +88,19 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
      * @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}`;
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const vault = await sdk.getVault({
+                path: {
+                    vaultAddress: args.vaultAddress,
+                    network: args.network,
+                },
+            });
+            return JSON.stringify((0, utils_1.transformVault)(vault));
+        }
+        catch (error) {
+            return `Failed to fetch vault: ${error instanceof Error ? error.message : String(error)}`;
         }
-        return JSON.stringify((0, utils_1.transformDetailedVault)(vault, args.apyRange ?? "7day"));
     }
     /**
      * vault historical data action
@@ -114,160 +110,304 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
      * @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,
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const data = await sdk.getVaultHistoricalData({
+                path: {
+                    vaultAddress: args.vaultAddress,
+                    network: args.network,
+                },
+                query: {
+                    granularity: args.granularity,
+                    fromTimestamp: Math.floor(new Date(args.fromDate).getTime() / 1000),
+                    toTimestamp: Math.floor(new Date(args.toDate).getTime() / 1000),
+                    apyInterval: args.apyInterval,
+                    page: args.page,
+                    perPage: args.perPage,
                 },
-                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,
-            },
-        });
+            });
+            return JSON.stringify({
+                ...data,
+                data: data.data.map(d => ({
+                    ...d,
+                    timestamp: new Date(d.timestamp * 1000).toISOString(),
+                    apy: (0, utils_1.transformApy)(d.apy),
+                })),
+            });
+        }
+        catch (error) {
+            return `Failed to fetch vault historical data: ${error instanceof Error ? error.message : String(error)}`;
+        }
     }
     /**
-     * Deposit action
+     * Transaction context action
      *
      * @param wallet - The wallet provider instance for blockchain interactions
      * @param args - Input arguments
      * @returns A result message
      */
-    async deposit(wallet, args) {
-        const actions = await (0, actions_1.fetchVaultActions)({
-            action: "deposit",
-            args: { ...args, amount: await (0, utils_1.parseAssetAmount)(wallet, args.assetAddress, args.amount) },
-            sender: wallet.getAddress(),
-            apiKey: this.apiKey,
-        });
-        if ("error" in actions) {
-            return `Failed to fetch deposit transactions: ${actions.error}, ${actions.message}`;
+    async transactionContext(wallet, args) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const context = await sdk.getTransactionsContext({
+                path: {
+                    userAddress: wallet.getAddress(),
+                    vaultAddress: args.vaultAddress,
+                    network: args.network,
+                },
+            });
+            return JSON.stringify(context);
+        }
+        catch (error) {
+            return `Failed to fetch transaction context: ${error instanceof Error ? error.message : String(error)}`;
         }
-        await (0, utils_1.executeActions)(wallet, actions);
-        return "Deposit successful";
     }
     /**
-     * Redeem action
+     * Deposit action
      *
      * @param wallet - The wallet provider instance for blockchain interactions
      * @param args - Input arguments
      * @returns A result message
      */
-    async redeem(wallet, args) {
-        const actions = await (0, actions_1.fetchVaultActions)({
-            action: "redeem",
-            args: { ...args, amount: await (0, utils_1.parseAssetAmount)(wallet, args.assetAddress, args.amount) },
-            sender: wallet.getAddress(),
-            apiKey: this.apiKey,
-        });
-        if ("error" in actions) {
-            return `Failed to fetch redeem transactions: ${actions.error}, ${actions.message}`;
+    async executeStep(wallet, args) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const amount = args.amount === "all" ? 0 : args.amount;
+            const actions = await sdk.getActions({
+                path: {
+                    action: args.action,
+                    userAddress: wallet.getAddress(),
+                    vaultAddress: args.vaultAddress,
+                    network: args.network,
+                },
+                query: {
+                    assetAddress: args.assetAddress,
+                    amount: amount ? amount.toString() : undefined,
+                    all: args.amount === "all",
+                },
+            });
+            await (0, utils_1.executeActions)(wallet, actions);
+            return `Successfully executed ${args.action} step`;
+        }
+        catch (error) {
+            return `Failed to execute step: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /**
+     * Returns the users wallet token balances.
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @returns A record of the users balances
+     */
+    async idleAssets(wallet) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const idleAssets = await sdk.getIdleAssets({
+                path: {
+                    userAddress: wallet.getAddress(),
+                },
+            });
+            return JSON.stringify(idleAssets);
+        }
+        catch (error) {
+            return `Failed to fetch idle assets: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /**
+     * Returns the users positions.
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @returns A record of the users positions
+     */
+    async positions(wallet) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const positions = await sdk.getPositions({
+                path: {
+                    userAddress: wallet.getAddress(),
+                },
+            });
+            return JSON.stringify({
+                ...positions,
+                data: positions.data.map(p => ({
+                    ...p,
+                    apy: (0, utils_1.transformApy)(p.apy),
+                })),
+            });
+        }
+        catch (error) {
+            return `Failed to fetch positions: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /**
+     * Rewards context action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @returns A record of rewards that are available to the user each with a unique claim id
+     */
+    async rewardsContext(wallet) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const context = await sdk.getRewardsTransactionsContext({
+                path: {
+                    userAddress: wallet.getAddress(),
+                },
+            });
+            return JSON.stringify(context);
+        }
+        catch (error) {
+            return `Failed to fetch rewards context: ${error instanceof Error ? error.message : String(error)}`;
         }
-        await (0, utils_1.executeActions)(wallet, actions);
-        return "Redeem successful";
     }
     /**
      * Claim rewards action
      *
      * @param wallet - The wallet provider instance for blockchain interactions
-     * @param args - Input arguments
-     * @returns A result message
+     * @param args - Input arguments: claimIds
+     * @returns A message indicating the success of the claim
      */
-    async claim(wallet, args) {
-        const actions = await (0, actions_1.fetchVaultActions)({
-            action: "claim-rewards",
-            args,
-            sender: wallet.getAddress(),
-            apiKey: this.apiKey,
-        });
-        if ("error" in actions) {
-            return `Failed to fetch claim transactions: ${actions.error}, ${actions.message}`;
+    async claimRewards(wallet, args) {
+        const chainId = wallet.getNetwork().chainId;
+        if (!chainId)
+            return "Invalid network";
+        const networkName = (0, constants_1.getNetworkNameFromChainId)(chainId);
+        if (!networkName)
+            return "Invalid network";
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const actions = await sdk.getRewardsClaimActions({
+                path: {
+                    userAddress: wallet.getAddress(),
+                },
+                query: {
+                    claimIds: args.claimIds,
+                },
+            });
+            if (Object.keys(actions).some(network => network !== networkName)) {
+                return `Error: You're trying to claim rewards from a different network. Agent network is ${networkName}.`;
+            }
+            if (!actions[networkName])
+                return "No actions found";
+            await (0, utils_1.executeActions)(wallet, actions[networkName]);
+            return `Successfully claimed rewards for ${args.claimIds.length} rewards`;
+        }
+        catch (error) {
+            return `Failed to claim rewards: ${error instanceof Error ? error.message : String(error)}`;
         }
-        await (0, utils_1.executeActions)(wallet, actions);
-        return "Claim successful";
     }
     /**
-     * Returns the users wallet token balances.
+     * Benchmark APY action
      *
      * @param wallet - The wallet provider instance for blockchain interactions
-     * @returns A record of the users balances
+     * @param args - Input arguments: network, benchmarkCode
+     * @returns benchmark APY data
      */
-    async balances(wallet) {
-        const params = new URLSearchParams({
-            account: wallet.getAddress(),
-        });
-        const result = await fetch(`${constants_1.VAULTS_API_URL}/portfolio/wallet-balances?${params.toString()}`, {
-            method: "GET",
-            headers: {
-                "x-api-key": this.apiKey,
-            },
-        });
-        const balances = (await result.json());
-        if ("error" in balances) {
-            return `Failed to fetch wallet balances: ${balances.error}, ${balances.message}`;
+    async benchmarkApy(wallet, args) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const benchmark = await sdk.getBenchmarks({
+                path: {
+                    network: args.network,
+                },
+                query: {
+                    code: args.benchmarkCode,
+                },
+            });
+            return JSON.stringify({
+                ...benchmark,
+                apy: benchmark.apy ? (0, utils_1.transformApyObject)(benchmark.apy) : null,
+                timestamp: new Date(benchmark.timestamp * 1000).toISOString(),
+            });
         }
-        const entries = Object.entries(balances).map(([network, balances]) => {
-            return [
-                network,
-                balances.map(balance => ({
-                    address: balance.address,
-                    name: balance.name,
-                    symbol: balance.symbol,
-                    balance: Number(balance.balance) / 10 ** balance.decimals,
+        catch (error) {
+            return `Failed to fetch benchmark: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /**
+     * Historical benchmark APY action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: network, benchmarkCode, fromDate, toDate, page, perPage
+     * @returns A list of historical benchmark APY data
+     */
+    async historicalBenchmarkApy(wallet, args) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const historicalBenchmarks = await sdk.getHistoricalBenchmarks({
+                path: {
+                    network: args.network,
+                },
+                query: {
+                    code: args.benchmarkCode,
+                    fromTimestamp: Math.floor(new Date(args.fromDate).getTime() / 1000),
+                    toTimestamp: Math.floor(new Date(args.toDate).getTime() / 1000),
+                    page: args.page,
+                    perPage: args.perPage,
+                },
+            });
+            return JSON.stringify({
+                ...historicalBenchmarks,
+                data: historicalBenchmarks.data.map(d => ({
+                    timestamp: new Date(d.timestamp * 1000).toISOString(),
+                    apy: d.apy ? (0, utils_1.transformApyObject)(d.apy) : null,
                 })),
-            ];
-        });
-        return JSON.stringify(Object.fromEntries(entries));
+            });
+        }
+        catch (error) {
+            return `Failed to fetch historical benchmark: ${error instanceof Error ? error.message : String(error)}`;
+        }
     }
     /**
-     * Returns the users positions.
+     * Total vault returns action
      *
      * @param wallet - The wallet provider instance for blockchain interactions
-     * @returns A record of the users positions
+     * @param args - Input arguments: vaultAddress, network, userAddress
+     * @returns An amount of the users total returns
      */
-    async positions(wallet) {
-        const result = await fetch(`${constants_1.VAULTS_API_URL}/portfolio/positions/${wallet.getAddress()}`, {
-            method: "GET",
-            headers: {
-                "x-api-key": this.apiKey,
-            },
-        });
-        const positions = (await result.json());
-        if ("error" in positions) {
-            return `Failed to fetch positions: ${positions.error}, ${positions.message}`;
+    async totalVaultReturns(wallet, args) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const totalReturns = await sdk.getUserVaultTotalReturns({
+                path: {
+                    vaultAddress: args.vaultAddress,
+                    network: args.network,
+                    userAddress: args.userAddress || wallet.getAddress(),
+                },
+            });
+            return JSON.stringify(totalReturns);
+        }
+        catch (error) {
+            return `Failed to fetch total vault returns: ${error instanceof Error ? error.message : String(error)}`;
         }
-        const entries = Object.entries(positions).map(([network, positions]) => {
-            return [
-                network,
-                positions.map(position => ({
-                    name: position.vaultName,
-                    vaultAddress: position.vaultAddress,
-                    asset: {
-                        address: position.asset.assetAddress,
-                        name: position.asset.name,
-                        symbol: position.asset.symbol,
-                    },
-                    underlyingTokenBalance: Number(position.balanceNative) / 10 ** position.asset.decimals,
-                    lpTokenBalance: Number(position.balanceLp) / 10 ** position.asset.decimals,
-                    unclaimedRewards: Number(position.unclaimedUsd) > 0,
-                    apy: {
-                        base: position.apy.base / 100,
-                        rewards: position.apy.rewards / 100,
-                        total: position.apy.total / 100,
-                    },
+    }
+    /**
+     * User events action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: vaultAddress, network, userAddress
+     * @returns A list of the users actions on a vault
+     */
+    async userEvents(wallet, args) {
+        try {
+            const sdk = (0, sdk_1.getVaultsSdk)(this.apiKey);
+            const userEvents = await sdk.getUserVaultEvents({
+                path: {
+                    vaultAddress: args.vaultAddress,
+                    network: args.network,
+                    userAddress: args.userAddress || wallet.getAddress(),
+                },
+            });
+            return JSON.stringify({
+                ...userEvents,
+                data: userEvents.data.map(d => ({
+                    ...d,
+                    timestamp: new Date(d.timestamp * 1000).toISOString(),
                 })),
-            ];
-        });
-        return JSON.stringify(Object.fromEntries(entries));
+            });
+        }
+        catch (error) {
+            return `Failed to fetch user events: ${error instanceof Error ? error.message : String(error)}`;
+        }
     }
     /**
      * Checks if this provider supports the given network.
@@ -276,8 +416,8 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
      * @returns True if the network is supported
      */
     supportsNetwork(network) {
-        return (network.protocolFamily == "evm" &&
-            (network.chainId ? Object.keys(constants_1.VAULTSFYI_SUPPORTED_CHAINS).includes(network.chainId) : false));
+        return (network.protocolFamily === "evm" &&
+            (network.chainId ? constants_1.SUPPORTED_CHAIN_IDS.includes(network.chainId) : false));
     }
 }
 exports.VaultsfyiActionProvider = VaultsfyiActionProvider;
@@ -285,24 +425,24 @@ __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "vaults",
         description: `
-      This action returns a list of available vaults.
+      This action returns a list of available vaults. All asset/lp token amounts returned are in the smallest unit of the token.
       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. Include vaults.fyi links for each vault.
-      Format result apys as: x% (base: x%, rewards: x%) if rewards apy is available, otherwise: x%
+      Include vaults.fyi links for each vault.
+      By default, it's best to check only the vaults for the users network (check with another action if you're not sure).
       Examples:
       User: "Show me the best vaults"
-      args: { sort: { field: 'apy', direction: 'desc' }, take: 5 }
+      args: { sort: { field: 'apy7day', direction: 'desc' }, perPage: 5 }
       User: "Show me the safest vaults"
-      args: { sort: { field: 'tvl', direction: 'desc' }, take: 5 }
+      args: { sort: { field: 'tvl', direction: 'desc' }, perPage: 5 }
       User: "Show me the best vaults on Arbitrum"
-      args: { network: 'arbitrum', sort: { field: 'apy', direction: 'desc' }, take: 5 }
+      args: { allowedNetworks: ['arbitrum'], sort: { field: 'apy7day', direction: 'desc' }, perPage: 5 }
       User: "I want to earn yield on my usdc on base!"
-      args: { token: 'usdc', network: 'base', sort: { field: 'apy', direction: 'desc' }, take: 5 }
+      args: { allowedAssets: ['usdc'], allowedNetworks: ['base'], sort: { field: 'apy7day', direction: 'desc' }, perPage: 5 }
       User: "What are some of the most profitable degen vaults on polygon"
-      args: { network: 'polygon', sort: { field: 'apy', direction: 'desc' }, take: 5, minTvl: 0 }
+      args: { allowedNetworks: ['polygon'], sort: { field: 'apy7day', direction: 'desc' }, perPage: 5, minTvl: 0 }
       User: "Show me some more of those"
-      args: { network: 'polygon', sort: { field: 'apy', direction: 'desc' }, take: 5, minTvl: 0, page: 2 }
+      args: { allowedNetworks: ['polygon'], sort: { field: 'apy7day', direction: 'desc' }, perPage: 5, minTvl: 0, page: 2 }
       All optional fields should be null if not specified.
     `,
         schema: schemas_1.VaultsActionSchema,
@@ -313,16 +453,9 @@ __decorate([
 ], 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)
+        name: "detailed_vault",
+        description: `This action returns single vault details.
+      All asset/lp token amounts returned are in the smallest unit of the token.
     `,
         schema: schemas_1.VaultDetailsActionSchema,
     }),
@@ -334,15 +467,12 @@ __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."
-    `,
+      This action returns a historical APY, TVL and share price of a vault. 
+      It returns an array of data points with the requested granularity. (hourly, daily weekly), 
+      The pricing is 3 credits base and 3 credits for each datapoint. 
+      Estimate the credits usage and warn the user before executing the action.
+      All asset/lp token amounts returned are in the smallest unit of the token.
+`,
         schema: schemas_1.VaultHistoricalDataActionSchema,
     }),
     __metadata("design:type", Function),
@@ -351,15 +481,18 @@ __decorate([
 ], VaultsfyiActionProvider.prototype, "vaultHistoricalData", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
-        name: "deposit",
+        name: "transaction_context",
         description: `
-      This action deposits assets into a selected vault. Before depositing make sure you have the required assets in your wallet using the wallet-balances action.
-      Even if you received the balance from some other source, double-check the user balance.
-      Use examples:
+      This action returns the transaction context for a given vault. It returns a list of steps for a deposit/redeem from a vault. 
+      These steps can be executed using the execute_step action. Check the "redeemStepsType"/"depositStepsType" to see if it's "instant" or "complex". 
+      Complex steps might require delay between steps like request and claim flows. Status of these can usually be found in the "vaultSpecificData" field of the context.
+      All asset/lp token amounts returned are in the smallest unit of the token. For example, USDC has 6 decimals, so 1000 USDC is 1000000000. Use smallest unit for the amount field in the execute_step action.
+      Usage examples:
       User: "Deposit 1000 USDC into the vault"
       actions:
-       - check wallet balance for USDC
-       - deposit USDC into the vault if balance is sufficient
+       - check if the wallet has 1000 USDC
+       - check vault context to see the deposit steps
+       - execute the deposit steps sequentially
       User: "I want more yield on my DAI"
       actions:
        - check positions that the user already has for dai
@@ -373,45 +506,32 @@ __decorate([
        - create a diversified strategy using the users assets
        - propose the strategy to the user before executing
     `,
-        schema: schemas_1.depositActionSchema,
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
-    __metadata("design:returntype", Promise)
-], VaultsfyiActionProvider.prototype, "deposit", null);
-__decorate([
-    (0, actionDecorator_1.CreateAction)({
-        name: "redeem",
-        description: `
-      This action redeems assets from a selected vault. Before redeeming make sure you have the required lp tokens in your wallet using the positions action.
-      Even if you received the lp tokens from some other source, double-check the amount before redeeming.
-      lp tokens aren't always 1:1 with the underlying asset, so make sure to check the amount of lp tokens you have before redeeming even if you know the amount of the underlying asset you want to redeem.
-    `,
-        schema: schemas_1.redeemActionSchema,
+        schema: schemas_1.transactionContextActionSchema,
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
-], VaultsfyiActionProvider.prototype, "redeem", null);
+], VaultsfyiActionProvider.prototype, "transactionContext", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
-        name: "claim_rewards",
+        name: "execute_step",
         description: `
-      This action claims rewards from a selected vault.
-      assetAddress is the address of the vaults underlying token.
-      If you're not sure what vaults have rewards claimable, use the positions action.
-    `,
-        schema: schemas_1.claimActionSchema,
+      This action executes a given step on a vault. If you're not sure what steps are available, use the transaction context to get more information.
+      The amount should be a in smallest unit of the token (f.e. 1000000 for 1 USDC) and for redeeming should be the amount of lpTokens in smallest units.
+      If you want to redeem all shares, use {"amount":"all"}.
+      Even if you received the balance from some other source, double-check the user balance with idle_assets/positions/context actions before deposit/redeem.`,
+        schema: schemas_1.executeStepActionSchema,
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
-], VaultsfyiActionProvider.prototype, "claim", null);
+], VaultsfyiActionProvider.prototype, "executeStep", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
-        name: "user_wallet_balances",
+        name: "user_idle_assets",
         description: `
     This action returns the users wallet balances of all tokens supported by vaults.fyi. Useful when you don't know token addresses but want to check if the user has an asset.
+    All asset/lp token amounts returned are in the smallest unit of the token.
     Example queries:
     User: "What tokens do I have?"
     User: "What tokens do I have on Arbitrum?"
@@ -422,12 +542,13 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider]),
     __metadata("design:returntype", Promise)
-], VaultsfyiActionProvider.prototype, "balances", null);
+], VaultsfyiActionProvider.prototype, "idleAssets", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "positions",
         description: `
       This action returns the users positions in vaults.
+      All asset/lp token amounts returned are in the smallest unit of the token.
       Example queries:
       User: "Show me my positions"
       User: "What vaults am i invested in?"
@@ -440,11 +561,86 @@ __decorate([
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider]),
     __metadata("design:returntype", Promise)
 ], VaultsfyiActionProvider.prototype, "positions", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "rewards_context",
+        description: `
+      This action returns a record of rewards that are available to the user each with a unique claim id. You can use these ids in the claim_rewards action to claim specific rewards.
+      All asset/lp token amounts returned are in the smallest unit of the token.
+    `,
+        schema: zod_1.z.object({}),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "rewardsContext", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "claim_rewards",
+        description: `
+      This action claims rewards for a given reward id.
+    `,
+        schema: schemas_1.claimRewardsActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "claimRewards", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "benchmark_apy",
+        description: `
+      This action retrieves benchmark APY data for the specified network and benchmark code. It's a weighted average of top yields for the network and asset. Can be used to benchmark vaults against.
+    `,
+        schema: schemas_1.benchmarkActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "benchmarkApy", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "historical_benchmark_apy",
+        description: `
+      This action retrieves historical benchmark APY data for the specified network and benchmark code. It's a weighted average of top yields for the network and asset. Can be used to benchmark vaults against.
+    `,
+        schema: schemas_1.historicalBenchmarkActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "historicalBenchmarkApy", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "total_vault_returns",
+        description: `
+      This action retrieves the total returns earned by a given user for a given vault. Uses your address if userAddress not specified.
+      "returnsNative" amounts returned are in the smallest unit of the token.
+    `,
+        schema: schemas_1.totalVaultReturnsActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "totalVaultReturns", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "user_events",
+        description: `
+      This action retrieves historical actions performed by a given user on a given vault.
+      All asset/lp token amounts returned are in the smallest unit of the token.
+    `,
+        schema: schemas_1.userEventsActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "userEvents", null);
 /**
  * Factory function to create a new VaultsfyiActionProvider instance.
  *
  * @param config - Configuration options for the provider
  * @returns A new VaultsfyiActionProvider instance
  */
-const vaultsfyiActionProvider = (config) => new VaultsfyiActionProvider(config);
+const vaultsfyiActionProvider = (config = {}) => new VaultsfyiActionProvider(config);
 exports.vaultsfyiActionProvider = vaultsfyiActionProvider;