@merkl/api 0.21.46 → 1.0.0

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

@@ -1,412 +0,0 @@
-import { TTLPresets } from "@/modules/v4/cache/cache.model";
-// @ts-nocheck
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { ChainInteractionService } from "@/modules/v4/chainInteraction/chainInteraction.service";
-import { log } from "@/utils/logger";
-import { Pricer } from "@/utils/pricer";
-import { providers } from "@/utils/providers";
-import { ALM, AMMAlgorithmMapping, BN2Number, NETWORK_LABELS, NFTManagerAddress, NonFungiblePositionManagerInterface, PoolInterface, PoolState, SqrtPrice, YEAR, getAmountsForLiquidity, getSupportedNFPWrapperMapping, getTickAtSqrtRatio, spNFTInterface, } from "@sdk";
-import { BigNumber, Contract, utils } from "ethers";
-import JSBI from "jsbi";
-import { fetchAlmPositions } from "./thegraph/fetchAlmPositions";
-import { fetchAmmPositions } from "./thegraph/fetchAmmPositions";
-import { fetchFarmedPositions } from "./thegraph/fetchFarmedPositions";
-export async function getClammUserPositions(user, chainId, poolsByAmm, withIndividualAPRs = true) {
-    const pricer = await Pricer.load();
-    /**
-     * Fetch user positions
-     */
-    const promisePositions = [
-        fetchAmmPositions(chainId, user, (!!poolsByAmm ? Object.keys(poolsByAmm) : []).map(x => Number(x))),
-        fetchAlmPositions(chainId, user),
-    ];
-    /**
-     * Per pool mapping to store all ids of positions that were wrapped into a farm
-     * @notice see line 110 for more context
-     */
-    const farmedTokenIds = {};
-    const calls = [];
-    const callsByAmm = {};
-    let startingIndex = 0;
-    /** Add on onchain calls at the pool level */
-    if (!!poolsByAmm) {
-        for (const [amm, poolDatas] of Object.entries(poolsByAmm)) {
-            const pools = Object.keys(poolDatas);
-            if (!callsByAmm[amm]) {
-                callsByAmm[amm] = {
-                    start: startingIndex,
-                    poolCalls: pools.length,
-                    wrapperCalls: {},
-                };
-            }
-            for (const pool of pools) {
-                calls.push({
-                    allowFailure: true,
-                    callData: PoolInterface[AMMAlgorithmMapping[amm]].encodeFunctionData(PoolState[AMMAlgorithmMapping[amm]]),
-                    target: pool,
-                });
-                startingIndex++;
-            }
-            if (getSupportedNFPWrapperMapping(chainId, amm).length > 0) {
-                farmedTokenIds[amm] = await CacheService.wrap(TTLPresets.MIN_5, fetchFarmedPositions, chainId, [user], Number(amm));
-            }
-            for (const wrapper of getSupportedNFPWrapperMapping(chainId, amm)) {
-                if (!!farmedTokenIds &&
-                    !!farmedTokenIds?.[amm] &&
-                    !!farmedTokenIds?.[amm]?.[wrapper] &&
-                    farmedTokenIds?.[amm]?.[wrapper].length > 0) {
-                    if (!callsByAmm[amm].wrapperCalls[wrapper]) {
-                        callsByAmm[amm].wrapperCalls[wrapper] = 0;
-                    }
-                    farmedTokenIds?.[amm]?.[wrapper]
-                        ?.map((pos) => pos.id)
-                        ?.forEach((tokenId) => {
-                        calls.push({
-                            allowFailure: true,
-                            callData: NonFungiblePositionManagerInterface[AMMAlgorithmMapping[amm]].encodeFunctionData("positions", [tokenId]),
-                            target: NFTManagerAddress[chainId][amm],
-                        });
-                        callsByAmm[amm].wrapperCalls[wrapper]++;
-                        startingIndex++;
-                    });
-                }
-            }
-        }
-    }
-    const result = await ChainInteractionService(chainId).fetchState(calls);
-    const [promisePosition, promiseALMPosition] = await Promise.all(promisePositions);
-    const positions = Object.values((await Promise.resolve(promisePosition))).reduce((acc, val) => {
-        return acc.concat(val.nft).concat(val.direct);
-    }, []);
-    /** Fill user positions */
-    const finalRes = {};
-    if (!!poolsByAmm) {
-        for (const [amm, poolDatas] of Object.entries(poolsByAmm)) {
-            const pools = Object.keys(poolDatas);
-            let i = callsByAmm[amm].start;
-            for (const p of pools) {
-                try {
-                    const res = {
-                        userPositions: [],
-                        apr: {},
-                        userTVL: 0,
-                        userBalanceToken0: 0,
-                        userBalanceToken1: 0,
-                        userTotalLiquidity: 0,
-                        userInRangeLiquidity: 0,
-                    };
-                    const updateUserPosition = (x) => {
-                        res.userPositions?.push(x);
-                        // Update global data logic
-                        res.userTVL += x.tvl ?? 0;
-                        res.userBalanceToken0 += x.balance0 ?? 0;
-                        res.userBalanceToken1 += x.balance1 ?? 0;
-                        res.userTotalLiquidity += x.totalLiquidity ?? 0;
-                        res.userInRangeLiquidity += x.inRangeLiquidity ?? 0;
-                    };
-                    const sqrtPriceX96 = PoolInterface[AMMAlgorithmMapping[amm]]
-                        .decodeFunctionResult(PoolState[AMMAlgorithmMapping[amm]], result[i++].returnData)[SqrtPrice[AMMAlgorithmMapping[amm]]].toString();
-                    res.tick = getTickAtSqrtRatio(JSBI.BigInt(sqrtPriceX96));
-                    res.userTVL = 0;
-                    res.userBalanceToken0 = 0;
-                    res.userBalanceToken1 = 0;
-                    res.userTotalLiquidity = 0;
-                    res.userInRangeLiquidity = 0;
-                    const priceToken0 = (await pricer.get({
-                        address: poolDatas[p].token0,
-                        chainId,
-                        symbol: poolDatas[p].symbolToken0,
-                    }));
-                    const priceToken1 = (await pricer.get({
-                        address: poolDatas[p].token1,
-                        chainId,
-                        symbol: poolDatas[p].symbolToken1,
-                    }));
-                    /** 1_ User Liquidity Positions */
-                    const userNonALMPositions = positions?.filter((x) => utils.getAddress(x.pool.id) === utils.getAddress(p));
-                    for (const pos of userNonALMPositions) {
-                        try {
-                            const [amount0, amount1] = getAmountsForLiquidity(sqrtPriceX96, Number.parseInt(pos.tickLower), Number.parseInt(pos.tickUpper), BigNumber.from(pos.liquidity));
-                            const balance0 = BN2Number(amount0, poolDatas[p].decimalsToken0);
-                            const balance1 = BN2Number(amount1, poolDatas[p].decimalsToken1);
-                            const tvl = balance0 * priceToken0 + balance1 * priceToken1;
-                            updateUserPosition({
-                                balance0,
-                                balance1,
-                                id: pos.id,
-                                inRangeLiquidity: balance0 > 0 && balance1 > 0 ? BN2Number(pos.liquidity) : 0,
-                                lowerTick: Number.parseInt(pos.tickLower),
-                                origin: -1,
-                                totalLiquidity: BN2Number(pos.liquidity),
-                                tvl,
-                                upperTick: Number.parseInt(pos.tickUpper),
-                            });
-                        }
-                        catch {
-                            log.local(`Merkl User Data: error handling positions for pool ${NETWORK_LABELS[chainId]}-${p}`);
-                        }
-                    }
-                    /** 2_ User Positions through ALMs */
-                    for (const almAddress of Object.keys(promiseALMPosition).filter(almAddress => !!poolDatas[p].forwarders[utils.getAddress(almAddress)])) {
-                        try {
-                            const almDetail = poolDatas[p].forwarders[utils.getAddress(almAddress)];
-                            let balance;
-                            if (almDetail.origin === ALM.spNFT) {
-                                const tokenId = promiseALMPosition[almAddress];
-                                balance = (await new Contract(almAddress, spNFTInterface, providers[chainId]).getStakingPosition(tokenId))[0];
-                            }
-                            else {
-                                balance = promiseALMPosition[almAddress];
-                            }
-                            for (const pos of almDetail.positions) {
-                                updateUserPosition({
-                                    almAddress: almAddress, // FIXME: typing is bypassed here
-                                    balance0: (BN2Number(balance) * pos?.balance0) / almDetail.totalSupply,
-                                    balance1: (BN2Number(balance) * pos?.balance1) / almDetail.totalSupply,
-                                    id: pos.id,
-                                    inRangeLiquidity: (BN2Number(balance) * pos?.inRangeLiquidity) / almDetail.totalSupply,
-                                    lowerTick: pos.lowerTick,
-                                    origin: almDetail.origin,
-                                    totalLiquidity: (BN2Number(balance) * pos?.totalLiquidity) / almDetail.totalSupply,
-                                    tvl: (BN2Number(balance) * pos?.tvl) / almDetail.totalSupply,
-                                    upperTick: pos.upperTick,
-                                });
-                            }
-                        }
-                        catch (_error) {
-                            log.local(`Merkl User Data: error handling alm positions for pool ${NETWORK_LABELS[chainId]}-${p}`);
-                        }
-                    }
-                    /** 3_ User positions that were deposited on non fungible positions wrapper contracts (eg. farms) */
-                    let j = callsByAmm[amm].start + callsByAmm[amm].poolCalls;
-                    if (getSupportedNFPWrapperMapping(chainId, amm).length > 0) {
-                        const nonFungiblePositionManagerInterface = NonFungiblePositionManagerInterface[AMMAlgorithmMapping[amm]];
-                        for (const wrapper of getSupportedNFPWrapperMapping(chainId, amm)) {
-                            if (!!farmedTokenIds?.[amm] && farmedTokenIds?.[amm][wrapper].length > 0) {
-                                for (let k = 0; k < farmedTokenIds[amm][wrapper].length; k++) {
-                                    if (farmedTokenIds[amm][wrapper][k].pool !== p.toLowerCase()) {
-                                        j++;
-                                        continue;
-                                    }
-                                    const posLiquidity = nonFungiblePositionManagerInterface.decodeFunctionResult("positions", result[j].returnData).liquidity;
-                                    const tickLower = Number.parseFloat(nonFungiblePositionManagerInterface
-                                        .decodeFunctionResult("positions", result[j].returnData)
-                                        .tickLower.toString());
-                                    const tickUpper = Number.parseFloat(nonFungiblePositionManagerInterface
-                                        .decodeFunctionResult("positions", result[j++].returnData)
-                                        .tickUpper.toString());
-                                    try {
-                                        const [amount0, amount1] = getAmountsForLiquidity(sqrtPriceX96, tickLower, tickUpper, posLiquidity);
-                                        const balance0 = BN2Number(amount0, poolDatas[p].decimalsToken0);
-                                        const balance1 = BN2Number(amount1, poolDatas[p].decimalsToken1);
-                                        const priceToken0 = (await pricer.get({
-                                            address: poolDatas[p].token0,
-                                            chainId,
-                                            symbol: poolDatas[p].symbolToken0,
-                                        }));
-                                        const priceToken1 = (await pricer.get({
-                                            address: poolDatas[p].token1,
-                                            chainId,
-                                            symbol: poolDatas[p].symbolToken1,
-                                        }));
-                                        const tvl = balance0 * priceToken0 + balance1 * priceToken1;
-                                        updateUserPosition({
-                                            almAddress: farmedTokenIds[amm][wrapper][k].farmAddress,
-                                            balance0,
-                                            balance1,
-                                            id: farmedTokenIds[amm][wrapper][k].id,
-                                            inRangeLiquidity: balance0 > 0 && balance1 > 0 ? BN2Number(posLiquidity) : 0,
-                                            lowerTick: tickLower,
-                                            origin: -2 - Number.parseInt(String(wrapper)), // -2 - X means NFT Wrapper
-                                            totalLiquidity: BN2Number(posLiquidity),
-                                            tvl,
-                                            upperTick: tickUpper,
-                                        });
-                                    }
-                                    catch (_e) {
-                                        log.local(`Merkl User Data: error handling positions for pool ${NETWORK_LABELS[chainId]}-${p}`);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    if (withIndividualAPRs) {
-                        /** Individual APRs */
-                        let individualApr = 0;
-                        const oneDistributionIsBoosted = false;
-                        for (const campaignDatas of Object.values(poolDatas[p].campaigns)) {
-                            const campaignData = campaignDatas;
-                            let userBalance0 = res.userBalanceToken0;
-                            let userBalance1 = res.userBalanceToken1;
-                            let userInRangeLiquidity = res.userInRangeLiquidity;
-                            let userTotalLiquidity = res.userTotalLiquidity;
-                            const priceRewardToken = (await pricer.get({
-                                address: campaignData.rewardToken,
-                                chainId,
-                                symbol: campaignData.symbolRewardToken,
-                            }));
-                            /** Handle whitelist to compute APR */
-                            if (campaignData.whitelist.length > 0) {
-                                const aux = campaignData.whitelist.reduce((acc, whitelistedAddress) => {
-                                    /** 1_ User is whitelisted */
-                                    if (user.toLowerCase() === whitelistedAddress.toLowerCase()) {
-                                        acc.balance0 += res.userBalanceToken0;
-                                        acc.balance1 += res.userBalanceToken1;
-                                        acc.inRangeLiquidity += res.userInRangeLiquidity;
-                                        acc.totalLiquidity += res.userTotalLiquidity;
-                                    }
-                                    else if (res.userPositions
-                                        .map((w) => (!!w?.almAddress ? w?.almAddress?.toLowerCase() : null))
-                                        ?.filter((a) => !!a)
-                                        .includes(whitelistedAddress.toLowerCase())) {
-                                        /**
-                                         *  2_ ALM is whitelisted and/or Nf positions vault is whitelisted
-                                         * @dev for simplicity purposes, vault address is marked as `almAddress`
-                                         */
-                                        let index = -1;
-                                        const positionsAddresses = res.userPositions.map((w) => w.almAddress?.toLowerCase());
-                                        while (true) {
-                                            const newIndex = positionsAddresses.slice(index + 1).indexOf(whitelistedAddress.toLowerCase());
-                                            if (newIndex === -1)
-                                                break;
-                                            index = index + 1 + newIndex;
-                                            acc.balance0 += res.userPositions[index].balance0;
-                                            acc.balance1 += res.userPositions[index].balance1;
-                                            acc.inRangeLiquidity += res.userPositions[index].inRangeLiquidity;
-                                            acc.totalLiquidity += res.userPositions[index].totalLiquidity;
-                                        }
-                                    }
-                                    else if (res.userPositions
-                                        .map((w) => !!w?.almAddress
-                                        ? poolDatas[p].forwarders[utils.getAddress(w?.almAddress)]?.target?.toLowerCase()
-                                        : null)
-                                        ?.filter((a) => !!a)
-                                        .includes(whitelistedAddress?.toLowerCase())) {
-                                        /** 3_ ALM target is whitelisted */
-                                        let index = -1;
-                                        const positionsAddresses = res.userPositions.map((w) => !!w?.almAddress &&
-                                            poolDatas[p].forwarders[utils.getAddress(w?.almAddress)]?.target.toLowerCase());
-                                        while (true) {
-                                            const newIndex = positionsAddresses.slice(index + 1).indexOf(whitelistedAddress.toLowerCase());
-                                            if (newIndex === -1)
-                                                break;
-                                            index = index + 1 + newIndex;
-                                            acc.balance0 += res.userPositions[index].balance0;
-                                            acc.balance1 += res.userPositions[index].balance1;
-                                            acc.inRangeLiquidity += res.userPositions[index].inRangeLiquidity;
-                                            acc.totalLiquidity += res.userPositions[index].totalLiquidity;
-                                        }
-                                    }
-                                    return acc;
-                                }, {
-                                    balance0: 0,
-                                    balance1: 0,
-                                    inRangeLiquidity: 0,
-                                    totalLiquidity: 0,
-                                });
-                                userBalance0 = Math.max(0, aux.balance0);
-                                userBalance1 = Math.max(0, aux.balance1);
-                                userInRangeLiquidity = Math.max(0, aux.inRangeLiquidity);
-                                userTotalLiquidity = Math.max(0, aux.inRangeLiquidity);
-                            }
-                            else if (campaignData.blacklist.length > 0) {
-                                /** Handle blacklist to compute APR */
-                                const aux = campaignData.blacklist.reduce((acc, blacklistedAddress) => {
-                                    /** 1_ User is blacklisted */
-                                    if (user.toLowerCase() === blacklistedAddress.toLowerCase()) {
-                                        acc.balance0 -= res.userBalanceToken0;
-                                        acc.balance1 -= res.userBalanceToken1;
-                                        acc.inRangeLiquidity -= res.userInRangeLiquidity;
-                                    }
-                                    else if (res.userPositions
-                                        .map((w) => (!!w?.almAddress ? w?.almAddress?.toLowerCase() : null))
-                                        ?.filter((a) => !!a)
-                                        .includes(blacklistedAddress.toLowerCase())) {
-                                        /** 2_ ALM and/or NFP vault is blacklisted */
-                                        let index = -1;
-                                        const positionsAddresses = res.userPositions.map((w) => w.almAddress?.toLowerCase());
-                                        while (true) {
-                                            const newIndex = positionsAddresses.slice(index + 1).indexOf(blacklistedAddress.toLowerCase());
-                                            if (newIndex === -1)
-                                                break;
-                                            index = index + 1 + newIndex;
-                                            acc.balance0 -= res.userPositions[index].balance0;
-                                            acc.balance1 -= res.userPositions[index].balance1;
-                                            acc.inRangeLiquidity -= res.userPositions[index].inRangeLiquidity;
-                                            acc.totalLiquidity -= res.userPositions[index].totalLiquidity;
-                                        }
-                                    }
-                                    else if (
-                                    /** 3_ Target is blacklisted */
-                                    res.userPositions
-                                        .map((w) => !!w?.almAddress
-                                        ? poolDatas[p].forwarders[utils.getAddress(w?.almAddress)]?.target?.toLowerCase()
-                                        : null)
-                                        ?.filter((a) => !!a)
-                                        .includes(blacklistedAddress.toLowerCase())) {
-                                        let index = -1;
-                                        const positionsAddresses = res.userPositions.map((w) => !!w?.almAddress &&
-                                            poolDatas[p].forwarders[utils.getAddress(w?.almAddress)]?.target.toLowerCase());
-                                        while (true) {
-                                            const newIndex = positionsAddresses.slice(index + 1).indexOf(blacklistedAddress.toLowerCase());
-                                            if (newIndex === -1)
-                                                break;
-                                            index = index + 1 + newIndex;
-                                            acc.balance0 -= res.userPositions[index].balance0;
-                                            acc.balance1 -= res.userPositions[index].balance1;
-                                            acc.inRangeLiquidity -= res.userPositions[index].inRangeLiquidity;
-                                            acc.totalLiquidity -= res.userPositions[index].totalLiquidity;
-                                        }
-                                    }
-                                    return acc;
-                                }, {
-                                    balance0: res.userBalanceToken0,
-                                    balance1: res.userBalanceToken1,
-                                    inRangeLiquidity: res.userInRangeLiquidity,
-                                    totalLiquidity: 0,
-                                });
-                                userBalance0 = Math.max(0, aux.balance0);
-                                userBalance1 = Math.max(0, aux.balance1);
-                                userInRangeLiquidity = Math.max(0, aux.inRangeLiquidity);
-                                userTotalLiquidity = Math.max(0, aux.inRangeLiquidity);
-                            }
-                            /** Yearly rewards in $ */
-                            const distributionDuration = campaignData.endTimestamp - campaignData.startTimestamp;
-                            const yearlyAmountDistributed = priceRewardToken * campaignData.amount * YEAR;
-                            const yearlyToken0Rewards = (campaignData.propToken0 * yearlyAmountDistributed) / distributionDuration;
-                            const yearlyToken1Rewards = (campaignData.propToken1 * yearlyAmountDistributed) / distributionDuration;
-                            const yearlyFeeRewards = (campaignData.propFees * yearlyAmountDistributed) / distributionDuration;
-                            // Approximation because it uses `poolTotalLiquidity` which may contain out of range liquidity
-                            // Approximation as well because the out of range / in range is for all positions and not "per position"
-                            let campaignIndividualAPR = !campaignData.isOutOfRangeIncentivized && (!userBalance0 || !userBalance1)
-                                ? 0
-                                : ((yearlyToken0Rewards * userBalance0) /
-                                    (poolDatas[p].poolBalanceToken0 - (campaignData.blacklistedBalance0 ?? 0)) +
-                                    (yearlyToken1Rewards * userBalance1) /
-                                        (poolDatas[p].poolBalanceToken1 - (campaignData.blacklistedBalance1 ?? 0)) +
-                                    (yearlyFeeRewards *
-                                        (campaignData.isOutOfRangeIncentivized ? userTotalLiquidity : userInRangeLiquidity)) /
-                                        (poolDatas[p].poolTotalLiquidity - (campaignData.blacklistedLiquidity ?? 0))) /
-                                    res.userTVL;
-                            campaignIndividualAPR =
-                                !campaignIndividualAPR || Number.isNaN(campaignIndividualAPR) ? 0 : campaignIndividualAPR;
-                            individualApr += campaignIndividualAPR;
-                        }
-                        if (!!individualApr) {
-                            res.apr[`User current APR ${oneDistributionIsBoosted ? "(based on last distribution boost)" : ""}`] =
-                                individualApr;
-                        }
-                    }
-                    if (res.userPositions.length > 0) {
-                        finalRes[`2_${poolDatas[p].mainParameter ?? p}`] = { ...res };
-                    }
-                }
-                catch (_e) {
-                    console.error(_e);
-                    log.local(`merkl User Data: error for pool ${NETWORK_LABELS[chainId]}-${p}`);
-                }
-            }
-        }
-    }
-    return finalRes;
-}

package/dist/src/libs/positions/clamm/thegraph/fetchAlmPositions.js

@@ -1,36 +0,0 @@
-import { log } from "@/utils/logger";
-// @ts-nocheck
-import { ALM, NETWORK_LABELS, merklSubgraphALMEndpoints, withTimeout } from "@sdk";
-import { BigNumber } from "ethers";
-import { request } from "graphql-request";
-import { almBalancesQuery, almNFTBalancesQuery } from ".";
-import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../../constants";
-export async function fetchAlmPositions(chainId, user) {
-    const res = {};
-    const availableALMEndpoints = merklSubgraphALMEndpoints[chainId];
-    if (Object.keys(availableALMEndpoints).length > 0) {
-        const almPromises = Object.keys(availableALMEndpoints).map(async (alm) => {
-            // FIXME: find another way to assess this issue
-            const tgURL = availableALMEndpoints[alm];
-            if (!!tgURL) {
-                const query = Number.parseInt(alm) === ALM.spNFT ||
-                    Number.parseInt(alm) === ALM.ConcentricStaker ||
-                    Number.parseInt(alm) === ALM.GammaChef
-                    ? almNFTBalancesQuery
-                    : almBalancesQuery;
-                await withTimeout(request(tgURL, query, {
-                    owner: user.toLowerCase(),
-                }).then(requestRes => {
-                    requestRes.holders.forEach(holder => {
-                        res[holder.token] = BigNumber.from(Number.parseInt(alm) === ALM.spNFT ? holder.tokenId : holder.balance);
-                    });
-                }), MERKL_USER_POSITION_FETCHING_TIMEOUT).catch(error => {
-                    const service = `Merkl ALM Subgraph for ${NETWORK_LABELS[chainId]} ${ALM[alm]}`;
-                    log.error(service, error, service, tgURL);
-                });
-            }
-        });
-        await Promise.all(almPromises);
-    }
-    return res;
-}

package/dist/src/libs/positions/clamm/thegraph/fetchAmmPositions.js

@@ -1,36 +0,0 @@
-import { log } from "@/utils/logger";
-// @ts-nocheck
-import { AMM, NETWORK_LABELS, merklSubgraphAMMEndpoints, withTimeout } from "@sdk";
-import { request } from "graphql-request";
-import { positionsQuery } from ".";
-import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../../constants";
-export async function fetchAmmPositions(chainId, user, amms) {
-    const res = {};
-    const promises = amms.map(async (amm) => {
-        const tgURL = merklSubgraphAMMEndpoints[chainId][amm];
-        if (!!tgURL && tgURL !== "") {
-            await withTimeout(request(tgURL, positionsQuery, {
-                owner: user?.toLowerCase(),
-            }), MERKL_USER_POSITION_FETCHING_TIMEOUT)
-                .then(fetchedData => {
-                res[amm] = { nft: [], direct: [] };
-                res[amm].nft = fetchedData?.nft?.reduce((prev, curr) => {
-                    if (!prev.map(i => i.id).includes(curr.id))
-                        prev.push(curr);
-                    return prev;
-                }, []);
-                res[amm].direct = fetchedData?.direct?.reduce((prev, curr) => {
-                    if (!prev.map(i => i.id).includes(curr.id))
-                        prev.push(curr);
-                    return prev;
-                }, []);
-            })
-                .catch(error => {
-                const service = `Merkl AMM Subgraph for ${NETWORK_LABELS[chainId]} ${AMM[amm]}`;
-                log.error(service, error, service, tgURL);
-            });
-        }
-    });
-    await Promise.all(promises);
-    return res;
-}

package/dist/src/libs/positions/clamm/thegraph/fetchFarmedPositions.js

@@ -1,42 +0,0 @@
-// @ts-nocheck
-import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "@/constants";
-import { log } from "@/utils/logger";
-import { AMM, NETWORK_LABELS, getSupportedNFPWrapperMapping, merklSubgraphNFPWrapperEndpoints, withTimeout, } from "@sdk";
-import { request } from "graphql-request";
-import { nftWrapperPositionsQuery } from ".";
-export async function fetchFarmedPositions(chainId, owners, amm) {
-    const res = {};
-    const promises = getSupportedNFPWrapperMapping(chainId, amm).map(async (wrapper) => {
-        const tgURL = merklSubgraphNFPWrapperEndpoints[chainId][wrapper];
-        if (!!tgURL) {
-            await withTimeout((async () => {
-                let hasFollowingPage = true;
-                let skip = 0;
-                while (hasFollowingPage) {
-                    const auxRes = await request(tgURL, nftWrapperPositionsQuery, {
-                        first: 1_000,
-                        owners: owners.map(owner => owner.toLowerCase()),
-                        skip,
-                    });
-                    if (auxRes.holderNFTs.length < 1000) {
-                        hasFollowingPage = false;
-                    }
-                    skip += 1000;
-                    res[wrapper] = (res[wrapper] ?? []).concat(auxRes.holderNFTs.map(p => {
-                        return {
-                            farmAddress: p.id.split("_")[2],
-                            id: p.tokenId,
-                            pool: p.token,
-                            holder: p.holder,
-                        };
-                    }));
-                }
-            })(), MERKL_USER_POSITION_FETCHING_TIMEOUT).catch(error => {
-                const service = `merkl non fungible pos wrapper subgraph for ${NETWORK_LABELS[chainId]} ${AMM[amm]}`;
-                log.error(service, error, service, tgURL);
-            });
-        }
-    });
-    await Promise.all(promises);
-    return res;
-}