@merkl/api 0.10.128 → 0.10.130

package/dist/src/libs/deprecated-merklv3/index.js

@@ -0,0 +1,184 @@
+import { Redis } from "../../cache";
+import { RewardConvertorService } from "../../modules/v4/reward/rewardConvertor.service";
+import { AMM, ANGLE_NETWORKS, Campaign, NETWORK_LABELS, } from "@sdk";
+import Big from "big.js";
+import { utils } from "ethers";
+import { log } from "../../utils/logger";
+const fetchCachedData = async (chainIds, onlyLive) => {
+    if (onlyLive === undefined) {
+        onlyLive = false;
+    }
+    const cacheKeys = chainIds.map(chainId => onlyLive ? `LiveCampaignsOldFormat_${chainId}` : `CampaignsOldFormat_${chainId}`);
+    return await Redis.getMany(cacheKeys);
+};
+export async function getClamsInfo(chainIds, AMMs, user, onlyLive) {
+    if (!chainIds && !user && !AMMs) {
+        const cachedData = await fetchCachedData(ANGLE_NETWORKS.merkl);
+        const result = ANGLE_NETWORKS.merkl.reduce((acc, chainId, index) => {
+            if (!cachedData[index]) {
+                log.error("Merkl cache", `Data for ${NETWORK_LABELS[chainId]} not found in cache`);
+            }
+            else {
+                acc[chainId] = cachedData[index];
+            }
+            return acc;
+        }, {});
+        return result;
+    }
+    if (!chainIds) {
+        chainIds = ANGLE_NETWORKS.merkl;
+    }
+    if (onlyLive === undefined) {
+        onlyLive = false;
+    }
+    const cachedData = await fetchCachedData(chainIds, onlyLive);
+    let chainData = [];
+    if (!!user) {
+        chainData = await Redis.getMany(chainIds.map(chainId => `MerklChainData_${chainId}`));
+    }
+    /** Parallel computation of data for each chain */
+    const result = {};
+    const promises = chainIds.map((chainId, index) => (async () => {
+        if (!cachedData[index]) {
+            log.error("Merkl cache", `Data for ${NETWORK_LABELS[chainId]} not found in cache`);
+            return;
+        }
+        log.local(`Redis: ${Object.keys(cachedData[index]?.pools ?? {}).length} pools found on ${NETWORK_LABELS[chainId]}`);
+        /** Filter pools if an AMM filter is required */
+        const filteredPools = {};
+        for (const key of Object.keys(cachedData[index]?.pools ?? {})) {
+            if (!!AMMs &&
+                AMMs.length > 0 &&
+                !!AMM[cachedData[index].pools[key].amm] &&
+                AMMs.indexOf(AMM[cachedData[index].pools[key].amm].toLowerCase()) === -1) {
+                continue;
+            }
+            filteredPools[key] = cachedData[index].pools[key];
+        }
+        cachedData[index].pools = filteredPools;
+        /** Fetch user specific data */
+        if (!!user &&
+            utils.isAddress(user) &&
+            utils.getAddress(user) !== "0xeeeeeEAaAeEEeEEeEeEEEeEEeEeEEEeeeEeeeEee" &&
+            !!cachedData[index].merkleRoot) {
+            cachedData[index] = await RewardConvertorService.convertV4toMerklV2(user, chainId, cachedData[index]);
+            log.local(`Merkl: ${Object.keys(cachedData[index]?.pools ?? {}).filter(k => cachedData[index].pools[k].userBalanceToken0 > 0 ||
+                cachedData[index].pools[k].userBalanceToken1 > 0).length} pool with a user position found on ${NETWORK_LABELS[chainId]}`);
+        }
+        /** Fill result */
+        result[chainId] = cachedData[index];
+    })());
+    await Promise.all(promises);
+    return result;
+}
+export function campaignsToOldFormat(campaignData, merklChainData) {
+    const res = {};
+    res.merkleRoot = merklChainData.merkleRoot;
+    res.message = merklChainData.message;
+    res.validRewardTokens = merklChainData.validRewardTokens;
+    res.pools = {};
+    const pools = {};
+    for (const [type_mainParameter, campaigns] of Object.entries(campaignData)) {
+        // if not a CLAMM campaign, skip
+        if (!type_mainParameter.startsWith("2_")) {
+            continue;
+        }
+        const mainParameter = type_mainParameter.split("_")[1];
+        for (const campaign of Object.values(campaigns)) {
+            if (campaign.campaignType !== Campaign.CLAMM) {
+                continue;
+            }
+            if (!pools[mainParameter]) {
+                pools[mainParameter] = {
+                    alm: campaign.forwarders?.reduce((prev, curr) => {
+                        if (!prev[utils.getAddress(curr.almAddress)]) {
+                            prev[utils.getAddress(curr.almAddress)] = {
+                                ...curr,
+                                almAddress: utils.getAddress(curr.almAddress),
+                            };
+                        }
+                        else {
+                            prev[utils.getAddress(curr.almAddress)].almAPR =
+                                (!!prev[utils.getAddress(curr.almAddress)].almAPR
+                                    ? prev[utils.getAddress(curr.almAddress)].almAPR
+                                    : 0) + (curr.almAPR ?? 0);
+                        }
+                        return prev;
+                    }, {}),
+                    amm: campaign.amm,
+                    ammAlgo: campaign.ammAlgo,
+                    ammAlgoName: campaign.ammAlgoName,
+                    ammName: campaign.ammName,
+                    aprs: campaign.aprs,
+                    chainId: campaign.chainId,
+                    decimalsToken0: campaign.campaignParameters.decimalsToken0,
+                    decimalsToken1: campaign.campaignParameters.decimalsToken1,
+                    disputeLive: merklChainData.disputeLive,
+                    distributionData: [],
+                    endOfDisputePeriod: merklChainData.endOfDisputePeriod,
+                    meanAPR: campaign.apr,
+                    pool: campaign.campaignParameters.poolAddress,
+                    poolBalanceToken0: campaign.poolBalanceToken0,
+                    poolBalanceToken1: campaign.poolBalanceToken1,
+                    poolFee: Number.parseFloat(campaign.campaignParameters.poolFee),
+                    poolTotalLiquidity: campaign.poolTotalLiquidity,
+                    rewardsPerToken: {},
+                    symbolToken0: campaign.campaignParameters.symbolToken0,
+                    symbolToken1: campaign.campaignParameters.symbolToken1,
+                    tick: campaign.tick,
+                    token0: campaign.campaignParameters.token0,
+                    token1: campaign.campaignParameters.token1,
+                    tvl: campaign.tvl,
+                };
+            }
+            else {
+                pools[mainParameter].meanAPR += campaign.apr;
+                if (!!campaign.aprs) {
+                    for (const [key, value] of Object.entries(campaign.aprs)) {
+                        pools[mainParameter].aprs[key] =
+                            (!!pools[mainParameter].aprs[key] ? pools[mainParameter].aprs[key] : 0) + (value ?? 0);
+                    }
+                }
+                if (!!campaign.forwarders) {
+                    for (const almDetails of campaign.forwarders) {
+                        if (!pools[mainParameter]?.alm?.[utils.getAddress(almDetails.almAddress)]) {
+                            pools[mainParameter].alm[utils.getAddress(almDetails.almAddress)] = almDetails;
+                        }
+                        else {
+                            pools[mainParameter].alm[utils.getAddress(almDetails.almAddress)].almAPR =
+                                (!!pools[mainParameter].alm[utils.getAddress(almDetails.almAddress)].almAPR
+                                    ? pools[mainParameter].alm[utils.getAddress(almDetails.almAddress)].almAPR
+                                    : 0) + (almDetails.almAPR ?? 0);
+                        }
+                    }
+                }
+            }
+            const amountDecimal = Number.parseFloat(new Big(campaign.amount).div(new Big(10).pow(campaign.campaignParameters.decimalsRewardToken)).toString());
+            pools[mainParameter].distributionData.push({
+                amount: amountDecimal,
+                apr: campaign?.apr,
+                blacklist: campaign.campaignParameters.blacklist,
+                blacklistedBalance0: campaign.blacklistedBalance0,
+                blacklistedBalance1: campaign.blacklistedBalance1,
+                blacklistedLiquidity: campaign.blacklistedLiquidity,
+                breakdown: {},
+                decimalsRewardToken: campaign.campaignParameters.decimalsRewardToken,
+                endTimestamp: campaign.endTimestamp,
+                id: campaign.campaignId,
+                isLive: campaign.isLive,
+                isMock: campaign.isMock,
+                isOutOfRangeIncentivized: campaign.campaignParameters.isOutOfRangeIncentivized,
+                propFees: campaign.campaignParameters.weightFees / 100,
+                propToken0: campaign.campaignParameters.weightToken0 / 100,
+                propToken1: campaign.campaignParameters.weightToken1 / 100,
+                rewardToken: campaign.rewardToken,
+                startTimestamp: campaign.startTimestamp,
+                symbolRewardToken: campaign.campaignParameters.symbolRewardToken,
+                unclaimed: 0,
+                whitelist: campaign.campaignParameters.whitelist,
+            });
+        }
+        res.pools = pools;
+    }
+    return res;
+}

package/dist/src/libs/getTokensList.js

@@ -0,0 +1,37 @@
+import { Redis } from "../cache";
+import { engineDbClient } from "../utils/prisma";
+import axios from "axios";
+import { log } from "../utils/logger";
+async function getTokensList() {
+    let res = {};
+    try {
+        res = (await axios.get("https://raw.githubusercontent.com/AngleProtocol/angle-token-list/main/ERC20_LIST.json", {
+            timeout: 5000,
+        })).data[0];
+    }
+    catch (e) {
+        log.error("getTokensList failed", e);
+    }
+    return res;
+}
+export const getTokensListWithCache = async () => await Redis.getOrSet("TokenList", getTokensList);
+export async function getMerklTokenList(chainId) {
+    const tokensRaws = await engineDbClient.tokens.findMany({
+        select: {
+            address: true,
+            decimals: true,
+            symbol: true,
+        },
+        where: {
+            chainId,
+        },
+    });
+    const tokens = {};
+    for (const token of tokensRaws) {
+        tokens[token.address] = {
+            decimals: token.decimals,
+            symbol: token.symbol,
+        };
+    }
+    return tokens;
+}

package/dist/src/libs/merklChainData.js

@@ -0,0 +1,129 @@
+import { Redis } from "../cache";
+import { Interface } from "@ethersproject/abi";
+import { BN2Number, DistributionCreator__factory, Distributor__factory, NETWORK_LABELS, NULL_ADDRESS, registry, } from "@sdk";
+import { batchMulticallCallWithRetry } from "../utils/generic";
+import { getMerklTokenList, getTokensListWithCache } from "./getTokensList";
+const DistributorInterface = Distributor__factory.createInterface();
+const DistributorCreatorInterface = DistributionCreator__factory.createInterface();
+const MTW_INTERFACE = new Interface([
+    "function isTokenWrapper() pure returns (bool)",
+    "function token() external view returns (address)",
+]);
+export async function merklChainData(chainId) {
+    const tokens = await getMerklTokenList(chainId);
+    const distributorAddress = registry(chainId)?.Merkl?.Distributor;
+    const distributionCreatorAddress = registry(chainId)?.Merkl?.DistributionCreator;
+    if (!distributorAddress || !distributionCreatorAddress) {
+        throw `Cannot find distributor or distribution creator address for chain ${NETWORK_LABELS[chainId]}`;
+    }
+    const calls = [
+        {
+            allowFailure: false,
+            callData: DistributorInterface.encodeFunctionData("getMerkleRoot"),
+            target: distributorAddress,
+        },
+        {
+            allowFailure: false,
+            callData: DistributorInterface.encodeFunctionData("tree"),
+            target: distributorAddress,
+        },
+        {
+            allowFailure: false,
+            callData: DistributorInterface.encodeFunctionData("lastTree"),
+            target: distributorAddress,
+        },
+        {
+            allowFailure: false,
+            callData: DistributorInterface.encodeFunctionData("endOfDisputePeriod"),
+            target: distributorAddress,
+        },
+        {
+            allowFailure: false,
+            callData: DistributorInterface.encodeFunctionData("disputer"),
+            target: distributorAddress,
+        },
+        {
+            allowFailure: true,
+            callData: DistributorCreatorInterface.encodeFunctionData("message"),
+            target: distributionCreatorAddress,
+        },
+        {
+            allowFailure: true,
+            callData: DistributorCreatorInterface.encodeFunctionData("getValidRewardTokens()"),
+            target: distributionCreatorAddress,
+        },
+    ];
+    const result = await batchMulticallCallWithRetry(chainId, { calls });
+    const tokenList = await getTokensListWithCache();
+    let i = 0;
+    const merkleRoot = DistributorInterface.decodeFunctionResult("getMerkleRoot", result[i++].returnData)[0]?.toString();
+    const treeRoot = DistributorInterface.decodeFunctionResult("tree", result[i++].returnData)[0].toString();
+    const lastTreeRoot = DistributorInterface.decodeFunctionResult("lastTree", result[i++].returnData)[0]?.toString();
+    const endOfDisputePeriod = BN2Number(DistributorInterface.decodeFunctionResult("endOfDisputePeriod", result[i++].returnData)[0], 0);
+    const disputeLive = DistributorInterface.decodeFunctionResult("disputer", result[i++].returnData)[0] !== NULL_ADDRESS;
+    const message = DistributorCreatorInterface.decodeFunctionResult("message", result[i++].returnData)[0]?.toString();
+    const validRewardTokens = DistributorCreatorInterface.decodeFunctionResult("getValidRewardTokens()", result[i++].returnData)[0].map((t) => {
+        const decimals = tokens[t.token]?.decimals
+            ? tokens[t.token]?.decimals
+            : tokenList[chainId]?.[t.token]?.decimals
+                ? tokenList[chainId][t.token].decimals
+                : undefined;
+        const symbol = tokens[t.token]?.symbol
+            ? tokens[t.token]?.symbol
+            : tokenList[chainId]?.[t.token]?.symbol
+                ? tokenList[chainId][t.token].symbol
+                : undefined;
+        return {
+            decimals: decimals,
+            minimumAmountPerEpoch: decimals
+                ? BN2Number(t.minimumAmountPerEpoch, decimals)
+                : BN2Number(t.minimumAmountPerEpoch),
+            symbol: symbol,
+            token: t.token,
+        };
+    });
+    const missingSymbols = validRewardTokens.filter(t => !t.symbol || !t.decimals);
+    for (const token of missingSymbols) {
+        if (!tokenList[chainId])
+            continue;
+        const tokenInfo = tokenList[chainId][token.token];
+        if (!tokenInfo)
+            continue;
+        token.symbol = tokenInfo.symbol;
+        token.decimals = tokenInfo.decimals;
+        token.minimumAmountPerEpoch = BN2Number(token.minimumAmountPerEpoch, tokenInfo.decimals);
+    }
+    const validRewardTokensCalls = validRewardTokens.reduce((acc, t) => {
+        acc.push({
+            allowFailure: true,
+            target: t.token,
+            callData: MTW_INTERFACE.encodeFunctionData("isTokenWrapper"),
+        });
+        acc.push({
+            allowFailure: true,
+            target: t.token,
+            callData: MTW_INTERFACE.encodeFunctionData("token"),
+        });
+        return acc;
+    }, []);
+    const validRewardTokenRes = await batchMulticallCallWithRetry(chainId, { calls: validRewardTokensCalls });
+    for (let index = 0; index < validRewardTokens.length; index++) {
+        try {
+            if (validRewardTokenRes[2 * index][0] &&
+                MTW_INTERFACE.decodeFunctionResult("isTokenWrapper", validRewardTokenRes[2 * index][1])[0]) {
+                validRewardTokens[index].isTokenWrapper = MTW_INTERFACE.decodeFunctionResult("token", validRewardTokenRes[2 * index + 1][1])[0];
+            }
+        }
+        catch { }
+    }
+    return {
+        disputeLive,
+        endOfDisputePeriod,
+        merkleRoot,
+        treeRoot,
+        lastTreeRoot,
+        message,
+        validRewardTokens,
+    };
+}
+export const merklChainDataWithCache = async (chainId) => await Redis.getOrSet(`MerklChainData_${chainId}`, merklChainData, chainId);

package/dist/src/libs/parse/marketsWithCache.js

@@ -0,0 +1,8 @@
+import { Redis } from "../../cache";
+import { hashArray } from "../../utils/hashArray";
+import { getMorphoMarkets, getRadiantMarkets, getSiloMarkets } from "@sdk";
+export const getMorphoMarketsWithCache = async (chainId, subtype) => {
+    return await Redis.getOrSet(`MorphoMarkets_${hashArray([chainId, subtype])}`, getMorphoMarkets, chainId, subtype);
+};
+export const getRadiantMarketsWithCache = async (chainId, poolAddressProvider) => await Redis.getOrSet(`RadiantMarkets_${hashArray(chainId, poolAddressProvider)}$`, getRadiantMarkets, chainId, poolAddressProvider);
+export const getSiloMarketsWithCache = async (chainId, repository) => await Redis.getOrSet(`SiloMarkets_${hashArray([chainId, repository])}`, getSiloMarkets, chainId, repository);

package/dist/src/libs/positions/ajna/index.js

@@ -0,0 +1,107 @@
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { AjnaSubCampaignType, BN2Number, NETWORK_LABELS, PoolInfoUtilsInterface, } from "@sdk";
+import { POOL_INFO_UTILS } from "@sdk";
+import axios from "axios";
+export async function getAjnaUserPositions(user, _chainId, campaigns) {
+    /**
+     * Fetch user positions
+     */
+    const calls = [];
+    for (const campaign of Object.values(campaigns)) {
+        if (campaign.subtype === AjnaSubCampaignType.lend) {
+            calls.push({
+                allowFailure: true,
+                callData: PoolInfoUtilsInterface.encodeFunctionData("poolPricesInfo", [campaign.poolId]),
+                target: POOL_INFO_UTILS[_chainId],
+            });
+        }
+        else {
+            calls.push({
+                allowFailure: true,
+                callData: PoolInfoUtilsInterface.encodeFunctionData("borrowerInfo", [campaign.poolId, user]),
+                target: POOL_INFO_UTILS[_chainId],
+            });
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const finalRes = {};
+                const resCalls = await batchMulticallCallWithRetry(_chainId, {
+                    calls,
+                });
+                for (const [index, campaignId] of Object.keys(campaigns).entries()) {
+                    let userSupply = 0;
+                    const res = {
+                        userPositions: [],
+                        decimals: campaigns[campaignId].decimals,
+                        totalSupply: campaigns[campaignId].computedtotalSupply,
+                        userTVL: 0,
+                    };
+                    const resAjna = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[_chainId].toLowerCase()}/wallets/${user.toLowerCase()}/pools/${campaigns[campaignId].poolId.toLowerCase()}/buckets/?p=1&p_size=50`);
+                    if (resAjna.data.count === 0) {
+                        res.userTVL = 0;
+                        userSupply = 0;
+                    }
+                    else {
+                        if (campaigns[campaignId].subtype === AjnaSubCampaignType.lend) {
+                            const htpIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", resCalls[index].returnData)[3];
+                            const lupIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", resCalls[index].returnData)[5];
+                            const threshold = BN2Number(BN2Number(lupIndex, 0) === 0 ? lupIndex : lupIndex.gt(htpIndex) ? lupIndex.add(22) : htpIndex.add(22), 0);
+                            let nextRoute = null;
+                            if (!!resAjna.data.next) {
+                                nextRoute = `https://${resAjna.data.next.slice(resAjna.data.next.indexOf(":") + 1)}`;
+                            }
+                            let position;
+                            for (position of resAjna.data.results) {
+                                if (position.bucket_index < threshold) {
+                                    res.userTVL += Number(position.deposit);
+                                    userSupply += Number(position.deposit);
+                                }
+                            }
+                            while (nextRoute !== null) {
+                                const resNext = await axios.get(nextRoute);
+                                let position;
+                                for (position of resNext.data.results) {
+                                    if (position.bucket_index < threshold) {
+                                        res.userTVL += Number(position.deposit);
+                                        userSupply += Number(position.deposit);
+                                    }
+                                }
+                                if (!!resNext.data.next) {
+                                    nextRoute = `https://${resNext.data.next.slice(resNext.data.next.indexOf(":") + 1)}`;
+                                }
+                                else {
+                                    nextRoute = null;
+                                }
+                            }
+                        }
+                        else {
+                            userSupply = BN2Number(PoolInfoUtilsInterface.decodeFunctionResult("borrowerInfo", resCalls[index].returnData)[0], 18);
+                            res.userTVL = BN2Number(PoolInfoUtilsInterface.decodeFunctionResult("borrowerInfo", resCalls[index].returnData)[0], 18);
+                        }
+                    }
+                    /////
+                    if (userSupply > 0) {
+                        res.userPositions.push({
+                            balance: userSupply,
+                            token: campaigns[campaignId].quoteToken,
+                            origin: "Direct",
+                            totalSupply: campaigns[campaignId].computedtotalSupply,
+                            tvl: campaigns[campaignId].tvl,
+                        });
+                        // to modify
+                    }
+                    // Add to final result if there are positions
+                    if (res.userPositions.length > 0) {
+                        finalRes[`11_${campaignId}`] = { ...res };
+                    }
+                }
+                return finalRes;
+            },
+        },
+    };
+}

package/dist/src/libs/positions/badger/index.js

@@ -0,0 +1,79 @@
+import { CDPMANAGER_ADDRESS, SORTEDCDPS_ADDRESS } from "../../../constants";
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { BN2Number, CdpManagerInterface, SortedCdpsInterface } from "@sdk";
+export async function getBadgerUserPositions(user, _chainId, campaigns) {
+    /**
+     * Fetch user positions
+     */
+    const calls = [];
+    calls.push({
+        allowFailure: false,
+        callData: CdpManagerInterface.encodeFunctionData("getSystemDebt"),
+        target: CDPMANAGER_ADDRESS,
+    });
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const finalRes = {};
+                const totalSupplyEBTC = BN2Number(CdpManagerInterface.decodeFunctionResult("getSystemDebt", result[0])[0], 18);
+                for (const campaignId of Object.keys(campaigns)) {
+                    let calls = [];
+                    let userSupply = 0;
+                    const totalSupply = totalSupplyEBTC;
+                    const res = {
+                        userPositions: [],
+                        decimals: campaigns[campaignId].decimals,
+                        totalSupply: totalSupplyEBTC,
+                        userTVL: 0,
+                    };
+                    calls.push({
+                        allowFailure: false,
+                        callData: SortedCdpsInterface.encodeFunctionData("getCdpsOf", [user]),
+                        target: SORTEDCDPS_ADDRESS,
+                    });
+                    const resCdps = await batchMulticallCallWithRetry(_chainId, {
+                        calls,
+                    });
+                    calls = [];
+                    for (const res of resCdps) {
+                        const cdp = SortedCdpsInterface.decodeFunctionResult("getCdpsOf", res.returnData)[0];
+                        if (cdp.length !== 0) {
+                            calls.push({
+                                allowFailure: false,
+                                callData: CdpManagerInterface.encodeFunctionData("Cdps", cdp),
+                                target: CDPMANAGER_ADDRESS,
+                            });
+                        }
+                    }
+                    const resRecipient = await batchMulticallCallWithRetry(_chainId, {
+                        calls,
+                    });
+                    for (const res of resRecipient) {
+                        const cdpSupply = CdpManagerInterface.decodeFunctionResult("Cdps", res.returnData)[0];
+                        userSupply += BN2Number(cdpSupply, campaigns[campaignId].decimals);
+                    }
+                    let i = 0;
+                    if (userSupply > 0) {
+                        res.userPositions.push({
+                            balance: userSupply,
+                            token: campaigns[campaignId].targetToken,
+                            origin: "Direct",
+                            totalSupply: totalSupply,
+                            tvl: campaigns[campaignId].tvl,
+                        });
+                        // to modify
+                    }
+                    // Add to final result if there are positions
+                    if (res.userPositions.length > 0) {
+                        finalRes[`9_${campaignId}`] = { ...res };
+                    }
+                    i++;
+                }
+                return finalRes;
+            },
+        },
+    };
+}