@merkl/api 0.20.3 → 0.20.4

package/dist/src/cache/declaration.d.ts

@@ -32,7 +32,7 @@ export declare const CacheDeclaration: {
     };
     EulerV2Vaults: {
         compressed: false;
-        redisTTL: TTLType.Hours3;
+        redisTTL: TTLType.Day;
         localCache: false;
     };
     CompoundV2ForksVaults: {
@@ -127,7 +127,7 @@ export declare const CacheDeclaration: {
     };
     UniswapV4Pools: {
         compressed: false;
-        redisTTL: TTLType.Hours3;
+        redisTTL: TTLType.Day;
         localCache: false;
     };
 };

package/dist/src/cache/declaration.js

@@ -20,7 +20,7 @@ export const CacheDeclaration = {
     },
     EulerV2Vaults: {
         compressed: false,
-        redisTTL: TTLType.Hours3,
+        redisTTL: TTLType.Day,
         localCache: false,
     },
     CompoundV2ForksVaults: {
@@ -115,7 +115,7 @@ export const CacheDeclaration = {
     },
     UniswapV4Pools: {
         compressed: false,
-        redisTTL: TTLType.Hours3,
+        redisTTL: TTLType.Day,
         localCache: false,
     },
 };

package/dist/src/engine/dynamicData/utils/getEulerV2Vaults.d.ts

@@ -4,5 +4,4 @@ export declare enum LoggedEntityType {
     UNISWAP_V4 = "UNISWAP_V4"
 }
 export declare function getEulerV2Vaults(): Promise<EulerVaultType[]>;
-export declare const getEulerV2VaultsWithCache: () => Promise<EulerVaultType[]>;
 export declare function updateEulerVaultsCollatInDatabase(): Promise<void>;

package/dist/src/engine/dynamicData/utils/getEulerV2Vaults.js

@@ -1,7 +1,6 @@
-import { Redis } from "@/cache";
 import { fetchEulerVaultName } from "@/engine/erc20SubTypeProcessors/helpers/eulerVaultNames";
 import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { log } from "@/utils/logger";
+import { log, logger } from "@/utils/logger";
 import { providers } from "@/utils/providers";
 import { apiDbClient } from "@db";
 import { ChainInteractionService, ERC20Interface, EULER_ADDRESSES, EulerEVKInterface, EulerVaultLensInterface, EulerVault__factory, NETWORK_LABELS, eulerChainIds, getContractCreationBlock, } from "@sdk";
@@ -27,59 +26,93 @@ async function computeCollatListAndReturnVaults(chainId, vaults) {
             };
         }),
     });
-    const callsCollatUnderlying = [];
-    const callsCollatUnderlyingSymbol = [];
+    const callsToCollat = [];
+    const callsToCollatUnderlying = [];
+    // To keep track of all collat data
+    const collateralDataArray = [];
+    let k = 0;
     for (const [index, vault] of vaults.entries()) {
         const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
         for (const collat of collatArray) {
+            // FIXME
             if (!!vault.collaterals &&
-                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase()))
+                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase())) {
                 continue;
+            }
             log.info(`🦭 found new collateral ${collat.collateral} for vault ${vault.address} (${NETWORK_LABELS[chainId]})`);
-            callsCollatUnderlying.push({
+            collateralDataArray.push({ vaultAddress: vault.address, address: collat.collateral, callsToCollatIndex: k });
+            k++;
+            callsToCollat.push({
                 allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("asset"),
+                callData: EulerEVKInterface.encodeFunctionData("symbol"),
                 target: collat.collateral,
             }, {
                 allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("symbol"),
+                callData: EulerEVKInterface.encodeFunctionData("asset"),
                 target: collat.collateral,
             });
         }
     }
-    const resCollatUnderlying = await batchMulticallCallWithRetry(chainId, {
-        calls: callsCollatUnderlying,
+    const resCallsToCollat = await batchMulticallCallWithRetry(chainId, {
+        calls: callsToCollat,
     });
-    for (let i = 0; i < resCollatUnderlying.length; i = i + 2) {
-        const underlyingToken = EulerEVKInterface.decodeFunctionResult("asset", resCollatUnderlying[i].returnData)[0];
-        callsCollatUnderlyingSymbol.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("symbol"),
-            target: underlyingToken,
+    let j = 0;
+    for (let i = 0; i < resCallsToCollat.length; i = i + 2) {
+        const collatData = collateralDataArray.find(collat => collat.callsToCollatIndex === i / 2);
+        try {
+            // 1_ Collat symbol
+            const symbolCollateral = EulerEVKInterface.decodeFunctionResult("symbol", resCallsToCollat[i].returnData)[0];
+            collatData.symbolCollateral = symbolCollateral;
+            // 2_ Underlying asset => warning it can be undefined and throw an error
+            const underlyingToken = EulerEVKInterface.decodeFunctionResult("asset", resCallsToCollat[i + 1].returnData)[0];
+            callsToCollatUnderlying.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target: underlyingToken,
+            });
+            collatData.callsToCollatUnderlyingIndex = j;
+            j++;
+        }
+        catch {
+            logger.warn(`🦭 error while decoding underlying token address for collat ${JSON.stringify(collatData)}`);
+        }
+    }
+    let resCallsToCollatUnderlying;
+    if (callsToCollatUnderlying.length > 0) {
+        resCallsToCollatUnderlying = await batchMulticallCallWithRetry(chainId, {
+            calls: callsToCollatUnderlying,
         });
     }
-    const resCollatUnderlyingSymbol = await batchMulticallCallWithRetry(chainId, {
-        calls: callsCollatUnderlyingSymbol,
-    });
     vaultsPerChain = vaultsPerChain.concat((await Promise.all(vaults.map(async (vault, index) => {
         const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
         if (!vault.collaterals)
             vault.collaterals = [];
-        let offset = 0;
         for (const [_index, collat] of collatArray.entries()) {
             // _ Check whether the collat was already registered
             if (!!vault.collaterals &&
                 vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase())) {
-                offset += 1;
                 continue;
             }
-            const symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCollatUnderlyingSymbol[_index - offset].returnData)[0];
+            const collatData = collateralDataArray.find(c => c.vaultAddress?.toLowerCase() === vault.address?.toLowerCase() && c.address === collat.collateral);
+            if (!collatData || collatData.address !== collat.collateral) {
+                logger.warn(`🦭 issue when fetching data for collat ${collat.collateral} on vault ${vault.address}`);
+                console.log(collatData, collat.collateral);
+                process.exit(1);
+            }
+            // Collateral symbol
+            const symbolCollateral = collatData.symbolCollateral ?? "Unknown";
+            // Collat underlying symbol
+            let symbolUnderlying = "Unknown";
+            try {
+                symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCallsToCollatUnderlying[collatData.callsToCollatUnderlyingIndex ?? -1].returnData)[0];
+            }
+            catch { }
             vault.collaterals.push({
                 address: collat.collateral,
-                symbolCollateral: EulerEVKInterface.decodeFunctionResult("symbol", resCollatUnderlying[2 * (_index - offset) + 1].returnData)[0],
-                symbolUnderlying,
+                symbolCollateral: symbolCollateral,
+                symbolUnderlying: symbolUnderlying,
                 borrowLTV: collat.borrowLTV.toString(),
-                nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolUnderlying,
+                nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolCollateral,
             });
         }
         return { ...vault };
@@ -113,20 +146,26 @@ export async function getEulerV2Vaults() {
             }
             const logs = await safeFetchLogs(chainId, [EulerEVKInterface.getEventTopic("EVaultCreated")], [], fromBlock, toBlock);
             const decodedVaults = await Promise.all(logs.map(async (log) => {
-                const aux = EulerEVKInterface.decodeEventLog("EVaultCreated", log.data, log.topics);
-                const name = (await EulerVault__factory.connect(log.address, providers[chainId]).name()).split(" ");
-                const vaultName = (await fetchEulerVaultName(getAddress(log.address), chainId)) ?? name[name.length - 1];
-                /** Respect the previous typing */
-                return {
-                    address: log.address.toString(),
-                    asset: aux[1].toString(),
-                    fetchedAtBlock: Number(log.blockNumber),
-                    chainId: chainId,
-                    debtTokenAddress: aux[2].toString(),
-                    name: vaultName,
-                };
+                try {
+                    const aux = EulerEVKInterface.decodeEventLog("EVaultCreated", log.data, log.topics);
+                    const name = (await EulerVault__factory.connect(log.address, providers[chainId]).name()).split(" ");
+                    const vaultName = (await fetchEulerVaultName(getAddress(log.address), chainId)) ?? name[name.length - 1];
+                    /** Respect the previous typing */
+                    return {
+                        address: log.address.toString(),
+                        asset: aux[1].toString(),
+                        fetchedAtBlock: Number(log.blockNumber),
+                        chainId: chainId,
+                        debtTokenAddress: aux[2].toString(),
+                        name: vaultName,
+                    };
+                }
+                catch {
+                    logger.warn(`issue when fetching data on ${NETWORK_LABELS[chainId]} for vault ${log.address}`);
+                    process.exit(1);
+                }
             }));
-            log.local(`fetched ${decodedVaults.length} vaults(s) on ${NETWORK_LABELS[chainId]} between blocks ${fromBlock} and ${toBlock}`);
+            log.info(`fetched ${decodedVaults.length} vaults(s) on ${NETWORK_LABELS[chainId]} between blocks ${fromBlock} and ${toBlock}`);
             vaultsPerChain = await computeCollatListAndReturnVaults(chainId, decodedVaults);
             return vaultsPerChain;
         }
@@ -160,14 +199,12 @@ export async function getEulerV2Vaults() {
             throw new Error("Error while saving vaults to API database (`Logged` table)");
         }
     }
-    log.info("✅ successfully fetched new vaults on Euler V2");
     if (storedVaults.length > 0) {
         vaults = vaults.concat(storedVaults.map(v => v.entityData));
     }
     log.info("👋 exiting getEulerV2Vaults");
     return vaults;
 }
-export const getEulerV2VaultsWithCache = async () => await Redis.getOrSet("EulerV2Vaults", getEulerV2Vaults);
 export async function updateEulerVaultsCollatInDatabase() {
     // 0_ Fetch all euler vaults from database
     const vaults = await apiDbClient.logged.findMany({

package/dist/src/engine/erc20SubTypeProcessors/implementations/EulerLendProcessor.js

@@ -1,4 +1,5 @@
 import { generateCardName } from "@/utils/generateCardName";
+import { log } from "@/utils/logger";
 import { BN2Number } from "@sdk";
 import { GenericProcessor } from "../GenericProcessor";
 import { fetchEulerVaultName } from "../helpers/eulerVaultNames";
@@ -18,8 +19,12 @@ export class EulerLendProcessor extends GenericProcessor {
     async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const symbolAsset = campaign.campaignParameters.symbolAsset;
-        const decimalsAsset = Number(campaign.campaignParameters.decimalsAsset);
+        let decimalsAsset = Number(campaign.campaignParameters.decimalsAsset) ?? 18;
         const priceAsset = (await pricer.get({ symbol: symbolAsset })) ?? 1;
+        if (Number.isNaN(decimalsAsset)) {
+            log.warn(`decimalsAsset is NaN for ${symbolAsset} on campaign ${campaign.campaignId}`);
+            decimalsAsset = 18;
+        }
         const totalAssets = BN2Number(typeInfo.totalAssets, decimalsAsset);
         typeInfo.symbolUnderlyingToken = symbolAsset;
         let cardName = generateCardName(type, typeInfo, campaign);

package/dist/src/jobs/update-euler-vaults.d.ts

@@ -1 +1 @@
-export declare function updateEulerVaultsCollatInDatabase(): Promise<void>;
+export {};

package/dist/src/jobs/update-euler-vaults.js

@@ -1,122 +1,6 @@
 import { Redis } from "@/cache";
-import { LoggedEntityType, getEulerV2Vaults } from "@/engine/dynamicData/utils/getEulerV2Vaults";
-import { fetchEulerVaultName } from "@/engine/erc20SubTypeProcessors/helpers/eulerVaultNames";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { log } from "@/utils/logger";
-import { apiDbClient } from "@db";
-import { ERC20Interface, EULER_ADDRESSES, EulerEVKInterface, EulerVaultLensInterface, NETWORK_LABELS, eulerChainIds, } from "@sdk";
-import _ from "lodash";
-async function computeCollatListAndReturnVaults(chainId, vaults) {
-    let vaultsPerChain = [];
-    /** Extra calls batch to get the collateral addresses */
-    const resCollat = await batchMulticallCallWithRetry(chainId, {
-        calls: vaults
-            .map(vault => vault.address)
-            .map(vaultAddress => {
-            return {
-                allowFailure: true,
-                callData: EulerVaultLensInterface.encodeFunctionData("getRecognizedCollateralsLTVInfo", [vaultAddress]),
-                target: EULER_ADDRESSES[chainId].VAULT_LENS,
-            };
-        }),
-    });
-    const callsCollatUnderlying = [];
-    const callsCollatUnderlyingSymbol = [];
-    for (const [index, vault] of vaults.entries()) {
-        const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
-        for (const collat of collatArray) {
-            if (!!vault.collaterals &&
-                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase()))
-                continue;
-            log.info(`🦭 found new collateral ${collat.collateral} for vault ${vault.address} (${NETWORK_LABELS[chainId]})`);
-            callsCollatUnderlying.push({
-                allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("asset"),
-                target: collat.collateral,
-            }, {
-                allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("symbol"),
-                target: collat.collateral,
-            });
-        }
-    }
-    const resCollatUnderlying = await batchMulticallCallWithRetry(chainId, {
-        calls: callsCollatUnderlying,
-    });
-    for (let i = 0; i < resCollatUnderlying.length; i = i + 2) {
-        const underlyingToken = EulerEVKInterface.decodeFunctionResult("asset", resCollatUnderlying[i].returnData)[0];
-        callsCollatUnderlyingSymbol.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("symbol"),
-            target: underlyingToken,
-        });
-    }
-    const resCollatUnderlyingSymbol = await batchMulticallCallWithRetry(chainId, {
-        calls: callsCollatUnderlyingSymbol,
-    });
-    vaultsPerChain = vaultsPerChain.concat((await Promise.all(vaults.map(async (vault, index) => {
-        const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
-        if (!vault.collaterals)
-            vault.collaterals = [];
-        let offset = 0;
-        for (const [_index, collat] of collatArray.entries()) {
-            // _ Check whether the collat was already registered
-            if (!!vault.collaterals &&
-                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase())) {
-                offset += 1;
-                continue;
-            }
-            const symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCollatUnderlyingSymbol[_index - offset].returnData)[0];
-            vault.collaterals.push({
-                address: collat.collateral,
-                symbolCollateral: EulerEVKInterface.decodeFunctionResult("symbol", resCollatUnderlying[2 * (_index - offset) + 1].returnData)[0],
-                symbolUnderlying,
-                borrowLTV: collat.borrowLTV.toString(),
-                nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolUnderlying,
-            });
-        }
-        return { ...vault };
-    }))));
-    return vaultsPerChain;
-}
-export async function updateEulerVaultsCollatInDatabase() {
-    // 0_ Fetch all euler vaults from database
-    const vaults = await apiDbClient.logged.findMany({
-        where: { type: LoggedEntityType.EULER },
-    });
-    const clonedVaults = _.cloneDeep(vaults);
-    let toUpdateVaults = [];
-    // 1_ Return all vaults already stored with their collateral updated
-    const res = await Promise.all(eulerChainIds.map(async (chainId) => computeCollatListAndReturnVaults(chainId, clonedVaults.filter(entity => entity.chainId === chainId).map(entity => entity.entityData))));
-    for (const resPerChain of res) {
-        if (!!resPerChain && resPerChain.length > 0) {
-            toUpdateVaults = toUpdateVaults.concat(resPerChain.filter(updatedVault => {
-                return (updatedVault.collaterals.length >
-                    vaults.find(vault => vault.address?.toLowerCase() === updatedVault.address.toLowerCase())
-                        ?.entityData?.collaterals.length);
-            }));
-        }
-    }
-    // 2_ Update the API database
-    if (toUpdateVaults.length > 0) {
-        try {
-            for (const vault of toUpdateVaults) {
-                await apiDbClient.logged.updateMany({
-                    where: {
-                        address: vault.address,
-                        chainId: vault.chainId,
-                    },
-                    data: {
-                        entityData: vault,
-                    },
-                });
-            }
-            log.info(`✅ successfully updated ${toUpdateVaults.length} vault(s) collaterals in API database ('Logged' table)`);
-        }
-        catch {
-            throw new Error("Error while updating vaults to API database (`Logged` table)");
-        }
-    }
-}
-await updateEulerVaultsCollatInDatabase();
-await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
+import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dynamicData/utils/getEulerV2Vaults";
+(async () => {
+    await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
+    await updateEulerVaultsCollatInDatabase();
+})();

package/dist/src/modules/v4/icon/icon.model.d.ts

@@ -0,0 +1,4 @@
+export type FileMetadata = {
+    name?: string;
+    extension?: string;
+};

package/dist/src/modules/v4/icon/icon.model.js

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/v4/icon/icon.service.d.ts

@@ -0,0 +1,5 @@
+import type { BucketService } from "../bucket/bucket.service";
+import type { FileMetadata } from "./icon.model";
+export declare abstract class IconService {
+    static pullPush(url: string, bucket: BucketService, metadata?: FileMetadata): Promise<number>;
+}

package/dist/src/modules/v4/icon/icon.service.js

@@ -0,0 +1,15 @@
+export class IconService {
+    static async pullPush(url, bucket, metadata) {
+        const filename = metadata?.name ?? url;
+        const iconFile = await fetch(url);
+        const mimeType = iconFile.headers.get("content-type");
+        const extension = metadata?.extension ? metadata.extension : mimeType.split("/")[1].split("+")[0];
+        const byteArray = await iconFile.bytes();
+        return await bucket.pushRaw(`${filename}.${extension}`, byteArray, {
+            type: mimeType,
+            isPublic: true,
+            compression: true,
+            overwrite: true,
+        });
+    }
+}

package/dist/src/modules/v4/programPayload/programPayload.repository.js

@@ -96,6 +96,10 @@ const blacklistEtherlink = [
     "0x9D0E0e95305872E0f8065093b66E5FA224B5826f",
     "0xa0E147eA78D8d696D73bbd43dE353b3ab076B3a0",
     "0x196A8F57ff3AfB509f0014EDBa108A0BFeF0a84a",
+    "0x8F6dcd0db53029d1116E86DA6d38Bf047f504e08",
+    "0x1CC9F701399f586568F2B0498b137c561B288F6B",
+    "0xB387D0A73619791420De4a1e5e710023Cb0f49c0",
+    "0xA0fc58e4EE3a3E183dfa492147C97e81D42f5C86",
 ];
 export var swapxCampaigns;
 (function (swapxCampaigns) {

package/dist/src/modules/v4/token/token.service.js

@@ -10,6 +10,7 @@ import { getAddress, parseUnits } from "viem";
 import { BucketService } from "../bucket/bucket.service";
 import { CacheService } from "../cache";
 import { TTLPresets } from "../cache/cache.model";
+import { IconService } from "../icon/icon.service";
 import { PriceService } from "../price";
 import { TokenRepository } from "./token.repository";
 export class TokenService {
@@ -291,9 +292,9 @@ export class TokenService {
         const bucket = new BucketService(`merkl-${env}-tokens`, `angle-${env}-1`);
         const properties = body.data.properties;
         const file = properties["Icon (Required)"].files[0];
-        const icon = "external" in file ? file.external.url : file.file.url;
-        const iconFile = await fetch(icon);
-        const mimeType = iconFile.headers.get("content-type");
+        const iconURL = "external" in file ? file.external.url : file.file.url;
+        const icon = await fetch(iconURL);
+        const mimeType = icon.headers.get("content-type");
         const extension = mimeType.split("/")[1].split("+")[0];
         const address = throwOnInvalidRequiredAddress(properties["Address (in checksum format) (Required)"].rich_text[0].plain_text);
         const chainId = properties["Chain ID (Required)"].number;
@@ -301,7 +302,6 @@ export class TokenService {
         const displaySymbol = properties["Symbol (Optional)"].rich_text[0]?.plain_text;
         const isVerified = properties.Verified.checkbox;
         const coingeckoApiId = properties["CoinGecko API ID (Recommended)"].rich_text[0]?.plain_text;
-        const byteArray = await iconFile.bytes(); // Unknown type error here probably due to bun/types
         const [token] = await TokenService.findManyOrCreate([
             {
                 chainId,
@@ -311,15 +311,12 @@ export class TokenService {
         if (!token || !token.name)
             throw new HttpError(`Failed to fetch on-chain data for token ${token?.symbol} (${address} on chainId ${chainId}).`);
         try {
-            await bucket.pushRaw(`${chainId}/${address}.${extension}`, byteArray, {
-                type: mimeType,
-                isPublic: true,
-            });
+            await IconService.pullPush(iconURL, bucket, { name: `${chainId}/${address}` });
             token.icon = `${process.env.GCS_ENDPOINT}/merkl-${env}-tokens/${chainId}/${address}.${extension}`;
         }
         catch (err) {
             console.error(err);
-            token.icon = icon;
+            token.icon = iconURL;
         }
         if (coingeckoApiId) {
             try {

package/dist/src/routes/v3/euler.d.ts

@@ -1,10 +1,4 @@
 import { type Elysia } from "elysia";
-export declare const response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-    address: import("@sinclair/typebox").TString;
-    asset: import("@sinclair/typebox").TString;
-    chaind: import("@sinclair/typebox").TNumber;
-    debtTokenAddress: import("@sinclair/typebox").TString;
-}>>;
 declare const _default: (app: Elysia) => Elysia<"", false, {
     decorator: {};
     store: {};

package/dist/src/routes/v3/euler.js

@@ -1,9 +1,9 @@
-import { getEulerV2VaultsWithCache, updateEulerVaultsCollatInDatabase, } from "@/engine/dynamicData/utils/getEulerV2Vaults";
+import { Redis } from "@/cache";
+import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dynamicData/utils/getEulerV2Vaults";
 import { t } from "elysia";
-export const response = t.Array(t.Object({ address: t.String(), asset: t.String(), chaind: t.Number(), debtTokenAddress: t.String() }));
 export default (app) => app
     .get("/euler", async () => {
-    return await getEulerV2VaultsWithCache();
+    return await Redis.getOrSet("EulerV2Vaults", getEulerV2Vaults);
 }, {
     query: t.Object({}),
     tags: ["euler"],