@merkl/api 0.21.46 → 1.0.0

package/dist/src/jobs/update-uniswap-v4-pools.js

@@ -1,15 +0,0 @@
-import { TTLPresets } from "@/modules/v4/cache/cache.model";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { UniswapService } from "@/modules/v4/uniswap/uniswap.service";
-async function main() {
-    try {
-        await CacheService.set(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools);
-        process.exit(0);
-    }
-    catch (err) {
-        console.error("Failed to update Uniswap V4 pools cache.");
-        console.error(err);
-        process.exit(1);
-    }
-}
-await main();

package/dist/src/libs/computeFee.js

@@ -1,34 +0,0 @@
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { BASE_9, DistributionCreatorInterface, registry, } from "@sdk";
-import { BigNumber } from "ethers";
-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/deprecated-merklv3/index.js

@@ -1,183 +0,0 @@
-import { Redis } from "@/cache";
-import { RewardConvertorService } from "@/modules/v4/reward/reward.converter";
-import { log } from "@/utils/logger";
-import { AMM, ANGLE_NETWORKS, Campaign, NETWORK_LABELS, } from "@sdk";
-import Big from "big.js";
-import { utils } from "ethers";
-const fetchCachedData = async (chainIds, onlyLive) => {
-    if (onlyLive === undefined) {
-        onlyLive = false;
-    }
-    const cacheKeys = chainIds.map(chainId => onlyLive ? `LiveCampaignsOldFormat_${chainId}` : `CampaignsOldFormat_${chainId}`);
-    return await Redis.findMany(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.findMany(chainIds.map(chainId => `MerklChainData_${chainId}`));
-    }
-    /** Parallel computation of data for each chain */
-    const result = {};
-    const promises = chainIds.map((chainId, index) => (async () => {
-        if (!cachedData[index]) {
-            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

@@ -1,19 +0,0 @@
-import { Redis } from "@/cache";
-import { log } from "@/utils/logger";
-import axios from "axios";
-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;
-}
-/**
- * @deprecated
- */
-export const getTokensListWithCache = async () => await Redis.getOrSet("TokenList", getTokensList);

package/dist/src/libs/merklChainData.js

@@ -1,116 +0,0 @@
-import { Redis } from "@/cache";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { Interface } from "@ethersproject/abi";
-import { BN2Number, DistributionCreator__factory, Distributor__factory, NETWORK_LABELS, NULL_ADDRESS, registry, } from "@sdk";
-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 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 });
-    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;
-    let message = "";
-    try {
-        message = DistributorCreatorInterface.decodeFunctionResult("message", result[i++].returnData)[0]?.toString();
-    }
-    catch { }
-    const tokens = await TokenService.findManyObjectPerAddress({
-        chainId,
-        id: DistributorCreatorInterface.decodeFunctionResult("getValidRewardTokens()", result[i].returnData)[0].map((t) => TokenService.hashId({ chainId, address: t.token })),
-    });
-    const validRewardTokens = DistributorCreatorInterface.decodeFunctionResult("getValidRewardTokens()", result[i++].returnData)[0].map((t) => {
-        const decimals = tokens[t.token]?.decimals ? tokens[t.token]?.decimals : undefined;
-        const symbol = tokens[t.token]?.symbol ? tokens[t.token]?.symbol : undefined;
-        return {
-            decimals: decimals,
-            minimumAmountPerEpoch: decimals
-                ? BN2Number(t.minimumAmountPerEpoch, decimals)
-                : BN2Number(t.minimumAmountPerEpoch),
-            symbol: symbol,
-            token: t.token,
-        };
-    });
-    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

@@ -1,8 +0,0 @@
-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/EigenLayer/index.js

@@ -1,54 +0,0 @@
-// @ts-nocheck
-import { BN2Number, ChainInteractionService, EigenLayerStrategyInterface, EigenLayerStrategy__factory, } from "@sdk";
-export async function getEigenLayerUserPositions(user, _chainId, campaigns) {
-    /**
-     * Fetch user positions
-     */
-    const calls = [];
-    for (const mainParameter of Object.keys(campaigns)) {
-        calls.push({
-            allowFailure: true,
-            callData: EigenLayerStrategyInterface.encodeFunctionData("shares", [user]),
-            target: campaigns[mainParameter].targetToken,
-        });
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let j = 0;
-                const finalRes = {};
-                for (const campaignId of Object.keys(campaigns)) {
-                    let userShares = 0;
-                    let userSupply = 0;
-                    const strategy = campaigns[campaignId].targetToken;
-                    userShares = EigenLayerStrategyInterface.decodeFunctionResult("shares", result[j++])[0];
-                    userSupply = BN2Number(await EigenLayerStrategy__factory.connect(strategy, ChainInteractionService(_chainId).provider()).sharesToUnderlying(userShares), campaigns[campaignId].decimals);
-                    const res = {
-                        userPositions: [],
-                        decimals: campaigns[campaignId].decimals,
-                        totalSupply: campaigns[campaignId].totalSupplyTargetToken,
-                        userTVL: 0,
-                    };
-                    if (userSupply > 0) {
-                        res.userPositions.push({
-                            balance: userSupply,
-                            token: strategy,
-                            origin: "Direct",
-                            totalSupply: campaigns.campaignId.totalSupplyTargetToken,
-                            tvl: campaigns[campaignId].tvl,
-                        });
-                        // to modify
-                    }
-                    // Add to final result if there are positions
-                    if (res.userPositions.length > 0) {
-                        finalRes[`14_${campaignId}`] = { ...res };
-                    }
-                }
-                return finalRes;
-            },
-        },
-    };
-}

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

@@ -1,107 +0,0 @@
-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

@@ -1,80 +0,0 @@
-// @ts-nocheck
-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 = i++;
-                }
-                return finalRes;
-            },
-        },
-    };
-}