@merkl/api 0.10.146 → 0.10.148

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

@@ -92,7 +92,7 @@ export declare const CacheDeclaration: {
     };
     MerklChainData: {
         compressed: false;
-        redisTTL: TTLType.Hours12;
+        redisTTL: TTLType.Minutes30;
         localCache: false;
     };
     Opportunities: {

package/dist/src/cache/declaration.js

@@ -80,7 +80,7 @@ export const CacheDeclaration = {
     },
     MerklChainData: {
         compressed: false,
-        redisTTL: TTLType.Hours12,
+        redisTTL: TTLType.Minutes30,
         localCache: false,
     },
     Opportunities: {

package/dist/src/libs/campaigns/utils/getEulerV2Vaults.js

@@ -2,86 +2,100 @@ import { Redis } from "../../../cache";
 import { batchMulticallCallWithRetry } from "../../../utils/generic";
 import { log } from "../../../utils/logger";
 import { providers } from "../../../utils/providers";
-import { ChainId, ERC20Interface, EulerEVKInterface, EulerVaultLensInterface, EulerVault__factory, } from "@sdk";
+import { ChainId, ERC20Interface, EulerEVKInterface, EulerVaultLensInterface, EulerVault__factory, NETWORK_LABELS, } from "@sdk";
 import { getAddress } from "ethers/lib/utils";
 import { fetchEulerVaultName } from "../campaignTypes/ERC20SubTypes/helpers/eulerVaultNames";
 import { safeFetchLogs } from "./fetchLogs";
-const VAULT_LENS_ADDRESS = { [ChainId.MAINNET]: "0x57904B4DF131F00DEE9BB75a8FA1D27744035c90" };
+const VAULT_LENS_ADDRESS = {
+    [ChainId.MAINNET]: "0x57904B4DF131F00DEE9BB75a8FA1D27744035c90",
+    [ChainId.SWELL]: "0x7caA3c60D730D94D4b5E0E80E3b7D461fD153526",
+};
+const EVC_CREATION_BLOCK = {
+    [ChainId.MAINNET]: 20529207,
+    [ChainId.SWELL]: 485320,
+};
+const eulerChainds = [ChainId.MAINNET, ChainId.SWELL];
 async function getEulerV2Vaults() {
-    const chainId = ChainId.MAINNET;
-    const fromBlock = 20529207; // EVC contract creation block
-    const toBlock = await providers[chainId].getBlockNumber();
-    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(),
-            chainId: chainId,
-            debtTokenAddress: aux[2].toString(),
-            name: vaultName,
-        };
-    }));
-    log.local(`fetched ${decodedVaults.length} vaults(s) between blocks ${fromBlock} and ${toBlock}`);
-    log.local(`fetched ${decodedVaults.length} vaults(s) between blocks ${fromBlock} and ${toBlock}`);
-    /** Extra calls batch to get the collateral addresses */
-    const resCollat = await batchMulticallCallWithRetry(chainId, {
-        calls: decodedVaults.map(vault => {
-            return {
-                allowFailure: true,
-                callData: EulerVaultLensInterface.encodeFunctionData("getRecognizedCollateralsLTVInfo", [vault.address]),
-                target: VAULT_LENS_ADDRESS[ChainId.MAINNET],
-            };
-        }),
-    });
-    const callsCollatUnderlying = [];
-    const callsCollatUnderlyingSymbol = [];
-    for (const [index, _] of decodedVaults.entries()) {
-        const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
-        for (const collat of collatArray) {
-            callsCollatUnderlying.push({
-                allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("asset"),
-                target: collat.collateral,
-            }, {
-                allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("symbol"),
-                target: collat.collateral,
+    let vaults = [];
+    for (const chainId of eulerChainds) {
+        try {
+            const fromBlock = EVC_CREATION_BLOCK[chainId] ?? 0; // EVC contract creation block
+            const toBlock = await providers[chainId].getBlockNumber();
+            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(),
+                    chainId: chainId,
+                    debtTokenAddress: aux[2].toString(),
+                    name: vaultName,
+                };
+            }));
+            log.local(`fetched ${decodedVaults.length} vaults(s) on ${NETWORK_LABELS[chainId]} between blocks ${fromBlock} and ${toBlock}`);
+            /** Extra calls batch to get the collateral addresses */
+            const resCollat = await batchMulticallCallWithRetry(chainId, {
+                calls: decodedVaults.map(vault => {
+                    return {
+                        allowFailure: true,
+                        callData: EulerVaultLensInterface.encodeFunctionData("getRecognizedCollateralsLTVInfo", [vault.address]),
+                        target: VAULT_LENS_ADDRESS[ChainId.MAINNET],
+                    };
+                }),
             });
-        }
-    }
-    const resCollatUnderlying = await batchMulticallCallWithRetry(ChainId.MAINNET, {
-        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.MAINNET, {
-        calls: callsCollatUnderlyingSymbol,
-    });
-    const vaults = (await Promise.all(decodedVaults.map(async (decodedVault, index) => {
-        const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
-        const collaterals = [];
-        for (const [_index, collat] of collatArray.entries()) {
-            const symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCollatUnderlyingSymbol[_index].returnData)[0];
-            collaterals.push({
-                address: collat.collateral,
-                symbolCollateral: EulerEVKInterface.decodeFunctionResult("symbol", resCollatUnderlying[2 * _index + 1].returnData)[0],
-                symbolUnderlying,
-                borrowLTV: collat.borrowLTV.toString(),
-                nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolUnderlying,
+            const callsCollatUnderlying = [];
+            const callsCollatUnderlyingSymbol = [];
+            for (const [index, _] of decodedVaults.entries()) {
+                const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
+                for (const collat of collatArray) {
+                    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.MAINNET, {
+                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.MAINNET, {
+                calls: callsCollatUnderlyingSymbol,
+            });
+            vaults = vaults.concat((await Promise.all(decodedVaults.map(async (decodedVault, index) => {
+                const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
+                const collaterals = [];
+                for (const [_index, collat] of collatArray.entries()) {
+                    const symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCollatUnderlyingSymbol[_index].returnData)[0];
+                    collaterals.push({
+                        address: collat.collateral,
+                        symbolCollateral: EulerEVKInterface.decodeFunctionResult("symbol", resCollatUnderlying[2 * _index + 1].returnData)[0],
+                        symbolUnderlying,
+                        borrowLTV: collat.borrowLTV.toString(),
+                        nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolUnderlying,
+                    });
+                }
+                return { ...decodedVault, collaterals };
+            }))));
+        }
+        catch (e) {
+            log.error(`issue when fetching vaults on ${chainId}`, e);
         }
-        return { ...decodedVault, collaterals };
-    })));
+    }
     return vaults;
 }
 export const getEulerV2VaultsWithCache = async () => await Redis.getOrSet("EulerV2Vaults", getEulerV2Vaults);