@merkl/api 0.21.47 → 1.0.0

package/dist/src/engine/deprecated/dynamicData/utils/fetchLogs.js

@@ -1,149 +0,0 @@
-import { log } from "@/utils/logger";
-import { ChainId, ChainInteractionService, getContractCreationBlock } from "@sdk";
-import axios from "axios";
-export async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
-    const url = ChainInteractionService(chainId).provider().connection.url;
-    if (fromBlock === undefined || fromBlock === null || !toBlock || fromBlock > toBlock) {
-        throw new Error(`fromBlock and toBlock are required and fromBlock must be less than toBlock - fromBlock: ${fromBlock} - toBlock:${toBlock}`);
-    }
-    // Take the min of all address creation blocks
-    if (fromBlock === 0) {
-        let contractCreationBlock = toBlock;
-        for (const address of addresses) {
-            try {
-                const aux = await getContractCreationBlock(address, ChainInteractionService(chainId).provider());
-                if (aux < contractCreationBlock) {
-                    contractCreationBlock = aux;
-                }
-            }
-            catch {
-                contractCreationBlock = 0;
-                log.warn(`⚠️ couldn't get contract creation blocknumber for ${address}`);
-            }
-        }
-        fromBlock = contractCreationBlock;
-    }
-    const headers = {
-        accept: "application/json",
-        "content-type": "application/json",
-    };
-    let tempFromBlock = fromBlock;
-    let tempToBlock = toBlock;
-    log.info(`⏳ fetching logs between blocks ${fromBlock} and ${toBlock}`);
-    let step = tempToBlock - tempFromBlock;
-    // Binary search to fetch logs and avoid errors
-    let logs = [];
-    // Binary search to fetch logs and avoid errors
-    let isRateLimitingError = false;
-    let stepLimited = false;
-    const maxLogsPerRequest = 10_000;
-    while (true) {
-        try {
-            const data = {
-                id: 1,
-                jsonrpc: "2.0",
-                method: "eth_getLogs",
-                params: [
-                    {
-                        address: addresses,
-                        topics: topics,
-                        fromBlock: `0x${(tempFromBlock).toString(16)}`, // fromBlock is included
-                        toBlock: `0x${tempToBlock.toString(16)}`, // toBlock is included
-                    },
-                ],
-            };
-            try {
-                const res = await axios.post(url, data, { headers });
-                if (res?.data?.error?.code === -32602)
-                    throw new Error("Log size exceeded");
-                if (res.data.error?.code === 429) {
-                    isRateLimitingError = true;
-                    throw new Error("Rate Limiting");
-                }
-                if (res.data.error?.code === 413) {
-                    throw new Error("Request entity too large");
-                }
-                if (res.data.error?.code === -32000 && chainId === ChainId.AVALANCHE) {
-                    stepLimited = true;
-                    step = 2047 * 2;
-                    throw new Error("Block width exceeded");
-                }
-                if (res.data.error?.code === -32000 && chainId === ChainId.BSC) {
-                    // Reall error is: " block not found x"
-                    throw new Error("Log size exceeded");
-                }
-                // Check if we hit the maximum log limit for a single call
-                if (res.data.result?.length === 10000)
-                    throw new Error("Log size exceeded");
-                const logsBatch = res.data.result || [];
-                logs = logs.concat(...logsBatch);
-                const batchSize = logsBatch.length;
-                const blockRange = tempToBlock - tempFromBlock + 1;
-                if (!stepLimited) {
-                    if (batchSize === 0) {
-                        // Add safeguard for 0 logs case
-                        // If no logs found, increase step size
-                        step = Math.floor(step * 2);
-                    }
-                    else {
-                        // Aggressive adjustment based on how far we are from optimal logs per request
-                        const optimalLogsPerRequest = maxLogsPerRequest * 0.7; // Target 70% of max logs per request
-                        const logsPerRequestRatio = batchSize / optimalLogsPerRequest;
-                        if (batchSize < maxLogsPerRequest * 0.8) {
-                            // More aggressive adjustment when far from target
-                            const adjustmentFactor = (1 / logsPerRequestRatio) ** 0.7; // Non-linear scaling
-                            step = Math.floor(step * adjustmentFactor);
-                            // Allow for larger jumps when log density is very low
-                            if (logsPerRequestRatio < 0.2) {
-                                step = Math.floor(step * 2);
-                            }
-                        }
-                        else {
-                            // Quick reduction when close to limit
-                            step = Math.floor(step * 0.4);
-                        }
-                    }
-                }
-                log.local(`fetched ${batchSize} logs between blocks ${tempFromBlock} and ${tempToBlock} (block range: ${blockRange})`);
-            }
-            catch (e) {
-                if (e.toString() === "Error: Request failed with status code 429") {
-                    isRateLimitingError = true;
-                }
-                if (isRateLimitingError) {
-                    /** Sleeping to reduce the chances of being rate limited */
-                    await new Promise(resolve => setTimeout(resolve, 10_000));
-                    throw new Error("Rate Limiting");
-                }
-                const message = `error making POST request: ${e}`;
-                log.error("fetchLogs", message);
-                throw new Error(message);
-            }
-            if (tempToBlock === toBlock)
-                break;
-            tempFromBlock = Math.min(tempToBlock + 1, toBlock);
-            tempToBlock = Math.min(tempToBlock + step, toBlock);
-        }
-        catch {
-            if (!isRateLimitingError) {
-                step = Math.floor(step / 2);
-            }
-            else {
-                isRateLimitingError = false;
-            }
-            if (step === 0) {
-                log.error("❌ fetchLogs", `error fetching logs for ${addresses} on ${ChainId[chainId]}`);
-                return { logs, block: tempFromBlock };
-            }
-            tempToBlock = tempFromBlock + step;
-        }
-    }
-    return { logs, block: toBlock };
-}
-export async function safeFetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
-    const { logs, block } = await fetchLogs(chainId, topics, addresses, fromBlock, toBlock);
-    if (block !== toBlock) {
-        throw new Error(`error fetching logs for ${addresses}`);
-    }
-    return logs;
-}

package/dist/src/engine/deprecated/dynamicData/utils/getCompV2ForksVaults.js

@@ -1,141 +0,0 @@
-import { Redis } from "@/cache";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { log } from "@/utils/logger";
-import { providers } from "@/utils/providers";
-import { CTokenInterface, ChainId, CompFork, Comptrollers, ERC20Interface, NULL_ADDRESS, } from "@sdk";
-import { defaultAbiCoder } from "ethers/lib/utils";
-import { safeFetchLogs } from "./fetchLogs";
-import { getContractCreationBlock } from "./getContractCreationBlock";
-const MARKET_SUPPORTED_EVENT_HASH = "0xaf16ad15f9e29d5140e8e81a30a92a755aa8edff3d301053c84392b70c0d09a3"; // For the case of Venus
-const MARKET_LISTED_EVENT_HASH = "0xcf583bb0c569eb967f806b11601c4cb93c10310485c67add5f8362c2f212321f";
-async function getCompoundV2ForksVaults() {
-    const compoundVaults = {};
-    //TODO can be optimized by looking to the same event over all forks for the same chain, then filtering out for each fork
-    for (const compFork of Object.keys(Comptrollers).map(compFork => Number(compFork))) {
-        for (const chainId of Object.keys(Comptrollers[compFork]).map(compFork => Number(compFork))) {
-            if ([ChainId.LINEA].includes(chainId)) {
-                continue;
-            }
-            log.local(`Fetching Compound V2 vaults on ${ChainId[chainId]}, for ${CompFork[compFork]}`);
-            const toBlock = await providers[chainId].getBlockNumber();
-            const comptrollerAddress = Comptrollers[compFork][chainId];
-            if (!comptrollerAddress) {
-                continue;
-            }
-            const creationBlock = (await getContractCreationBlock(comptrollerAddress, providers[chainId])) ?? 0;
-            let logs = [];
-            let topic;
-            if (compFork === CompFork.Venus && (chainId === ChainId.ZKSYNC || chainId === ChainId.UNICHAIN)) {
-                topic = MARKET_SUPPORTED_EVENT_HASH;
-            }
-            else if (compFork === CompFork.Enclabs) {
-                topic = MARKET_SUPPORTED_EVENT_HASH;
-            }
-            else {
-                topic = MARKET_LISTED_EVENT_HASH;
-            }
-            logs = await safeFetchLogs(chainId, [topic], [comptrollerAddress], creationBlock, toBlock);
-            if (compFork === CompFork.Ionic && chainId === ChainId.MODE) {
-                const isolatedIonicMarketUnitroller = "0x8Fb3D4a94D0aA5D6EDaAC3Ed82B59a27f56d923a";
-                const creationBlock = (await getContractCreationBlock(isolatedIonicMarketUnitroller, providers[chainId])) ?? 0;
-                const isolatedMarketLogs = await safeFetchLogs(chainId, [topic], [isolatedIonicMarketUnitroller], creationBlock, toBlock);
-                logs = logs.concat(isolatedMarketLogs);
-            }
-            const vaults = Object.keys(logs.reduce((acc, transfer) => {
-                if (transfer.data !== "0x") {
-                    const [cToken] = defaultAbiCoder.decode(["address"], transfer.data);
-                    if (!!cToken) {
-                        acc[cToken] = true;
-                    }
-                }
-                else {
-                    const [cToken] = defaultAbiCoder.decode(["address"], transfer.topics[1]);
-                    if (!!cToken) {
-                        acc[cToken] = true;
-                    }
-                }
-                return acc;
-            }, {}));
-            // Ensure that the entry in compoundVaults for the current chainId and compFork exists
-            const key = `${String(chainId)}_${String(compFork)}`;
-            if (!compoundVaults[key]) {
-                compoundVaults[key] = [];
-            }
-            const callsUnderlying = [];
-            vaults.forEach(vaultAddress => {
-                callsUnderlying.push({
-                    allowFailure: true,
-                    callData: CTokenInterface.encodeFunctionData("underlying"),
-                    target: vaultAddress,
-                });
-            });
-            const resUnderlying = await batchMulticallCallWithRetry(chainId, {
-                calls: callsUnderlying,
-            });
-            const calls = [];
-            for (const [index, vaultAddress] of vaults.entries()) {
-                let underlying = NULL_ADDRESS;
-                if (!resUnderlying[index].success || resUnderlying[index].returnData === "0x") {
-                    // const message = `Failed to fetch underlying of ${vaultAddress}`;
-                    // log.warn(message);
-                }
-                else {
-                    underlying = CTokenInterface.decodeFunctionResult("underlying", resUnderlying[index].returnData)[0];
-                }
-                calls.push({
-                    allowFailure: true,
-                    callData: CTokenInterface.encodeFunctionData("symbol"),
-                    target: vaultAddress,
-                }, {
-                    allowFailure: true,
-                    callData: CTokenInterface.encodeFunctionData("decimals"),
-                    target: vaultAddress,
-                }, {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlying,
-                }, {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("decimals"),
-                    target: underlying,
-                });
-            }
-            const res = await batchMulticallCallWithRetry(chainId, {
-                calls,
-            });
-            // Add the found vaults to the compoundVaults object
-            let index = 0;
-            for (const [vaultIndex, vaultAddress] of vaults.entries()) {
-                let underlying = NULL_ADDRESS;
-                let symbolUnderlying = "ETH";
-                let decimalsUnderlying = 18;
-                if (!resUnderlying[vaultIndex].success || resUnderlying[vaultIndex].returnData === "0x") {
-                    // const message = `Failed to fetch underlying of ${vaultAddress}`;
-                    // log.warn(message);
-                }
-                else {
-                    underlying = CTokenInterface.decodeFunctionResult("underlying", resUnderlying[vaultIndex].returnData)[0];
-                }
-                if (res[index + 2].returnData !== "0x") {
-                    symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", res[index + 2].returnData)[0];
-                }
-                if (res[index + 3].returnData !== "0x") {
-                    decimalsUnderlying = ERC20Interface.decodeFunctionResult("decimals", res[index + 3].returnData)[0];
-                }
-                const symbolCToken = CTokenInterface.decodeFunctionResult("symbol", res[index].returnData)[0];
-                const decimalsCToken = CTokenInterface.decodeFunctionResult("decimals", res[index + 1].returnData)[0];
-                compoundVaults[key].push({
-                    address: vaultAddress,
-                    symbolCToken: symbolCToken,
-                    underlying: underlying,
-                    decimalsCToken: decimalsCToken,
-                    symbolUnderlying: symbolUnderlying,
-                    decimalsUnderlying: decimalsUnderlying,
-                });
-                index += 4;
-            }
-        }
-    }
-    return compoundVaults;
-}
-export const getCompoundV2ForksVaultsWithCache = async () => await Redis.getOrSet("CompoundV2ForksVaults", getCompoundV2ForksVaults);

package/dist/src/engine/deprecated/dynamicData/utils/getContractCreationBlock.js

@@ -1,44 +0,0 @@
-import { log } from "@/utils/logger";
-// Connect to network
-// Binary search to find the block where the contract code was first deployed
-async function binarySearchContractCreation(provider, contractAddress, startBlock, endBlock) {
-    while (startBlock <= endBlock) {
-        const midBlock = Math.floor((startBlock + endBlock) / 2);
-        let code;
-        try {
-            code = await provider.getCode(contractAddress, midBlock);
-        }
-        catch {
-            log.warn("There was an issue with this chain");
-            break;
-        }
-        if (code === "0x") {
-            // Contract doesn't exist yet, search the later half
-            startBlock = midBlock + 1;
-        }
-        else {
-            // Contract exists, search the earlier half
-            endBlock = midBlock - 1;
-        }
-    }
-    // `startBlock` will be the first block where the contract code exists
-    return startBlock - 1;
-}
-// Function to find the contract creation transaction
-export async function getContractCreationBlock(contractAddress, provider) {
-    // Get the contract code at the given address
-    const code = await provider.getCode(contractAddress);
-    // If the contract code is empty, it's not a contract
-    if (code === "0x") {
-        log.warn("This address is not a contract.");
-        throw new Error(`the address providers (${contractAddress}) is not a contract`);
-    }
-    // Binary search for the first block where the contract code exists
-    const currentBlock = await provider.getBlockNumber(); // Latest block
-    const contractCreationBlock = await binarySearchContractCreation(provider, contractAddress, 0, currentBlock);
-    if (contractCreationBlock) {
-        // log.info(`Contract was created in block: ${contractCreationBlock}`);
-        return contractCreationBlock;
-    }
-    log.warn("Contract creation block not found.");
-}

package/dist/src/engine/deprecated/dynamicData/utils/getDolomiteMarkets.js

@@ -1,53 +0,0 @@
-import { Redis } from "@/cache";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { providers } from "@/utils/providers";
-import { DOLOMITE_MARGIN_MAPPING, DolomiteInterface, DolomiteMargin__factory, ERC20Interface, } from "@sdk";
-export const getDomiteMarkets = async (chainId) => {
-    if (!DOLOMITE_MARGIN_MAPPING[chainId]) {
-        throw "Dolomite is not supported on this chain";
-    }
-    const dolomiteMarginContract = await DolomiteMargin__factory.connect(DOLOMITE_MARGIN_MAPPING[chainId], providers[chainId]);
-    const numMarkets = (await dolomiteMarginContract.getNumMarkets()).toNumber();
-    const calls = [];
-    for (let index = 0; index < numMarkets; index++) {
-        calls.push({
-            allowFailure: true,
-            callData: DolomiteInterface.encodeFunctionData("getMarket", [index]),
-            target: DOLOMITE_MARGIN_MAPPING[chainId],
-        });
-    }
-    const res = await batchMulticallCallWithRetry(chainId, {
-        calls,
-    });
-    if (!res.every(r => r.success)) {
-        throw "Failed to fetch market data for Dolomite";
-    }
-    const markets = [];
-    const secondCalls = [];
-    for (let index = 0; index < numMarkets; index++) {
-        const token = DolomiteInterface.decodeFunctionResult("getMarket", res[index].returnData)[0].token;
-        secondCalls.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("symbol"),
-            target: token,
-        });
-    }
-    const secondRes = await batchMulticallCallWithRetry(chainId, {
-        calls: secondCalls,
-    });
-    for (let index = 0; index < numMarkets; index++) {
-        const token = DolomiteInterface.decodeFunctionResult("getMarket", res[index].returnData)[0].token;
-        let symbol = "";
-        try {
-            symbol = ERC20Interface.decodeFunctionResult("symbol", secondRes[index].returnData)[0];
-        }
-        catch { }
-        markets.push({
-            index,
-            token,
-            symbol,
-        });
-    }
-    return markets;
-};
-export const getDolomiteMarketWithCache = async (chainId) => await Redis.getOrSet("DolomiteMarkets", getDomiteMarkets, chainId);

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

@@ -1,266 +0,0 @@
-import { fetchEulerVaultName } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/eulerVaultNames";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-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";
-import { getAddress } from "ethers/lib/utils";
-import _ from "lodash";
-import { safeFetchLogs } from "./fetchLogs";
-export var LoggedEntityType;
-(function (LoggedEntityType) {
-    LoggedEntityType["EULER"] = "EULER_VAULT";
-    LoggedEntityType["UNISWAP_V4"] = "UNISWAP_V4";
-})(LoggedEntityType || (LoggedEntityType = {}));
-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 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) {
-            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]})`);
-            collateralDataArray.push({ vaultAddress: vault.address, address: collat.collateral, callsToCollatIndex: k });
-            k++;
-            callsToCollat.push({
-                allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("symbol"),
-                target: collat.collateral,
-            }, {
-                allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("asset"),
-                target: collat.collateral,
-            });
-        }
-    }
-    const resCallsToCollat = await batchMulticallCallWithRetry(chainId, {
-        calls: callsToCollat,
-    });
-    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,
-        });
-    }
-    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 = [];
-        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())) {
-                continue;
-            }
-            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: getAddress(collat.collateral),
-                symbol: symbolCollateral,
-                symbolUnderlying: symbolUnderlying,
-                borrowLTV: collat.borrowLTV.toString(),
-                name: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolCollateral,
-            });
-        }
-        return { ...vault };
-    }))));
-    return vaultsPerChain;
-}
-export async function getEulerV2Vaults(chainId) {
-    let chainIdArray;
-    if (!!chainId) {
-        chainIdArray = [chainId];
-    }
-    else {
-        chainIdArray = eulerChainIds;
-    }
-    let vaults = [];
-    // 0_ Fetch all euler vaults from database
-    const storedVaults = await apiDbClient.logged.findMany({
-        where: { type: LoggedEntityType.EULER, ...(!!chainId && { chainId: chainId }) },
-    });
-    const res = await Promise.all(chainIdArray.map(async (chainId) => {
-        let vaultsPerChain = [];
-        chainId = chainId;
-        try {
-            // 1_ Get latest euler vaults from chain
-            const storedVaultsPerChain = storedVaults.filter(vault => vault.chainId === chainId);
-            log.info(`🎈 found ${storedVaultsPerChain.length} already stored vaults on ${NETWORK_LABELS[chainId]}`);
-            let fromBlock;
-            if (storedVaultsPerChain.length > 0) {
-                fromBlock = Math.max(...storedVaultsPerChain.map(vault => vault.fetchAtBlock)) + 1;
-            }
-            else {
-                fromBlock = await getContractCreationBlock(EULER_ADDRESSES[chainId].VAULT_FACTORY, ChainInteractionService(chainId).provider());
-            }
-            const toBlock = await providers[chainId].getBlockNumber();
-            // Check
-            if (fromBlock >= toBlock) {
-                throw new Error(`fromBlock ${fromBlock} is greater than toBlock ${toBlock}`);
-            }
-            const logs = await safeFetchLogs(chainId, [EulerEVKInterface.getEventTopic("EVaultCreated")], [], fromBlock, toBlock);
-            const decodedVaults = await Promise.all(logs.map(async (log) => {
-                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];
-                    // Match previous typings
-                    return {
-                        address: getAddress(log.address.toString()),
-                        asset: aux[1].toString(),
-                        fetchedAtBlock: Number(log.blockNumber),
-                        chainId: chainId,
-                        debtTokenAddress: aux[2].toString(),
-                        name: vaultName,
-                    };
-                }
-                catch {
-                    logger.error(`issue when fetching data on ${NETWORK_LABELS[chainId]} for vault ${log.address}`);
-                    return {};
-                }
-            }));
-            log.info(`fetched ${decodedVaults.length} vaults(s) on ${NETWORK_LABELS[chainId]} between blocks ${fromBlock} and ${toBlock}`);
-            vaultsPerChain = await computeCollatListAndReturnVaults(chainId, decodedVaults);
-            return vaultsPerChain;
-        }
-        catch (e) {
-            log.error(`issue when fetching vaults on ${NETWORK_LABELS[chainId]}`, e);
-        }
-        return vaultsPerChain;
-    }));
-    for (const resPerChain of res) {
-        if (!!resPerChain && resPerChain.length > 0) {
-            vaults = vaults.concat(resPerChain);
-        }
-    }
-    // Update the API database
-    if (vaults.length > 0) {
-        try {
-            await apiDbClient.logged.createMany({
-                data: vaults.map(vault => ({
-                    fetchAtBlock: vault.fetchedAtBlock,
-                    caughtFromAddress: EULER_ADDRESSES[vault.chainId].VAULT_FACTORY,
-                    chainId: vault.chainId,
-                    address: getAddress(vault.address),
-                    entityData: vault,
-                    id: Bun.hash(`${vault.address}-${vault.chainId}`).toString(),
-                    type: LoggedEntityType.EULER,
-                })),
-            });
-            log.info(`✅ successfully saved ${vaults.length} new vault(s) to API database ('Logged' table)`);
-        }
-        catch {
-            throw new Error("Error while saving vaults to API database (`Logged` table)");
-        }
-    }
-    // Add to exising vaults
-    if (storedVaults.length > 0) {
-        vaults = vaults.concat(storedVaults.map(v => v.entityData));
-    }
-    log.info("👋 exiting getEulerV2Vaults");
-    return vaults;
-}
-export async function updateEulerVaultsCollatInDatabase(chainId) {
-    log.info("🏁 start updating vaults collat data");
-    let chainIdArray;
-    if (!!chainId) {
-        chainIdArray = [chainId];
-    }
-    else {
-        chainIdArray = eulerChainIds;
-    }
-    // 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(chainIdArray.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)");
-        }
-    }
-    else {
-        log.info("🤷🏻 no vaults to update");
-    }
-    log.info("🏁 exiting vault collateral update");
-    return;
-}