@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,419 @@
+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 { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+import { providers } from "../../../utils/providers";
+import { fetchAlmPositionsV2 } from "./thegraph/fetchAlmPositions";
+import { fetchAmmPositionsV2 } from "./thegraph/fetchAmmPositions";
+import { fetchFarmedPositionsV2WithCache } from "./thegraph/fetchFarmedPositions";
+export async function getClammUserPositions(user, chainId, poolsByAmm) {
+    const pricer = await Pricer.load();
+    /**
+     * Fetch user positions
+     */
+    const promisePositions = [
+        fetchAmmPositionsV2(chainId, user, (!!poolsByAmm ? Object.keys(poolsByAmm) : [])),
+        fetchAlmPositionsV2(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 fetchFarmedPositionsV2WithCache(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++;
+                    });
+                }
+            }
+        }
+    }
+    // Calls
+    // all pool calls
+    // all NonFungiblePositionManagerInterface calls by wrapper
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                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: {},
+                                };
+                                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++])[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]).liquidity;
+                                                const tickLower = Number.parseFloat(nonFungiblePositionManagerInterface
+                                                    .decodeFunctionResult("positions", result[j])
+                                                    .tickLower.toString());
+                                                const tickUpper = Number.parseFloat(nonFungiblePositionManagerInterface
+                                                    .decodeFunctionResult("positions", result[j++])
+                                                    .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}`);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                /** 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_${Object.values(poolDatas[p].campaigns)[0].mainParameter}`] = { ...res };
+                                }
+                            }
+                            catch (_e) {
+                                log.local(`merkl User Data: error for pool ${NETWORK_LABELS[chainId]}-${p}`);
+                            }
+                        }
+                    }
+                }
+                return finalRes;
+            },
+        },
+    };
+}

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

@@ -0,0 +1,35 @@
+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";
+import { log } from "../../../../utils/logger";
+export async function fetchAlmPositionsV2(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

@@ -0,0 +1,35 @@
+import { AMM, NETWORK_LABELS, merklSubgraphAMMEndpoints, withTimeout } from "@sdk";
+import { request } from "graphql-request";
+import { positionsQuery } from ".";
+import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../../constants";
+import { log } from "../../../../utils/logger";
+export async function fetchAmmPositionsV2(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] = {};
+                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

@@ -0,0 +1,44 @@
+import { Redis } from "../../../../cache";
+import { MERKL_USER_POSITION_FETCHING_TIMEOUT } from "../../../../constants";
+import { hashArray } from "../../../../utils/hashArray";
+import { AMM, NETWORK_LABELS, getSupportedNFPWrapperMapping, merklSubgraphNFPWrapperEndpoints, withTimeout, } from "@sdk";
+import { request } from "graphql-request";
+import { nftWrapperPositionsQuery } from ".";
+import { log } from "../../../../utils/logger";
+export async function fetchFarmedPositionsV2(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;
+}
+export const fetchFarmedPositionsV2WithCache = async (chainId, user, amm) => await Redis.getOrSet(`FarmedPositions_${hashArray(chainId, user, amm)}$`, fetchFarmedPositionsV2, chainId, user, amm);