@merkl/api 0.9.15

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

@@ -0,0 +1,19 @@
+import { type MerklChainId } from "@sdk";
+export type CompoundVaultType = {
+    address: string;
+    asset: string;
+    chainId: MerklChainId;
+    debtTokenAddress: string;
+    name: string;
+};
+export type CompoundVaultsType = {
+    [chainId_compFork: string]: {
+        address: string;
+        symbolCToken: string;
+        decimalsCToken: number;
+        underlying: string;
+        symbolUnderlying: string;
+        decimalsUnderlying: number;
+    }[];
+};
+export declare const getCompoundV2ForksVaultsWithCache: () => Promise<CompoundVaultsType>;

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

@@ -0,0 +1,134 @@
+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 = [];
+            const topic = compFork === CompFork.Venus && chainId === ChainId.ZKSYNC
+                ? MARKET_SUPPORTED_EVENT_HASH
+                : 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/dynamicData/utils/getContractCreationBlock.d.ts

@@ -0,0 +1,2 @@
+import type { JsonRpcProvider } from "@ethersproject/providers";
+export declare function getContractCreationBlock(contractAddress: string, provider: JsonRpcProvider): Promise<number | undefined>;

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

@@ -0,0 +1,44 @@
+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/dynamicData/utils/getDolomiteMarkets.d.ts

@@ -0,0 +1,8 @@
+import { DOLOMITE_MARGIN_MAPPING } from "@sdk";
+export type DolomiteMarketT = {
+    index: number;
+    token: string;
+    symbol: string;
+}[];
+export declare const getDomiteMarkets: (chainId: keyof typeof DOLOMITE_MARGIN_MAPPING) => Promise<DolomiteMarketT>;
+export declare const getDolomiteMarketWithCache: (chainId: keyof typeof DOLOMITE_MARGIN_MAPPING) => Promise<DolomiteMarketT>;

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

@@ -0,0 +1,53 @@
+import { Redis } from "@/cache";
+import { DOLOMITE_MARGIN_MAPPING, DolomiteInterface, DolomiteMargin__factory, ERC20Interface, } from "@sdk";
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { providers } from "../../../utils/providers";
+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/dynamicData/utils/getEulerV2Vaults.d.ts

@@ -0,0 +1,8 @@
+import { type EulerVaultType } from "@sdk";
+export declare enum LoggedEntityType {
+    EULER = "EULER_VAULT",
+    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

@@ -0,0 +1,209 @@
+import { Redis } from "@/cache";
+import { fetchEulerVaultName } from "@/engine/erc20SubTypeProcessors/helpers/eulerVaultNames";
+import { batchMulticallCallWithRetry } from "@/utils/generic";
+import { log } 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 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 getEulerV2Vaults() {
+    let vaults = [];
+    // 0_ Fetch all euler vaults from database
+    const storedVaults = await apiDbClient.logged.findMany({
+        where: { type: LoggedEntityType.EULER },
+    });
+    const res = await Promise.all(eulerChainIds.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) => {
+                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,
+                };
+            }));
+            log.local(`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: 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)");
+        }
+    }
+    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({
+        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)");
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+import { type MerklChainId, type UniswapV4PoolType } from "@sdk";
+export type UniswapV4PoolsReturnType = {
+    [chainId in MerklChainId]?: {
+        [poolId: string]: UniswapV4PoolType;
+    };
+};
+export declare function getUniswapV4Pools(): Promise<UniswapV4PoolsReturnType>;
+export declare const getUniswapV4PoolsWithCache: () => Promise<UniswapV4PoolsReturnType>;