@merkl/api 0.20.2 → 0.20.4

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);