@coinbase/agentkit 0.10.2 → 0.10.4

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

@@ -11,46 +11,109 @@ const mockFetchResult = (status, data) => {
 };
 const mockVault = (num) => ({
     apiResult: {
-        address: `0x${num.toString(16).padStart(40, "0")}`,
-        network: `network-${num}`,
+        address: "0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5",
+        network: {
+            name: "base",
+            chainId: 8453,
+            networkCaip: "eip155:8453",
+        },
+        asset: {
+            address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+            assetCaip: "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+            name: "USD Coin",
+            symbol: "USDC",
+            decimals: 6,
+            assetLogo: "https://images.vaults.fyi/tokens/usdc.png",
+            assetPriceInUsd: "0.99983592",
+            assetGroup: "USD",
+        },
+        isTransactional: true,
+        isAppFeatured: true,
         name: `vault-${num}`,
-        protocol: `protocol-${num}`,
-        token: {
-            name: `token-${num}`,
-            assetAddress: `0x${num.toString(16).padStart(40, "0")}`,
-            symbol: `T${num}`,
-            decimals: 18,
+        protocol: {
+            name: "40acres",
+            product: "",
+            version: "",
+            protocolLogo: "https://images.vaults.fyi/protocols/40acres.png",
         },
-        tvlDetails: {
-            tvlUsd: num.toString(),
+        lendUrl: "https://app.vaults.fyi/opportunity/base/0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5",
+        description: `Description for vault-${num}`,
+        protocolVaultUrl: "https://www.40acres.finance/",
+        tags: ["Lending"],
+        holdersData: {
+            totalCount: num,
+            totalBalance: (num * 1000000).toString(),
+            topHolders: [
+                {
+                    address: "0x1d59868D7767d703929393bDaB313302840f533c",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x1c6586f4895A569d9EFac5ABd231b79E0D47cAAD",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x011b0a055E02425461A1ae95B30F483c4fF05bE7",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x9551EeC2a31025D582Be358E05D88a9c95cAD86E",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x10076ed296571cE4Fde5b1FDF0eB9014a880e47B",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x9e33Fef28A75303B4FEB7b4c713c27Fed2AC78DD",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x166B9a0390474C455115dFb64579D1D79286588F",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x318962D28813fe14B9b6265fE2dAFB241C7F7777",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x22e4bB70905c7Ad93B65BC9Bd5B1b06e67378124",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x57609a91CC6eA77D9805137656A9308F5bF52f23",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+            ],
         },
         apy: {
-            base: {
-                "7day": num * 100,
+            "1day": {
+                base: num,
+                reward: num,
+                total: num,
             },
-            rewards: {
-                "7day": num * 100,
+            "7day": {
+                base: num,
+                reward: num,
+                total: num,
             },
-            total: {
-                "7day": num * 100,
+            "30day": {
+                base: num,
+                reward: num,
+                total: num,
             },
-        },
-        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,
-                },
+            "1hour": {
+                base: num,
+                reward: num,
+                total: num,
             },
-        ],
-        description: `Description for vault-${num}`,
-        additionalIncentives: `Incentives for vault-${num}`,
+        },
+        tvl: {
+            usd: num.toString(),
+            native: (num * 1000000).toString(),
+        },
+        lastUpdateTimestamp: 1764259200,
+        rewards: [],
         score: {
             vaultScore: num,
             vaultTvlScore: num,
@@ -59,27 +122,146 @@ const mockVault = (num) => ({
             networkScore: num,
             assetScore: num,
         },
-        isTransactional: true,
+        lpToken: {
+            address: "0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5",
+            tokenCaip: "eip155:8453/erc20:0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5",
+            name: `Vault-${num}`,
+            symbol: `VAULT-${num}`,
+            decimals: 6,
+        },
+        transactionalProperties: {
+            depositStepsType: "instant",
+            redeemStepsType: "instant",
+            rewardsSupported: false,
+        },
+        warnings: [],
     },
     transformedResult: {
+        address: "0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5",
+        network: {
+            name: "base",
+            chainId: 8453,
+            networkCaip: "eip155:8453",
+        },
+        asset: {
+            address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+            assetCaip: "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+            name: "USD Coin",
+            symbol: "USDC",
+            decimals: 6,
+            assetLogo: "https://images.vaults.fyi/tokens/usdc.png",
+            assetPriceInUsd: "0.99983592",
+            assetGroup: "USD",
+        },
+        isTransactional: true,
+        isAppFeatured: true,
         name: `vault-${num}`,
-        address: `0x${num.toString(16).padStart(40, "0")}`,
-        network: `network-${num}`,
-        protocol: `protocol-${num}`,
-        tvlInUsd: num,
-        token: {
-            name: `token-${num}`,
-            address: `0x${num.toString(16).padStart(40, "0")}`,
-            symbol: `T${num}`,
+        protocol: {
+            name: "40acres",
+            product: "",
+            version: "",
+            protocolLogo: "https://images.vaults.fyi/protocols/40acres.png",
+        },
+        lendUrl: "https://app.vaults.fyi/opportunity/base/0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5",
+        description: `Description for vault-${num}`,
+        protocolVaultUrl: "https://www.40acres.finance/",
+        tags: ["Lending"],
+        holdersData: {
+            totalCount: num,
+            totalBalance: (num * 1000000).toString(),
+            topHolders: [
+                {
+                    address: "0x1d59868D7767d703929393bDaB313302840f533c",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x1c6586f4895A569d9EFac5ABd231b79E0D47cAAD",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x011b0a055E02425461A1ae95B30F483c4fF05bE7",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x9551EeC2a31025D582Be358E05D88a9c95cAD86E",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x10076ed296571cE4Fde5b1FDF0eB9014a880e47B",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x9e33Fef28A75303B4FEB7b4c713c27Fed2AC78DD",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x166B9a0390474C455115dFb64579D1D79286588F",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x318962D28813fe14B9b6265fE2dAFB241C7F7777",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x22e4bB70905c7Ad93B65BC9Bd5B1b06e67378124",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+                {
+                    address: "0x57609a91CC6eA77D9805137656A9308F5bF52f23",
+                    lpTokenBalance: (num * 1000000).toString(),
+                },
+            ],
         },
         apy: {
-            base: num,
-            rewards: num,
-            total: num,
+            "1day": {
+                base: `${(num * 100).toFixed(2)}%`,
+                reward: `${(num * 100).toFixed(2)}%`,
+                total: `${(num * 100).toFixed(2)}%`,
+            },
+            "7day": {
+                base: `${(num * 100).toFixed(2)}%`,
+                reward: `${(num * 100).toFixed(2)}%`,
+                total: `${(num * 100).toFixed(2)}%`,
+            },
+            "30day": {
+                base: `${(num * 100).toFixed(2)}%`,
+                reward: `${(num * 100).toFixed(2)}%`,
+                total: `${(num * 100).toFixed(2)}%`,
+            },
+            "1hour": {
+                base: `${(num * 100).toFixed(2)}%`,
+                reward: `${(num * 100).toFixed(2)}%`,
+                total: `${(num * 100).toFixed(2)}%`,
+            },
+        },
+        tvl: {
+            usd: num.toString(),
+            native: (num * 1000000).toString(),
         },
-        vaultsFyiScore: num,
-        numberOfHolders: num,
-        link: `https://app.vaults.fyi/opportunity/network-${num}/0x${num.toString(16).padStart(40, "0")}`,
+        lastUpdateTimestamp: new Date(1764259200 * 1000).toISOString(),
+        rewards: [],
+        score: {
+            vaultScore: num,
+            vaultTvlScore: num,
+            protocolTvlScore: num,
+            holderScore: num,
+            networkScore: num,
+            assetScore: num,
+        },
+        lpToken: {
+            address: "0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5",
+            tokenCaip: "eip155:8453/erc20:0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5",
+            name: `Vault-${num}`,
+            symbol: `VAULT-${num}`,
+            decimals: 6,
+        },
+        transactionalProperties: {
+            depositStepsType: "instant",
+            redeemStepsType: "instant",
+            rewardsSupported: false,
+        },
+        warnings: [],
+        link: `https://app.vaults.fyi/opportunity/base/0xB99B6dF96d4d5448cC0a5B3e0ef7896df9507Cf5`,
     },
 });
 const MOCK_TX_HASH = "0xmock-hash";
@@ -111,10 +293,10 @@ describe("VaultsfyiActionProvider", () => {
     });
     describe("network support", () => {
         it("should support all vaultsfyi networks", () => {
-            Object.keys(constants_1.VAULTSFYI_SUPPORTED_CHAINS).forEach(network => {
+            constants_1.SUPPORTED_CHAIN_IDS.forEach(chainId => {
                 expect(provider.supportsNetwork({
                     protocolFamily: "evm",
-                    chainId: network,
+                    chainId: chainId,
                 })).toBe(true);
             });
         });
@@ -135,75 +317,16 @@ describe("VaultsfyiActionProvider", () => {
             const args = {};
             const result = await provider.vaults(mockWalletProvider, args);
             expect(JSON.parse(result)).toStrictEqual({
-                totalResults: 1,
-                nextPage: false,
-                results: [mockedVault.transformedResult],
-            });
-        });
-        it("should filter by protocol", async () => {
-            const mockedVaults = [mockVault(1), mockVault(2)];
-            mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
-            const args = { protocol: "protocol-1" };
-            const result = await provider.vaults(mockWalletProvider, args);
-            expect(JSON.parse(result)).toStrictEqual({
-                totalResults: 1,
-                nextPage: false,
-                results: [mockedVaults[0].transformedResult],
-            });
-        });
-        it("should take a limit", async () => {
-            const mockedVaults = [mockVault(1), mockVault(2)];
-            mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
-            const args = { take: 1 };
-            const result = await provider.vaults(mockWalletProvider, args);
-            expect(JSON.parse(result)).toStrictEqual({
-                totalResults: 2,
-                nextPage: true,
-                results: [mockedVaults[0].transformedResult],
-            });
-        });
-        describe("sorting", () => {
-            it("should sort by TVL", async () => {
-                const mockedVaults = [mockVault(2), mockVault(1)];
-                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
-                const args = { sort: { field: "tvl", direction: "asc" } };
-                const result = await provider.vaults(mockWalletProvider, args);
-                expect(JSON.parse(result)).toStrictEqual({
-                    totalResults: 2,
-                    nextPage: false,
-                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
-                });
-            });
-            it("should sort by APY", async () => {
-                const mockedVaults = [mockVault(2), mockVault(1)];
-                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
-                const args = { sort: { field: "apy", direction: "asc" } };
-                const result = await provider.vaults(mockWalletProvider, args);
-                expect(JSON.parse(result)).toStrictEqual({
-                    totalResults: 2,
-                    nextPage: false,
-                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
-                });
-            });
-            it("should sort by name by default", async () => {
-                const mockedVaults = [mockVault(2), mockVault(1)];
-                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
-                const args = {};
-                const result = await provider.vaults(mockWalletProvider, args);
-                expect(JSON.parse(result)).toStrictEqual({
-                    totalResults: 2,
-                    nextPage: false,
-                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
-                });
+                data: [mockedVault.transformedResult],
             });
         });
         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 = {};
-            expect(await provider.vaults(mockWalletProvider, args)).toBe("Failed to fetch vaults: Internal Server Error, some more info");
+            expect(await provider.vaults(mockWalletProvider, args)).toBe("Failed to fetch vaults: some more info");
         });
     });
-    describe("deposit action", () => {
+    describe("execute_step action", () => {
         it("should execute deposit", async () => {
             mockedFetch.mockResolvedValue(mockFetchResult(200, {
                 currentActionIndex: 0,
@@ -223,15 +346,15 @@ describe("VaultsfyiActionProvider", () => {
                 vaultAddress: "0x123",
                 assetAddress: "0x456",
                 network: "mainnet",
-                amount: 1,
+                amount: 1n,
+                action: "deposit",
             };
-            const response = await provider.deposit(mockWalletProvider, args);
-            expect(response).toBe("Deposit successful");
+            const response = await provider.executeStep(mockWalletProvider, args);
+            expect(response).toBe("Successfully executed deposit step");
             expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
                 to: "0x123",
                 data: "0x456",
                 value: 1n,
-                chainId: 1,
             });
             expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
         });
@@ -263,21 +386,20 @@ describe("VaultsfyiActionProvider", () => {
                 vaultAddress: "0x123",
                 assetAddress: "0x456",
                 network: "mainnet",
-                amount: 1,
+                amount: 1n,
+                action: "deposit",
             };
-            const response = await provider.deposit(mockWalletProvider, args);
-            expect(response).toBe("Deposit successful");
+            const response = await provider.executeStep(mockWalletProvider, args);
+            expect(response).toBe("Successfully executed deposit step");
             expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
                 to: "0x123",
                 data: "0x456",
                 value: 1n,
-                chainId: 1,
             });
             expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
                 to: "0x789",
                 data: "0xabc",
                 value: 2n,
-                chainId: 1,
             });
             expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
         });
@@ -287,99 +409,14 @@ describe("VaultsfyiActionProvider", () => {
                 vaultAddress: "0x123",
                 assetAddress: "0x456",
                 network: "mainnet",
-                amount: 1,
+                amount: 1n,
+                action: "deposit",
             };
-            expect(await provider.deposit(mockWalletProvider, args)).toBe("Failed to fetch deposit transactions: Internal Server Error, some more info");
+            expect(await provider.executeStep(mockWalletProvider, args)).toBe("Failed to execute step: some more info");
         });
     });
-    describe("redeem action", () => {
-        it("should execute redeem", async () => {
-            mockedFetch.mockResolvedValue(mockFetchResult(200, {
-                currentActionIndex: 0,
-                actions: [
-                    {
-                        tx: {
-                            to: "0x123",
-                            data: "0x456",
-                            value: "1",
-                            chainId: 1,
-                        },
-                        description: "Redeem from vault",
-                    },
-                ],
-            }));
-            const args = {
-                vaultAddress: "0x123",
-                assetAddress: "0x456",
-                network: "mainnet",
-                amount: 1,
-            };
-            const response = await provider.redeem(mockWalletProvider, args);
-            expect(response).toBe("Redeem successful");
-            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
-                to: "0x123",
-                data: "0x456",
-                value: 1n,
-                chainId: 1,
-            });
-            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
-        });
-        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: "0x123",
-                assetAddress: "0x456",
-                network: "mainnet",
-                amount: 1,
-            };
-            expect(await provider.redeem(mockWalletProvider, args)).toBe("Failed to fetch redeem transactions: Internal Server Error, some more info");
-        });
-    });
-    describe("claim rewards action", () => {
-        it("should execute claim rewards", async () => {
-            mockedFetch.mockResolvedValue(mockFetchResult(200, {
-                currentActionIndex: 0,
-                actions: [
-                    {
-                        tx: {
-                            to: "0x123",
-                            data: "0x456",
-                            value: "1",
-                            chainId: 1,
-                        },
-                        description: "Claim rewards from vault",
-                    },
-                ],
-            }));
-            const args = {
-                vaultAddress: "0x123",
-                assetAddress: "0x456",
-                network: "mainnet",
-                amount: 1,
-            };
-            const response = await provider.claim(mockWalletProvider, args);
-            expect(response).toBe("Claim successful");
-            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
-                to: "0x123",
-                data: "0x456",
-                value: 1n,
-                chainId: 1,
-            });
-            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
-        });
-        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: "0x123",
-                assetAddress: "0x456",
-                network: "mainnet",
-                amount: 1,
-            };
-            expect(await provider.claim(mockWalletProvider, args)).toBe("Failed to fetch claim transactions: Internal Server Error, some more info");
-        });
-    });
-    describe("wallet balances action", () => {
-        it("should strip and transform balances correctly", async () => {
+    describe("user_idle_assets action", () => {
+        it("should return the response", async () => {
             mockedFetch.mockResolvedValue(mockFetchResult(200, {
                 mainnet: [
                     {
@@ -388,31 +425,31 @@ describe("VaultsfyiActionProvider", () => {
                         symbol: "T1",
                         balance: (10 ** 18).toString(),
                         decimals: 18,
-                        somethingElse: "should be stripped",
                     },
                 ],
             }));
-            const response = await provider.balances(mockWalletProvider);
+            const response = await provider.idleAssets(mockWalletProvider);
             expect(JSON.parse(response)).toStrictEqual({
                 mainnet: [
                     {
                         address: "0x123",
                         name: "token-1",
                         symbol: "T1",
-                        balance: 1,
+                        balance: (10 ** 18).toString(),
+                        decimals: 18,
                     },
                 ],
             });
         });
         it("should return an error if the API request fails", async () => {
             mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
-            expect(await provider.balances(mockWalletProvider)).toBe("Failed to fetch wallet balances: Internal Server Error, some more info");
+            expect(await provider.idleAssets(mockWalletProvider)).toBe("Failed to fetch idle assets: some more info");
         });
     });
     describe("wallet positions action", () => {
-        it("should strip and transform positions correctly", async () => {
+        it("should transform the response correctly", async () => {
             mockedFetch.mockResolvedValue(mockFetchResult(200, {
-                mainnet: [
+                data: [
                     {
                         vaultName: "vault-1",
                         vaultAddress: "0x123",
@@ -426,31 +463,32 @@ describe("VaultsfyiActionProvider", () => {
                         balanceLp: (10 ** 18).toString(),
                         unclaimedUsd: "100",
                         apy: {
-                            base: 100,
-                            rewards: 100,
-                            total: 100,
+                            base: 0.1,
+                            reward: 0.1,
+                            total: 0.1,
                         },
                     },
                 ],
             }));
             const response = await provider.positions(mockWalletProvider);
             expect(JSON.parse(response)).toStrictEqual({
-                mainnet: [
+                data: [
                     {
-                        name: "vault-1",
+                        vaultName: "vault-1",
                         vaultAddress: "0x123",
                         asset: {
-                            address: "0x456",
+                            assetAddress: "0x456",
                             name: "token-1",
                             symbol: "T1",
+                            decimals: 18,
                         },
-                        underlyingTokenBalance: 1,
-                        lpTokenBalance: 1,
-                        unclaimedRewards: true,
+                        balanceNative: (10 ** 18).toString(),
+                        balanceLp: (10 ** 18).toString(),
+                        unclaimedUsd: "100",
                         apy: {
-                            base: 1,
-                            rewards: 1,
-                            total: 1,
+                            base: "10.00%",
+                            reward: "10.00%",
+                            total: "10.00%",
                         },
                     },
                 ],
@@ -458,11 +496,11 @@ describe("VaultsfyiActionProvider", () => {
         });
         it("should return an error if the API request fails", async () => {
             mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
-            expect(await provider.positions(mockWalletProvider)).toBe("Failed to fetch positions: Internal Server Error, some more info");
+            expect(await provider.positions(mockWalletProvider)).toBe("Failed to fetch positions: some more info");
         });
     });
-    describe("vault_details action", () => {
-        it("should transform vault details correctly", async () => {
+    describe("detailed_vault action", () => {
+        it("should return the response", async () => {
             const detailedVault = mockVault(1);
             mockedFetch.mockResolvedValue(mockFetchResult(200, detailedVault.apiResult));
             const args = {
@@ -473,15 +511,59 @@ describe("VaultsfyiActionProvider", () => {
             const parsedResult = JSON.parse(result);
             expect(parsedResult).toStrictEqual({
                 ...detailedVault.transformedResult,
-                description: detailedVault.apiResult.description,
-                additionalIncentives: detailedVault.apiResult.additionalIncentives,
-                rewards: [
+            });
+        });
+        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: some more info");
+        });
+    });
+    describe("vault_historical_data action", () => {
+        it("transforms the response correctly", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                data: [
                     {
-                        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,
+                        timestamp: 1704067200,
+                        blockNumber: 12345678,
+                        apy: {
+                            base: 0.5,
+                            reward: 0.3,
+                            total: 0.8,
+                        },
+                        tvl: {
+                            usd: 1000000,
+                            native: 1000000,
+                        },
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+                fromDate: "2024-01-01T00:00:00Z",
+                toDate: "2024-01-02T00:00:00Z",
+                granularity: "1hour",
+                apyInterval: "1day",
+            };
+            const result = await provider.vaultHistoricalData(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toEqual({
+                data: [
+                    {
+                        timestamp: "2024-01-01T00:00:00.000Z",
+                        blockNumber: 12345678,
+                        apy: {
+                            base: "50.00%",
+                            reward: "30.00%",
+                            total: "80.00%",
+                        },
+                        tvl: {
+                            usd: 1000000,
+                            native: 1000000,
                         },
                     },
                 ],
@@ -492,112 +574,223 @@ describe("VaultsfyiActionProvider", () => {
             const args = {
                 vaultAddress: "0x123456",
                 network: "mainnet",
+                fromDate: "2024-01-01T00:00:00Z",
+                toDate: "2024-01-02T00:00:00Z",
+                granularity: "1hour",
+                apyInterval: "1day",
             };
-            expect(await provider.vaultDetails(mockWalletProvider, args)).toBe("Failed to fetch vault: Internal Server Error, some more info");
+            expect(await provider.vaultHistoricalData(mockWalletProvider, args)).toBe("Failed to fetch vault historical data: 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,
+    describe("rewards_context action", () => {
+        it("should return the response", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                data: [
+                    {
+                        some: "data",
+                    },
+                ],
+            }));
+            const response = await provider.rewardsContext(mockWalletProvider);
+            expect(JSON.parse(response)).toStrictEqual({ data: [{ some: "data" }] });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            expect(await provider.rewardsContext(mockWalletProvider)).toBe("Failed to fetch rewards context: some more info");
+        });
+    });
+    describe("get_benchmark_apy action", () => {
+        it("should transform the response correctly", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
                 apy: {
-                    base: 500,
-                    rewards: 300,
-                    total: 800,
+                    "1day": {
+                        base: 0.5,
+                        reward: 0.3,
+                        total: 0.8,
+                    },
+                    "7day": {
+                        base: 0.5,
+                        reward: 0.3,
+                        total: 0.8,
+                    },
+                    "30day": {
+                        base: 0.5,
+                        reward: 0.3,
+                        total: 0.8,
+                    },
                 },
+                timestamp: 1704067200,
+            }));
+            const args = {
+                network: "mainnet",
+                benchmarkCode: "eth",
             };
-            const mockTvlData = {
-                timestamp: 1704067200, // Jan 1, 2024
-                blockNumber: 12345678,
-                tvlDetails: {
-                    tvlUsd: 1000000,
+            const result = await provider.benchmarkApy(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toEqual({
+                apy: {
+                    "1day": {
+                        base: "50.00%",
+                        reward: "30.00%",
+                        total: "80.00%",
+                    },
+                    "7day": {
+                        base: "50.00%",
+                        reward: "30.00%",
+                        total: "80.00%",
+                    },
+                    "30day": {
+                        base: "50.00%",
+                        reward: "30.00%",
+                        total: "80.00%",
+                    },
                 },
-            };
-            // 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" }));
+                timestamp: new Date(1704067200 * 1000).toISOString(),
             });
+        });
+        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",
-                date: "2024-01-01T00:00:00Z",
+                benchmarkCode: "eth",
             };
-            const result = await provider.vaultHistoricalData(mockWalletProvider, args);
+            expect(await provider.benchmarkApy(mockWalletProvider, args)).toBe("Failed to fetch benchmark: some more info");
+        });
+    });
+    describe("historical_benchmark_apy action", () => {
+        it("should transform the response correctly", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                data: [
+                    {
+                        timestamp: 1704067200,
+                        apy: {
+                            "1day": {
+                                base: 0.5,
+                                reward: 0.3,
+                                total: 0.8,
+                            },
+                            "7day": {
+                                base: 0.5,
+                                reward: 0.3,
+                                total: 0.8,
+                            },
+                            "30day": {
+                                base: 0.5,
+                                reward: 0.3,
+                                total: 0.8,
+                            },
+                        },
+                    },
+                ],
+            }));
+            const args = {
+                network: "mainnet",
+                benchmarkCode: "eth",
+                fromDate: "2024-01-01T00:00:00Z",
+                toDate: "2024-01-02T00:00:00Z",
+                page: 1,
+                perPage: 10,
+            };
+            const result = await provider.historicalBenchmarkApy(mockWalletProvider, args);
             const parsedResult = JSON.parse(result);
             expect(parsedResult).toEqual({
-                apy: {
-                    apy: {
-                        base: 5,
-                        rewards: 3,
-                        total: 8,
+                data: [
+                    {
+                        timestamp: "2024-01-01T00:00:00.000Z",
+                        apy: {
+                            "1day": {
+                                base: "50.00%",
+                                reward: "30.00%",
+                                total: "80.00%",
+                            },
+                            "7day": {
+                                base: "50.00%",
+                                reward: "30.00%",
+                                total: "80.00%",
+                            },
+                            "30day": {
+                                base: "50.00%",
+                                reward: "30.00%",
+                                total: "80.00%",
+                            },
+                        },
                     },
-                    date: "2024-01-01T00:00:00.000Z",
-                    blockNumber: 12345678,
+                ],
+            });
+        });
+        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 = {
+                network: "mainnet",
+                benchmarkCode: "eth",
+                fromDate: "2024-01-01T00:00:00Z",
+                toDate: "2024-01-02T00:00:00Z",
+                page: 1,
+                perPage: 10,
+            };
+            expect(await provider.historicalBenchmarkApy(mockWalletProvider, args)).toBe("Failed to fetch historical benchmark: some more info");
+        });
+    });
+    describe("total_vault_returns action", () => {
+        it("should return the response", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                data: {
+                    totalReturns: 1000000,
                 },
-                tvl: {
-                    tvlInUsd: 1000000,
-                    date: "2024-01-01T00:00:00.000Z",
-                    blockNumber: 12345678,
+            }));
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+            };
+            const result = await provider.totalVaultReturns(mockWalletProvider, args);
+            expect(JSON.parse(result)).toEqual({
+                data: {
+                    totalReturns: 1000000,
                 },
             });
         });
-        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" }));
-            });
+        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",
-                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");
+            expect(await provider.totalVaultReturns(mockWalletProvider, args)).toBe("Failed to fetch total vault returns: some more info");
         });
-        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, {
+    });
+    describe("user_events action", () => {
+        it("should transform the response correctly", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                data: [
+                    {
                         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" }));
+                        action: "deposit",
+                        amount: 1000000,
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+            };
+            const result = await provider.userEvents(mockWalletProvider, args);
+            expect(JSON.parse(result)).toEqual({
+                data: [
+                    {
+                        timestamp: "2024-01-01T00:00:00.000Z",
+                        action: "deposit",
+                        amount: 1000000,
+                    },
+                ],
             });
+        });
+        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",
-                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");
+            expect(await provider.userEvents(mockWalletProvider, args)).toBe("Failed to fetch user events: some more info");
         });
     });
 });