@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,91 @@
+import { log } from "../../../utils/logger";
+import { providers } from "../../../utils/providers";
+import axios from "axios";
+async function fetchLogs(chainId, topics, addresses, fromBlock, toBlock) {
+    const url = providers[chainId].connection.url;
+    if (fromBlock === undefined || fromBlock === null || !toBlock) {
+        throw new Error("fromBlock and toBlock are required");
+    }
+    const headers = {
+        accept: "application/json",
+        "content-type": "application/json",
+    };
+    let tempFromBlock = fromBlock;
+    let tempToBlock = toBlock;
+    log.local(`fetching logs between blocks ${fromBlock} and ${toBlock}`);
+    let step = tempToBlock - tempFromBlock;
+    // Binary search to fetch logs and avoid errors
+    let logs = [];
+    let isRateLimitingError = false;
+    while (true) {
+        try {
+            const data = {
+                id: 1,
+                jsonrpc: "2.0",
+                method: "eth_getLogs",
+                params: [
+                    {
+                        address: [...addresses],
+                        topics: topics,
+                        fromBlock: `0x${(tempFromBlock + 1).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.result?.length === 10000)
+                    throw new Error("Log size exceeded");
+                logs = logs.concat(...res.data.result);
+                log.local(`fetched ${res.data.result.length} logs between blocks ${tempFromBlock} and ${tempToBlock}`);
+            }
+            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 message;
+            }
+            if (tempToBlock === toBlock)
+                break;
+            tempFromBlock = Math.min(tempFromBlock + step, 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}`);
+                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/libs/campaigns/utils/getCompV2ForksVaults.js

@@ -0,0 +1,122 @@
+import { Redis } from "../../../cache";
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+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;
+            }
+            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 ? 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) => {
+                const [cToken] = defaultAbiCoder.decode(["address"], transfer.data);
+                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/libs/campaigns/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/libs/campaigns/utils/getDolomiteMarkets.js

@@ -0,0 +1,50 @@
+import { Redis } from "../../../cache";
+import { DOLOMITE_CHAINID, DOLOMITE_MARGIN, DolomiteInterface, DolomiteMargin__factory, ERC20Interface } from "@sdk";
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { providers } from "../../../utils/providers";
+export const getDomiteMarkets = async () => {
+    const dolomiteMarginContract = await DolomiteMargin__factory.connect(DOLOMITE_MARGIN, providers[DOLOMITE_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,
+        });
+    }
+    const res = await batchMulticallCallWithRetry(DOLOMITE_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(DOLOMITE_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 () => await Redis.getOrSet("DolomiteMarkets", getDomiteMarkets);

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

@@ -0,0 +1,87 @@
+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 { getAddress } from "ethers/lib/utils";
+import { fetchEulerVaultName } from "../campaignTypes/ERC20SubTypes/helpers/eulerVaultNames";
+import { safeFetchLogs } from "./fetchLogs";
+const VAULT_LENS_ADDRESS = { [ChainId.MAINNET]: "0x57904B4DF131F00DEE9BB75a8FA1D27744035c90" };
+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,
+            });
+        }
+    }
+    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,
+            });
+        }
+        return { ...decodedVault, collaterals };
+    })));
+    return vaults;
+}
+export const getEulerV2VaultsWithCache = async () => await Redis.getOrSet("EulerV2Vaults", getEulerV2Vaults);

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

@@ -0,0 +1,56 @@
+import { engineDbClient } from "../../../utils/prisma";
+import { apiDbClient } from "src/utils/prisma";
+export const getLastEligibilityRatio = async (campaign, chainId, currentRoot, backupCampaignIds) => {
+    if (campaign.campaignId === "0x6acb7a8cd2646f18e6e438658273bbee1ed6d664c19779d144cc339decf240ca") {
+        return 2;
+    }
+    let lastEligibilityRatio = 1; // By default it's 1
+    try {
+        const auxLastEligibilityRatioString = (await apiDbClient.rewardBreakdown.findFirst({
+            select: {
+                auxiliaryData1: true,
+            },
+            where: {
+                Reward: {
+                    RewardToken: {
+                        chainId,
+                    },
+                    root: currentRoot,
+                },
+                campaignId: campaign.campaignId,
+            },
+            orderBy: {
+                amount: "desc",
+            },
+        }))?.auxiliaryData1;
+        let auxLastEligibilityRatio = !!auxLastEligibilityRatioString
+            ? Number.parseFloat(auxLastEligibilityRatioString)
+            : null;
+        // If the last eligibility ratio is 0 it means the campaign do not use eligibility
+        if (auxLastEligibilityRatio === undefined || auxLastEligibilityRatio === null) {
+            // Otherwise we search in the backup campaigns
+            for (const campaignId of backupCampaignIds) {
+                auxLastEligibilityRatio = (await engineDbClient.leaves.findFirst({
+                    select: {
+                        auxiliaryData1: true,
+                    },
+                    where: {
+                        chainId: chainId,
+                        campaignId,
+                        root: currentRoot,
+                    },
+                }))?.auxiliaryData1?.toNumber();
+                if (!!auxLastEligibilityRatio)
+                    break;
+            }
+        }
+        if (!!auxLastEligibilityRatio) {
+            lastEligibilityRatio = auxLastEligibilityRatio * 100;
+        }
+        else if (auxLastEligibilityRatio === 0) {
+            lastEligibilityRatio = 1;
+        }
+    }
+    catch { }
+    return lastEligibilityRatio;
+};

package/dist/src/libs/computeFee.js

@@ -0,0 +1,34 @@
+import { BASE_9, DistributionCreatorInterface, registry, } from "@sdk";
+import { BigNumber } from "ethers";
+import { batchMulticallCallWithRetry } from "../utils/generic";
+export const computeFee = async (chainId, config) => {
+    if (!config.creator) {
+        throw new Error("Creator is required");
+    }
+    const distributionCreator = registry(chainId)?.Merkl?.DistributionCreator;
+    const calls = [
+        {
+            allowFailure: true,
+            target: distributionCreator,
+            callData: DistributionCreatorInterface.encodeFunctionData("campaignSpecificFees", [config.campaignType]),
+        },
+        {
+            allowFailure: true,
+            target: distributionCreator,
+            callData: DistributionCreatorInterface.encodeFunctionData("feeRebate", [config.creator]),
+        },
+    ];
+    const result = await batchMulticallCallWithRetry(chainId, {
+        calls,
+    });
+    const campaignSpecificFees = BigNumber.from(DistributionCreatorInterface.decodeFunctionResult("campaignSpecificFees", result[0].returnData)[0]);
+    const feeRebate = BigNumber.from(DistributionCreatorInterface.decodeFunctionResult("feeRebate", result[1].returnData)[0]);
+    const baseFeesValue = campaignSpecificFees.eq("1")
+        ? BigNumber.from(0)
+        : campaignSpecificFees.eq("0")
+            ? BigNumber.from(30000000)
+            : campaignSpecificFees;
+    return {
+        fee: baseFeesValue.mul(BASE_9.sub(feeRebate)).div(BASE_9).toString(),
+    };
+};

package/dist/src/libs/custom/twtParticipants.js

@@ -0,0 +1,54 @@
+import { Redis } from "../../cache";
+import { batchMulticallCallWithRetry } from "../../utils/generic";
+import { Interface } from "@ethersproject/abi";
+import { BN2Number, ChainId, ERC20Interface } from "@sdk";
+import { log } from "../../utils/logger";
+const stTwtABI = [
+    {
+        constant: true,
+        inputs: [],
+        name: "participantNumber",
+        outputs: [
+            {
+                name: "",
+                type: "uint256",
+            },
+        ],
+        payable: false,
+        stateMutability: "view",
+        type: "function",
+    },
+];
+const stTwtAddresses = {
+    [ChainId.BSC]: "0x5029f49585D57ed770D2194841B5A0bE06BFc2ED",
+};
+const stTwtInterface = new Interface(stTwtABI);
+export async function getTwtParticipants(chainId) {
+    const tokenAddress = stTwtAddresses[chainId];
+    const calls = [
+        {
+            allowFailure: true,
+            callData: stTwtInterface.encodeFunctionData("participantNumber", []),
+            target: tokenAddress,
+        },
+        {
+            allowFailure: true,
+            callData: ERC20Interface.encodeFunctionData("totalSupply"),
+            target: tokenAddress,
+        },
+    ];
+    const result = await batchMulticallCallWithRetry(chainId, { calls });
+    const res = {
+        participants: 0,
+        totalSupply: 0,
+    };
+    try {
+        res.participants = stTwtInterface.decodeFunctionResult("participantNumber", result[0].returnData)[0].toNumber();
+        res.totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[1].returnData)[0], 18);
+    }
+    catch (_error) {
+        log.local(`❌ Failed to call participantNumber for ${tokenAddress} on ${chainId}`);
+    }
+    return res;
+}
+export const getTwtParticipantsWithCache = async (chainId) => await Redis.getOrSet(`TwtParticipants_${chainId}`, getTwtParticipants, chainId);