@merkl/api 0.19.6 → 0.19.8

package/dist/src/libs/campaigns/campaignTypes/CLAMMDynamicData.js

@@ -1,986 +0,0 @@
-import { nftPositionByIdsQuery, positionMultipleOwnersQuery } from "@/libs/positions/clamm/thegraph";
-import { fetchFarmedPositions } from "@/libs/positions/clamm/thegraph/fetchFarmedPositions";
-import { A51Factory__factory, ALM, ALMMapping, AMM, AMMAlgorithm, AMMAlgorithmMapping, BN2Number, DecodeLiquidity, EAprBreakdownType, ERC20Interface, Forwarder, JonesDoubleRewardTracker__factory, Liquidity, NETWORK_LABELS, NitroInterface, PoolInterface, PoolState, PriorityAMM, SqrtPrice, almName, ammName, getAmountsForLiquidity, getTickAtSqrtRatio, isBlacklisted, isWhitelisted, merklSubgraphAMMEndpoints, shortenAddress, spNFTInterface, withTimeout, } from "@sdk";
-import axios from "axios";
-import { BigNumber, utils } from "ethers";
-import request from "graphql-request";
-import JSBI from "jsbi";
-import moment from "moment";
-import { MERKL_ALM_POSITION_FETCHING_TIMEOUT } from "../../../constants";
-import { log } from "../../../utils/logger";
-import { Pricer } from "../../../utils/pricer";
-import { isStrykeCampaign } from "../../../utils/stryke";
-import { fetchA51Strategies } from "../utils/fetchA51Strategies";
-export async function CLAMMDynamicData(chainId, campaigns) {
-    const dynamicData = [];
-    const pricer = await Pricer.load();
-    const calls = [];
-    const A51Interface = A51Factory__factory.createInterface();
-    /** Dedupe pools from campaigns to build pool list */
-    let poolList = [];
-    for (const campaign of campaigns ?? []) {
-        /** Loop through all campaigns to add pools */
-        if (!poolList?.map(p => p.mainParameter.toLowerCase()).includes(campaign.mainParameter.toLowerCase())) {
-            if (AMMAlgorithmMapping[campaign.campaignParameters.amm] === undefined) {
-                console.log("Invalid AMM", campaign.campaignParameters.amm);
-                continue;
-            }
-            poolList.push({
-                address: campaign.campaignParameters.poolAddress,
-                mainParameter: campaign.mainParameter, // main parameter containes info of poolAddress + AMM (in case its a priority AMM)
-                alms: [],
-                amm: campaign.campaignParameters.amm,
-            });
-        }
-        /** Now we have an entry with campaign.mainParameter in poolList */
-        const poolIndex = poolList
-            ?.map(p => p.mainParameter.toLowerCase())
-            .findIndex(a => a === campaign.mainParameter.toLowerCase());
-        /** Fill ALMs per pools */
-        for (const forwarder of campaign.campaignParameters.forwarders
-            .filter(f => f.forwarderType === Forwarder.CLAMM)
-            .sort((a, b) => a.priority - b.priority)) {
-            const alm = {
-                address: forwarder.sender,
-                ...(!!forwarder.owner && { owner: forwarder.owner?.toLowerCase() }),
-                target: forwarder.target.toLowerCase(),
-                type: forwarder.type,
-                priority: forwarder.priority,
-            };
-            /** If the ALM is not found - add it */
-            if (poolList[poolIndex].alms.findIndex(a => alm.address === a.address && alm.target === a.target) === -1) {
-                poolList[poolIndex].alms.push(alm);
-            }
-        }
-    }
-    poolList = poolList.filter(p => p.amm !== undefined && p.amm !== null);
-    if (!!poolList) {
-        // Prepare A51 fetching
-        const A51Pools = [];
-        for (const pool of poolList) {
-            for (const _ of pool.alms.filter(a => a.type === ALM.A51)) {
-                A51Pools.push(pool.address.toLowerCase());
-            }
-        }
-        let A51Strategies = {};
-        if (A51Pools.length > 0) {
-            A51Strategies = await fetchA51Strategies(chainId, [...new Set(A51Pools)]);
-        }
-        for (const pool of poolList) {
-            const poolInterface = PoolInterface[AMMAlgorithmMapping[pool.amm]];
-            const d = campaigns?.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase())[0];
-            calls.push({
-                allowFailure: true,
-                callData: poolInterface.encodeFunctionData(Liquidity[AMMAlgorithmMapping[pool.amm]]),
-                target: pool.address,
-            }, {
-                allowFailure: true,
-                callData: poolInterface.encodeFunctionData(PoolState[AMMAlgorithmMapping[pool.amm]]),
-                target: pool.address,
-            }, {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("balanceOf", [pool.address]),
-                target: d.campaignParameters.token0,
-            }, {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("balanceOf", [pool.address]),
-                target: d.campaignParameters.token1,
-            });
-            /** Direct ALMs */
-            for (const alm of pool.alms.filter(a => a.target.toLowerCase() === pool.address.toLowerCase() && a.type !== ALM.A51)) {
-                let almAddress = alm.address;
-                if (alm.type === ALM.Beefy) {
-                    almAddress = alm.owner ?? alm.address;
-                }
-                calls.push({
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: alm.address,
-                });
-                calls.push({
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [almAddress]),
-                    target: d.campaignParameters.token0,
-                });
-                calls.push({
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [almAddress]),
-                    target: d.campaignParameters.token1,
-                });
-            }
-            /** Multi-hop ALMs */
-            for (const alm of pool.alms.filter(a => a.target !== pool.address.toLowerCase())) {
-                if (alm.type === ALM.spNFT) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: spNFTInterface.encodeFunctionData("getPoolInfo"),
-                        target: alm.address,
-                    });
-                }
-                else if (alm.type === ALM.kpNFT) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: spNFTInterface.encodeFunctionData("getPoolInfo"),
-                        target: alm.address,
-                    });
-                }
-                else if (alm.type === ALM.Nitro) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: NitroInterface.encodeFunctionData("totalDepositAmount"),
-                        target: alm.address,
-                    });
-                }
-                else if ([ALM.ConcentricStaker, ALM.GammaChef].includes(alm.type)) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: ERC20Interface.encodeFunctionData("balanceOf", [alm.address]),
-                        target: alm.target,
-                    });
-                }
-                else if (alm.type === ALM.JonesTracker) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: JonesDoubleRewardTracker__factory.createInterface().encodeFunctionData("totalStakedAmount"),
-                        target: alm.address,
-                    });
-                }
-                else {
-                    calls.push({
-                        allowFailure: true,
-                        callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                        target: alm.address,
-                    });
-                }
-            }
-            /** A51 Strategies */
-            for (const w of pool.alms.filter(a => a.type === ALM.A51)) {
-                const strategies = A51Strategies?.[pool.address.toLowerCase()]?.[w.address] ?? [];
-                for (const strategy of strategies) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: A51Interface.encodeFunctionData("strategies", [strategy.id]),
-                        target: w.address,
-                    });
-                }
-            }
-        }
-        /**
-         * Fetch all ALM vaults positions for the pools.
-         * @dev Do it in parallel with 1 call / AMM subgraph to save time.
-         */
-        const positions = {};
-        const positionsPromise = Object.keys(AMM)
-            .filter(amm => !!merklSubgraphAMMEndpoints[chainId][Number.parseInt(amm)])
-            .map(async (amm) => {
-            const tgURL = merklSubgraphAMMEndpoints[chainId][Number.parseInt(amm)];
-            let targetAddressesList = [];
-            if (!!poolList) {
-                for (const pool of poolList) {
-                    if (pool.amm === Number.parseInt(amm)) {
-                        /** Add direct alm addresses */
-                        targetAddressesList = targetAddressesList.concat(pool.alms
-                            .filter(a => a.target.toLowerCase() === pool.address.toLowerCase())
-                            ?.map(w => {
-                            return !!w?.owner && Number.parseInt(amm) !== AMM.Stryke
-                                ? w.owner.toLowerCase()
-                                : w.address.toLowerCase();
-                        }) ?? []);
-                        /** Add blacklisted / whitelisted addresses (optional) */
-                        for (const campaign of campaigns.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase())) {
-                            const distributionBlacklist = campaign.campaignId === "0x4a805dd97d823dfbc34d138af3d09536ac792b6ad73079573df082c71d4b057c"
-                                ? [...campaign.campaignParameters.blacklist, "0x657e6d2073A99aF61952beb7EE564169616b90C1"]
-                                : campaign.campaignParameters.blacklist;
-                            if (!!distributionBlacklist && distributionBlacklist.length > 0)
-                                targetAddressesList = targetAddressesList.concat(distributionBlacklist.map((address) => address.toLowerCase()));
-                            let distributionWhitelist = campaign.campaignParameters?.whitelist;
-                            if (distributionWhitelist.length === 1 &&
-                                distributionWhitelist[0].toLowerCase() === "0xE4bA6740aF4c666325D49B3112E4758371386aDc".toLowerCase()) {
-                                distributionWhitelist = ["0xe11d346757d052214686bCbC860C94363AfB4a9A"];
-                            }
-                            if (!isStrykeCampaign(pool.amm) && !!distributionWhitelist && distributionWhitelist.length > 0)
-                                targetAddressesList = targetAddressesList.concat(distributionWhitelist.map((address) => address.toLowerCase()));
-                        }
-                    }
-                }
-            }
-            targetAddressesList = targetAddressesList.filter((a, index, self) => self.indexOf(a) === index); // Dedupe
-            if (targetAddressesList?.length > 0) {
-                positions[Number.parseInt(amm)] = [];
-                /** Fetch NFT Wrapper positions */
-                const farmedPositionsList = await fetchFarmedPositions(chainId, targetAddressesList, Number(amm));
-                const farmedPositionsById = Object.keys(farmedPositionsList).reduce((acc, curr) => {
-                    for (const pos of farmedPositionsList[curr]) {
-                        acc[pos.id] = pos;
-                    }
-                    return acc;
-                }, {});
-                if (Object.keys(farmedPositionsById).length > 0) {
-                    let hasFollowingPage = true;
-                    let skip = 0;
-                    const res = { nft: [] };
-                    while (hasFollowingPage) {
-                        const auxRes = await request(tgURL, nftPositionByIdsQuery, {
-                            ids: Object.keys(farmedPositionsById),
-                            skip,
-                        });
-                        res.nft = res.nft.concat(auxRes.nft ?? []);
-                        if (auxRes.nft.length < 1000) {
-                            hasFollowingPage = false;
-                        }
-                        skip += 1000;
-                    }
-                    if (!!res.nft) {
-                        for (const pos of res.nft) {
-                            positions[Number.parseInt(amm)]?.push({
-                                ...pos,
-                                owner: farmedPositionsById[pos.id].holder,
-                            });
-                        }
-                    }
-                }
-                await withTimeout((async () => {
-                    let hasFollowingPage = true;
-                    let skip = 0;
-                    const res = { direct: [], nft: [] };
-                    while (hasFollowingPage) {
-                        const auxRes = await request(tgURL, positionMultipleOwnersQuery, {
-                            owners: targetAddressesList,
-                            skip,
-                        });
-                        res.direct = res.direct.concat(auxRes.direct ?? []);
-                        res.nft = res.nft.concat(auxRes.nft ?? []);
-                        if (auxRes.direct.length < 1000 && auxRes.nft.length < 1000) {
-                            hasFollowingPage = false;
-                        }
-                        skip += 1000;
-                    }
-                    return res;
-                })().then(res => {
-                    if (!!res.direct) {
-                        for (const pos of res.direct) {
-                            positions[Number.parseInt(amm)]?.push(pos);
-                        }
-                    }
-                    if (!!res.nft) {
-                        for (const pos of res.nft) {
-                            positions[Number.parseInt(amm)]?.push(pos);
-                        }
-                    }
-                }), MERKL_ALM_POSITION_FETCHING_TIMEOUT).catch(error => {
-                    const service = `Merkl AMM Subgraph for ${NETWORK_LABELS[chainId]} ${AMM[Number.parseInt(amm)]}`;
-                    log.error(service, error, service, tgURL);
-                });
-            }
-        });
-        return {
-            cached: false,
-            call: {
-                callData: calls,
-                handler: () => { },
-                reducer: async (result) => {
-                    // Wait for position fetching before finalizing the data
-                    await Promise.all(positionsPromise);
-                    let i = 0;
-                    if (!!poolList) {
-                        for (const pool of poolList) {
-                            const poolInterface = PoolInterface[AMMAlgorithmMapping[pool.amm]];
-                            // This liquidity call gives the active liquidity on the pool. To get the total liquidity we would need to loop over all positions
-                            let poolTotalLiquidity;
-                            let sqrtPrice;
-                            let poolBalanceToken0;
-                            let poolBalanceToken1;
-                            const d = campaigns?.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase())[0];
-                            const decimalsToken0 = d.campaignParameters.decimalsToken0;
-                            const decimalsToken1 = d.campaignParameters.decimalsToken1;
-                            const symbolToken0 = d.campaignParameters.symbolToken0;
-                            const symbolToken1 = d.campaignParameters.symbolToken1;
-                            const prevI = i;
-                            try {
-                                poolTotalLiquidity = BN2Number(poolInterface.decodeFunctionResult(Liquidity[AMMAlgorithmMapping[pool.amm]], result[i++])[DecodeLiquidity[AMMAlgorithmMapping[pool.amm]]]);
-                                sqrtPrice = poolInterface
-                                    .decodeFunctionResult(PoolState[AMMAlgorithmMapping[pool.amm]], result[i++])[SqrtPrice[AMMAlgorithmMapping[pool.amm]]].toString();
-                                poolBalanceToken0 = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0], decimalsToken0);
-                                poolBalanceToken1 = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0], decimalsToken1);
-                            }
-                            catch (e) {
-                                log.warn(`merklDynamic data - failed to decode state of pool ${pool.address} on ${NETWORK_LABELS[chainId]}`);
-                                i = prevI + 4;
-                                continue;
-                            }
-                            const priceToken0 = (await pricer.get({
-                                address: d.campaignParameters.token0,
-                                chainId: chainId,
-                                symbol: symbolToken0,
-                            }));
-                            const priceToken1 = (await pricer.get({
-                                address: d.campaignParameters.token1,
-                                chainId: chainId,
-                                symbol: symbolToken1,
-                            }));
-                            const almDetails = [];
-                            /** Direct ALMs */
-                            for (const w of pool.alms.filter(a => a.target.toLowerCase() === pool.address.toLowerCase() && a.type !== ALM.A51)) {
-                                const prevI = i;
-                                try {
-                                    const totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[i++])[0]);
-                                    const almIdleBalance0 = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0], d.campaignParameters.decimalsToken0);
-                                    let almBalance0 = almIdleBalance0;
-                                    const almIdleBalance1 = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0], d.campaignParameters.decimalsToken1);
-                                    let almBalance1 = almIdleBalance1;
-                                    let almTotalLiquidity = 0;
-                                    let almInRangeLiquidity = 0;
-                                    const almPositions = positions?.[pool.amm]?.filter(pos => pos.pool.id === pool.address.toLowerCase() &&
-                                        [w.address.toLowerCase(), ...[!!w?.owner && w.owner.toLowerCase()]].includes(pos.owner.toLowerCase()));
-                                    const almPositionsWithAPIType = [];
-                                    if (!!almPositions) {
-                                        for (const position of almPositions) {
-                                            const upperTick = Number.parseInt(position.tickUpper);
-                                            const lowerTick = Number.parseInt(position.tickLower);
-                                            const [amount0, amount1] = getAmountsForLiquidity(sqrtPrice, lowerTick, upperTick, BigNumber.from(position.liquidity));
-                                            const balance0 = BN2Number(amount0, decimalsToken0);
-                                            const balance1 = BN2Number(amount1, decimalsToken1);
-                                            const totalLiquidity = BN2Number(position.liquidity);
-                                            const inRangeLiquidity = balance0 > 0 && balance1 > 0 ? (BN2Number(position.liquidity) ?? 0) : 0;
-                                            almTotalLiquidity += totalLiquidity;
-                                            almInRangeLiquidity += inRangeLiquidity;
-                                            almBalance0 += balance0;
-                                            almBalance1 += balance1;
-                                            almPositionsWithAPIType.push({
-                                                balance0,
-                                                balance1,
-                                                id: position.id,
-                                                inRangeLiquidity,
-                                                lowerTick,
-                                                totalLiquidity,
-                                                tvl: priceToken0 * balance0 + priceToken1 * balance1,
-                                                upperTick,
-                                            });
-                                        }
-                                        // The wrapper type can exist in the subgraph without being declared in the SDK which can lead to type errors
-                                        if (!!ALMMapping[pool.amm] && w.type in ALMMapping[pool.amm]) {
-                                            almDetails.push({
-                                                almAPR: 0, // filled later on
-                                                almAddress: utils.getAddress(w.address),
-                                                almBalance0,
-                                                almIdleBalance0,
-                                                almIdleBalance1,
-                                                almBalance1,
-                                                almInRangeLiquidity,
-                                                almTVL: almBalance0 * priceToken0 + almBalance1 * priceToken1,
-                                                almTotalLiquidity,
-                                                forwarderType: Forwarder.CLAMM,
-                                                label: `${ALMMapping[pool.amm]?.[w.type]} ${w.address}`,
-                                                origin: w.type,
-                                                positions: almPositionsWithAPIType,
-                                                priority: 0,
-                                                sender: utils.getAddress(w.address),
-                                                target: w.target,
-                                                owner: utils.getAddress(w.owner ?? w.address),
-                                                totalSupply,
-                                                type: w.type,
-                                            });
-                                        }
-                                    }
-                                }
-                                catch (e) {
-                                    log.warn(`merklDynamic data - failed to handle direct alm data of pool ${pool.address} on ${NETWORK_LABELS[chainId]} - ${w.address}`);
-                                    i = prevI + 3;
-                                }
-                            }
-                            /** Multi-hop ALMs */
-                            for (const w of pool.alms.filter(a => a.target !== pool.address.toLowerCase())) {
-                                const prevI = i;
-                                try {
-                                    let totalSupply;
-                                    if (w.type === ALM.spNFT) {
-                                        totalSupply = BN2Number(spNFTInterface.decodeFunctionResult("getPoolInfo", result[i++])[5]);
-                                    }
-                                    else if (w.type === ALM.kpNFT) {
-                                        totalSupply = BN2Number(spNFTInterface.decodeFunctionResult("getPoolInfo", result[i++])[5]);
-                                    }
-                                    else if (w.type === ALM.Nitro) {
-                                        totalSupply = BN2Number(NitroInterface.decodeFunctionResult("totalDepositAmount", result[i++])[0]);
-                                    }
-                                    else if ([ALM.ConcentricStaker, ALM.GammaChef].includes(w.type)) {
-                                        totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0]);
-                                    }
-                                    else if (w.type === ALM.JonesTracker) {
-                                        totalSupply = BN2Number(JonesDoubleRewardTracker__factory.createInterface().decodeFunctionResult("totalStakedAmount", result[i++])[0]);
-                                    }
-                                    else {
-                                        totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[i++])[0]);
-                                    }
-                                    const wrappedALM = almDetails.filter(a => utils.getAddress(a.almAddress) === utils.getAddress(w.target))[0];
-                                    if (!!wrappedALM && !!wrappedALM.totalSupply) {
-                                        const ratio = totalSupply / wrappedALM.totalSupply;
-                                        almDetails.push({
-                                            almAPR: 0,
-                                            // filled later on
-                                            almAddress: w.address,
-                                            almIdleBalance0: 0,
-                                            almIdleBalance1: 0,
-                                            almBalance0: ratio * wrappedALM.almBalance0,
-                                            almBalance1: ratio * wrappedALM.almBalance1,
-                                            almInRangeLiquidity: ratio * wrappedALM.almInRangeLiquidity,
-                                            almTVL: ratio * wrappedALM.almTVL,
-                                            almTotalLiquidity: ratio * wrappedALM.almTotalLiquidity,
-                                            forwarderType: Forwarder.CLAMM,
-                                            label: `${ALMMapping[pool.amm]?.[w.type]} ${w.address}`,
-                                            origin: w.type,
-                                            positions: wrappedALM.positions.map(pos => {
-                                                return {
-                                                    ...pos,
-                                                    balance0: ratio * pos.balance0,
-                                                    balance1: ratio * pos.balance1,
-                                                    inRangeLiquidity: ratio * pos.inRangeLiquidity,
-                                                    totalLiquidity: ratio * pos.totalLiquidity,
-                                                    tvl: ratio * pos.tvl,
-                                                };
-                                            }),
-                                            priority: wrappedALM.priority + 1,
-                                            sender: utils.getAddress(w.address),
-                                            target: w.target,
-                                            owner: w.owner ?? w.address,
-                                            totalSupply,
-                                            type: w.type,
-                                        });
-                                    }
-                                    else {
-                                        log.local(`Target ALM not found (${NETWORK_LABELS[chainId]}). Address: ${w.address}, Target: ${w.target}`);
-                                    }
-                                }
-                                catch {
-                                    log.warn(`merklDynamic data - failed to handle multi hop alm data of pool ${pool.address} on ${NETWORK_LABELS[chainId]} - ${w.address}`);
-                                    i = prevI + 1;
-                                }
-                            }
-                            /** A51 Strategies */
-                            for (const w of pool.alms.filter(a => a.type === ALM.A51)) {
-                                const prevI = i;
-                                const strategies = A51Strategies?.[pool.address.toLowerCase()]?.[w.address] ?? [];
-                                let j = 0;
-                                for (const strategy of strategies) {
-                                    j++;
-                                    const almPositionsWithAPIType = [];
-                                    let almTotalLiquidity = 0;
-                                    let almInRangeLiquidity = 0;
-                                    let almBalance0 = 0;
-                                    let almBalance1 = 0;
-                                    try {
-                                        //   struct StrategyData {
-                                        //     StrategyKey key; 0
-                                        //     address owner; 1
-                                        //     bytes actions; 2
-                                        //     bytes actionStatus; 3
-                                        //     bool isCompound; 4
-                                        //     bool isPrivate; 5
-                                        //     uint256 managementFee; 6
-                                        //     uint256 performanceFee; 7
-                                        //     Account account; 8
-                                        // }
-                                        const strategyAccount = A51Interface.decodeFunctionResult("strategies", result[i++])[8];
-                                        //   struct Account {
-                                        //     uint256 fee0; 0
-                                        //     uint256 fee1; 1
-                                        //     uint256 balance0; 2
-                                        //     uint256 balance1; 3
-                                        //     uint256 totalShares; 4
-                                        //     uint128 uniswapLiquidity;
-                                        //     uint256 feeGrowthInside0LastX128;
-                                        //     uint256 feeGrowthInside1LastX128;
-                                        //     uint256 feeGrowthOutside0LastX128;
-                                        //     uint256 feeGrowthOutside1LastX128;
-                                        //   }
-                                        const a51Positions = positions?.[pool.amm]?.filter(pos => pos.pool.id === pool.address.toLowerCase() &&
-                                            pos.owner === w.address.toLowerCase() &&
-                                            pos.tickLower === strategy.tickLower.toString() &&
-                                            pos.tickUpper === strategy.tickUpper.toString());
-                                        if (!!a51Positions) {
-                                            for (const position of a51Positions) {
-                                                const upperTick = Number.parseInt(position.tickUpper);
-                                                const lowerTick = Number.parseInt(position.tickLower);
-                                                const [amount0, amount1] = getAmountsForLiquidity(sqrtPrice, lowerTick, upperTick, BigNumber.from(position.liquidity));
-                                                const balance0 = BN2Number(amount0, decimalsToken0);
-                                                const balance1 = BN2Number(amount1, decimalsToken1);
-                                                const totalLiquidity = BN2Number(position.liquidity);
-                                                const inRangeLiquidity = balance0 > 0 && balance1 > 0 ? (BN2Number(position.liquidity) ?? 0) : 0;
-                                                almTotalLiquidity += totalLiquidity;
-                                                almInRangeLiquidity += inRangeLiquidity;
-                                                almBalance0 += balance0;
-                                                almBalance1 += balance1;
-                                                almPositionsWithAPIType.push({
-                                                    balance0,
-                                                    balance1,
-                                                    id: position.id,
-                                                    inRangeLiquidity,
-                                                    lowerTick,
-                                                    totalLiquidity,
-                                                    tvl: priceToken0 * balance0 + priceToken1 * balance1,
-                                                    upperTick,
-                                                });
-                                            }
-                                        }
-                                        if (!!ALMMapping[pool.amm] && w.type in ALMMapping[pool.amm]) {
-                                            almDetails.push({
-                                                almAPR: 0,
-                                                // filled later on
-                                                almAddress: utils.getAddress(w.address),
-                                                almBalance0,
-                                                almBalance1,
-                                                almIdleBalance0: 0,
-                                                almIdleBalance1: 0,
-                                                almInRangeLiquidity,
-                                                almTVL: almBalance0 * priceToken0 + almBalance1 * priceToken1,
-                                                almTotalLiquidity,
-                                                forwarderType: Forwarder.CLAMM,
-                                                label: `${ALMMapping[pool.amm]?.[w.type]} ${w.address} - ${strategy.id}`,
-                                                origin: w.type,
-                                                positions: almPositionsWithAPIType,
-                                                priority: 0,
-                                                sender: w.address,
-                                                target: w.target,
-                                                owner: w.owner ?? w.address,
-                                                totalSupply: strategyAccount[4].toString(),
-                                                type: w.type,
-                                            });
-                                        }
-                                    }
-                                    catch (e) {
-                                        log.warn(`merklDynamic data - failed to handle A51 data of pool ${pool.address} on ${NETWORK_LABELS[chainId]} - ${w.address}`);
-                                        i = prevI + j;
-                                    }
-                                }
-                            }
-                            /** Iterate over distributions to compute APRs */
-                            for (const campaign of campaigns.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase())) {
-                                const c = campaign;
-                                const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
-                                const startTimestamp = BN2Number(c.startTimestamp, 0);
-                                const endTimestamp = BN2Number(c.endTimestamp, 0);
-                                const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
-                                const totalWeight = BN2Number(c.campaignParameters.weightFees, 4) +
-                                    BN2Number(c.campaignParameters.weightToken0, 4) +
-                                    BN2Number(c.campaignParameters.weightToken1, 4);
-                                // Proportions in percentage
-                                const propFees = (BN2Number(c.campaignParameters.weightFees, 4) / totalWeight) * 100;
-                                const propToken0 = (BN2Number(c.campaignParameters.weightToken0, 4) / totalWeight) * 100;
-                                const propToken1 = (BN2Number(c.campaignParameters.weightToken1, 4) / totalWeight) * 100;
-                                let distributionMeanAPR = 0;
-                                let blacklistedBalance0 = 0;
-                                let blacklistedBalance1 = 0;
-                                let blacklistedLiquidity = 0;
-                                /**
-                                 * @dev In case there is a super amm handling some other amm lp positions,
-                                 *      we only need to check the positions associated to this super amm subgraph
-                                 *      in order to compute the APRs.
-                                 *      Yet, the pool will still be labelled with the main amm
-                                 */
-                                const amm = c.campaignParameters.whitelist.length > 0 &&
-                                    !!PriorityAMM?.[chainId]?.[c.campaignParameters.whitelist[0]]
-                                    ? PriorityAMM[chainId]?.[c.campaignParameters.whitelist[0]]
-                                    : pool.amm;
-                                const aprs = {};
-                                const aprBreakdowns = [];
-                                /** Clear alm APRs */
-                                const distributionForwarders = almDetails.map(x => ({ ...x }));
-                                let priceRewardToken = 0;
-                                if (isLive && c.campaignParameters.symbolRewardToken !== "aglaMerkl") {
-                                    priceRewardToken = (await pricer.get({
-                                        address: c.rewardToken,
-                                        chainId: chainId,
-                                        symbol: c.campaignParameters.symbolRewardToken,
-                                    }));
-                                    /**
-                                     * Handle whitelisted/blacklisted addresses to compute APR
-                                     */
-                                    if (c.campaignParameters.whitelist.length > 0) {
-                                        blacklistedBalance0 = poolBalanceToken0;
-                                        blacklistedBalance1 = poolBalanceToken1;
-                                        blacklistedLiquidity = poolTotalLiquidity;
-                                        // Get all beefy staker is whitelisted, get a list of all senders
-                                        let targetToMatch = "";
-                                        for (const alm of almDetails.filter(a => a.type === ALM.BeefyStaker)) {
-                                            if (c.campaignParameters.whitelist.includes(alm.sender)) {
-                                                targetToMatch = alm.target;
-                                            }
-                                        }
-                                        if (targetToMatch !== "") {
-                                            for (const alm of almDetails.filter(a => a.type === ALM.Beefy)) {
-                                                if (targetToMatch === alm.sender.toLowerCase()) {
-                                                    c.campaignParameters.whitelist.push(alm.owner);
-                                                }
-                                            }
-                                        }
-                                        positions?.[pool.amm]?.forEach(pos => {
-                                            if (pos.pool.id === pool.address.toLowerCase() &&
-                                                (isWhitelisted(pos.owner, c.campaignParameters.whitelist) || isStrykeCampaign(pool.amm))) {
-                                                let [amount0, amount1] = [BigNumber.from(0), BigNumber.from(0)];
-                                                try {
-                                                    [amount0, amount1] = getAmountsForLiquidity(sqrtPrice, Number.parseInt(pos.tickLower), Number.parseInt(pos.tickUpper), BigNumber.from(pos.liquidity));
-                                                }
-                                                catch {
-                                                    log.warn(`merklDynamic data - failed to handle whitelisted positions of pool ${pool.address} on ${NETWORK_LABELS[chainId]} - ${pos.owner} ${pos.tickLower} ${pos.tickUpper} ${pos.liquidity}`);
-                                                }
-                                                blacklistedBalance0 -= BN2Number(amount0, decimalsToken0);
-                                                blacklistedBalance1 -= BN2Number(amount1, decimalsToken1);
-                                                if (c.campaignParameters.isOutOfRangeIncentivized
-                                                    ? BN2Number(amount0, decimalsToken0) > 0 || BN2Number(amount1, decimalsToken1) > 0
-                                                    : BN2Number(amount0, decimalsToken0) > 0 && BN2Number(amount1, decimalsToken1) > 0)
-                                                    blacklistedLiquidity -= BN2Number(pos.liquidity);
-                                            }
-                                            // Handling the case of a ALM of priority 2 being whitelisted
-                                            else if (pos.pool.id === pool.address.toLowerCase() &&
-                                                almDetails.map(a => a.target.toLowerCase()).includes(pos.owner.toLowerCase()) // If pos owner is an ALM
-                                            ) {
-                                                // If we're in this branch it means the ALM owning the position is not whitelisted
-                                                const almHolding = almDetails.filter(a => a.almAddress.toLowerCase() === pos.owner.toLowerCase())[0];
-                                                for (const whitelistedAddress of c.campaignParameters.whitelist) {
-                                                    const forwarderIndex = distributionForwarders.findIndex(f => utils.getAddress(f.almAddress) === utils.getAddress(whitelistedAddress));
-                                                    if (forwarderIndex !== -1 &&
-                                                        almHolding.almAddress.toLowerCase() ===
-                                                            distributionForwarders[forwarderIndex].target.toLowerCase()) {
-                                                        // If we are here it means one of the ALM whitelisted is a "child" of the ALM holding the position
-                                                        const childALM = distributionForwarders[forwarderIndex];
-                                                        let [amount0, amount1] = [BigNumber.from(0), BigNumber.from(0)];
-                                                        try {
-                                                            [amount0, amount1] = getAmountsForLiquidity(sqrtPrice, Number.parseInt(pos.tickLower), Number.parseInt(pos.tickUpper), BigNumber.from(pos.liquidity));
-                                                        }
-                                                        catch {
-                                                            log.warn(`merklDynamic data - failed to handle whitelisted positions of pool ${pool.address} on ${NETWORK_LABELS[chainId]} - ${pos.owner} ${pos.tickLower} ${pos.tickUpper} ${pos.liquidity}`);
-                                                        }
-                                                        blacklistedBalance0 -=
-                                                            (BN2Number(amount0, decimalsToken0) * childALM.almBalance0) / almHolding.almBalance0;
-                                                        blacklistedBalance1 -=
-                                                            (BN2Number(amount1, decimalsToken1) * childALM.almBalance1) / almHolding.almBalance1;
-                                                        if (c.campaignParameters.isOutOfRangeIncentivized
-                                                            ? BN2Number(amount0, decimalsToken0) > 0 || BN2Number(amount1, decimalsToken1) > 0
-                                                            : BN2Number(amount0, decimalsToken0) > 0 && BN2Number(amount1, decimalsToken1) > 0)
-                                                            blacklistedLiquidity -=
-                                                                (BN2Number(pos.liquidity) * childALM.almTotalLiquidity) / almHolding.almTotalLiquidity;
-                                                    }
-                                                }
-                                            }
-                                        });
-                                    }
-                                    else if (c.campaignParameters.blacklist.length > 0) {
-                                        blacklistedBalance0 = 0;
-                                        blacklistedBalance1 = 0;
-                                        blacklistedLiquidity = 0;
-                                        for (const blacklistedAddress of c.campaignParameters.blacklist) {
-                                            const blackAddressPositions = positions?.[amm]?.filter(pos => pos.pool.id === pool.address.toLowerCase() && pos.owner === blacklistedAddress.toLowerCase());
-                                            if (!!blackAddressPositions) {
-                                                for (const position of blackAddressPositions) {
-                                                    const [amount0, amount1] = getAmountsForLiquidity(sqrtPrice, Number.parseInt(position.tickLower), Number.parseInt(position.tickUpper), BigNumber.from(position.liquidity));
-                                                    blacklistedBalance0 += BN2Number(amount0, decimalsToken0);
-                                                    blacklistedBalance1 += BN2Number(amount1, decimalsToken1);
-                                                    if (BN2Number(amount0, decimalsToken0) > 0 && BN2Number(amount1, decimalsToken1) > 0)
-                                                        blacklistedLiquidity += BN2Number(position.liquidity);
-                                                }
-                                            }
-                                        }
-                                    }
-                                    /** Yearly rewards in $ */
-                                    const yearlyToken0Rewards = (propToken0 * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
-                                    const yearlyToken1Rewards = (propToken1 * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
-                                    const yearlyFeeRewards = (propFees * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
-                                    let poolAPRkey = "";
-                                    // /**
-                                    //  * @notice Stryke users receive rewards with respect to their LP positions (they hold through
-                                    //  *         Stryke contracts and the `used liquidity` hold in the Stryke option market contracts
-                                    //  */
-                                    // if (amm === AMM.Stryke || amm === AMM.StrykePCS) {
-                                    //   try {
-                                    //     poolBalanceToken0 +=
-                                    //       BN2Number(
-                                    //         await Erc20__factory.connect(c.campaignParameters.token0, providers[chainId]).balanceOf(
-                                    //           DOPEX_OPTION_MARKET[pool.address.toLowerCase()]
-                                    //         ),
-                                    //         c.campaignParameters.decimalsToken0
-                                    //       ) / 2;
-                                    //     poolBalanceToken1 +=
-                                    //       BN2Number(
-                                    //         await Erc20__factory.connect(c.campaignParameters.token1, providers[chainId]).balanceOf(
-                                    //           DOPEX_OPTION_MARKET[pool.address.toLowerCase()]
-                                    //         ),
-                                    //         c.campaignParameters.decimalsToken1
-                                    //       ) / 2;
-                                    //   } catch {
-                                    //     log.error(
-                                    //       "clamm dynamic data fetching",
-                                    //       `failed to handle dopex option market - ${pool.address}`
-                                    //     );
-                                    //   }
-                                    // }
-                                    /**
-                                     * General APR (@notice potentially with a boost)
-                                     */
-                                    let poolBalanceToken0WithoutBlacklist = poolBalanceToken0 - (blacklistedBalance0 ?? 0);
-                                    poolBalanceToken0WithoutBlacklist = !!poolBalanceToken0WithoutBlacklist
-                                        ? poolBalanceToken0WithoutBlacklist
-                                        : 0.00001;
-                                    let poolBalanceToken1WithoutBlacklist = poolBalanceToken1 - (blacklistedBalance1 ?? 0);
-                                    poolBalanceToken1WithoutBlacklist = !!poolBalanceToken1WithoutBlacklist
-                                        ? poolBalanceToken1WithoutBlacklist
-                                        : 0.00001;
-                                    const poolLiquidityWithoutBlacklist = poolTotalLiquidity - (blacklistedLiquidity ?? 0);
-                                    const tvl = isStrykeCampaign(amm)
-                                        ? (await axios.get(`https://api.stryke.xyz/clamm/stats/tvl/${pool.address}?chainId=${chainId}`)).data
-                                        : poolBalanceToken0WithoutBlacklist * priceToken0 + poolBalanceToken1WithoutBlacklist * priceToken1;
-                                    distributionMeanAPR = (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) / tvl;
-                                    distributionMeanAPR =
-                                        !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
-                                    /**
-                                     * @dev We cannot include a whitelisted distrib apr into the mean APR
-                                     */
-                                    if (c.campaignParameters.whitelist.length === 0) {
-                                        poolAPRkey = "Average APR (rewards / pool TVL)";
-                                        if (!aprs[poolAPRkey])
-                                            aprs[poolAPRkey] = 0;
-                                        aprs[poolAPRkey] += distributionMeanAPR;
-                                        // @Hugo wip: new way to structure aprBreakdowns
-                                        aprBreakdowns.push({
-                                            address: pool.address,
-                                            value: distributionMeanAPR,
-                                            type: EAprBreakdownType.AVERAGE,
-                                            label: "Average APR (rewards / pool TVL)",
-                                        });
-                                        // APR per token
-                                        poolAPRkey = `APR for holding ${c.campaignParameters.symbolToken0} in pool`;
-                                        if (!aprs[poolAPRkey])
-                                            aprs[poolAPRkey] = 0;
-                                        aprs[poolAPRkey] += yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0);
-                                        // @Hugo wip: new way to structure aprBreakdowns
-                                        aprBreakdowns.push({
-                                            address: pool.address,
-                                            value: yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0),
-                                            type: EAprBreakdownType.TOKEN1,
-                                            label: c.campaignParameters.symbolToken0,
-                                        });
-                                        poolAPRkey = `APR for holding  ${c.campaignParameters.symbolToken1} in pool`;
-                                        if (!aprs[poolAPRkey])
-                                            aprs[poolAPRkey] = 0;
-                                        aprs[poolAPRkey] += yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1);
-                                        // @Hugo wip: new way to structure aprBreakdowns
-                                        aprBreakdowns.push({
-                                            address: pool.address,
-                                            value: yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1),
-                                            type: EAprBreakdownType.TOKEN2,
-                                            label: c.campaignParameters.symbolToken1,
-                                        });
-                                    }
-                                    else {
-                                        for (const whitelistedAddress of c.campaignParameters.whitelist) {
-                                            const forwarderIndex = distributionForwarders.findIndex(f => utils.getAddress(f.almAddress) === utils.getAddress(whitelistedAddress));
-                                            const poolAPRkey = `Whitelisted campaign on ${ammName(amm)} via address ${shortenAddress(c.campaignParameters.whitelist[0])} Average APR`;
-                                            if (!aprs[poolAPRkey])
-                                                aprs[poolAPRkey] = 0;
-                                            // Account for idle liquidity
-                                            if (forwarderIndex > -1) {
-                                                // @Hugo wip: new way to structure aprBreakdowns
-                                                const breakdownWl = {
-                                                    address: c.campaignParameters.whitelist[0],
-                                                    value: 0,
-                                                    type: EAprBreakdownType.WHITELIST,
-                                                    label: ammName(amm),
-                                                };
-                                                if (distributionForwarders[forwarderIndex].priority === 2) {
-                                                    distributionMeanAPR =
-                                                        (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) /
-                                                            (tvl +
-                                                                distributionForwarders[forwarderIndex].almBalance0 * priceToken0 +
-                                                                distributionForwarders[forwarderIndex].almBalance1 * priceToken1);
-                                                }
-                                                else {
-                                                    distributionMeanAPR =
-                                                        (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) /
-                                                            (tvl +
-                                                                distributionForwarders[forwarderIndex].almIdleBalance0 * priceToken0 +
-                                                                distributionForwarders[forwarderIndex].almIdleBalance1 * priceToken1);
-                                                }
-                                                distributionMeanAPR =
-                                                    !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
-                                                // @Hugo wip: new way to structure aprBreakdowns
-                                                breakdownWl.value = distributionMeanAPR;
-                                                aprBreakdowns.push(breakdownWl);
-                                            }
-                                        }
-                                        aprs[poolAPRkey] += distributionMeanAPR;
-                                    }
-                                    /**
-                                     * ALM APRs
-                                     * @notice given a campaign
-                                     * */
-                                    distributionForwarders.forEach((alm, index) => {
-                                        const targetForwarder = distributionForwarders.filter(f => f.almAddress.toLowerCase() === alm.target.toLowerCase())?.[0];
-                                        // @Hugo wip: new way to structure aprBreakdowns
-                                        const aprsBreakdown = getForwarderAprbreakDown(distributionForwarders, alm, c, pool, yearlyToken0Rewards, yearlyToken1Rewards, yearlyFeeRewards, poolBalanceToken0WithoutBlacklist, poolBalanceToken1WithoutBlacklist, poolLiquidityWithoutBlacklist, tvl, distributionMeanAPR, index, chainId, amm);
-                                        // @Hugo wip: new way to structure aprBreakdowns
-                                        aprsBreakdown && aprBreakdowns.push(aprsBreakdown);
-                                        const isALMWhitelisted = c.campaignParameters.whitelist.length > 0
-                                            ? isStrykeCampaign(pool.amm)
-                                                ? true
-                                                : isWhitelisted(alm.sender, c.campaignParameters.whitelist) ||
-                                                    isWhitelisted(alm.almAddress, c.campaignParameters.whitelist) ||
-                                                    isWhitelisted(!!alm?.owner ? alm.owner : "", c.campaignParameters.whitelist) ||
-                                                    isWhitelisted(!!alm?.target ? alm.target : "", c.campaignParameters.whitelist) ||
-                                                    (!!targetForwarder?.owner &&
-                                                        isWhitelisted(targetForwarder?.owner, c.campaignParameters.whitelist))
-                                            : true;
-                                        const isBlacklistedByCampaign = isBlacklisted(alm.sender, c.campaignParameters.blacklist) ||
-                                            isBlacklisted(alm.almAddress, c.campaignParameters.blacklist) ||
-                                            (!!alm?.target && isBlacklisted(alm?.target, c.campaignParameters.blacklist)) ||
-                                            !isALMWhitelisted;
-                                        if (!isBlacklistedByCampaign && !!alm.almTVL && alm.almTVL > 0) {
-                                            try {
-                                                poolAPRkey = `${almName(alm.origin)} ${alm.almAddress}`;
-                                                if (!aprs[poolAPRkey])
-                                                    aprs[poolAPRkey] = 0;
-                                                // Token 0 APR
-                                                const almToken0APR = (yearlyToken0Rewards * (alm?.almBalance0 ?? 0 - alm?.almIdleBalance0 ?? 0)) /
-                                                    poolBalanceToken0WithoutBlacklist /
-                                                    alm.almTVL;
-                                                aprs[poolAPRkey] += almToken0APR;
-                                                // Token 1 APR
-                                                const almToken1APR = (yearlyToken1Rewards * (alm?.almBalance1 ?? 0 - alm?.almIdleBalance1 ?? 0)) /
-                                                    poolBalanceToken1WithoutBlacklist /
-                                                    alm.almTVL;
-                                                ((alm.almBalance1 / (alm?.almBalance1 ?? 0 + alm?.almIdleBalance1 ?? 0)) *
-                                                    alm.almBalance1 *
-                                                    yearlyToken1Rewards) /
-                                                    poolBalanceToken1WithoutBlacklist /
-                                                    alm.almTVL;
-                                                aprs[poolAPRkey] += almToken1APR;
-                                                // Fee APR
-                                                const almFeeAPR = (yearlyFeeRewards * (alm?.almInRangeLiquidity ?? 0)) /
-                                                    poolLiquidityWithoutBlacklist /
-                                                    alm.almTVL;
-                                                aprs[poolAPRkey] += almFeeAPR;
-                                                if (isStrykeCampaign(amm)) {
-                                                    // computation is less precise here as we don't have the details of balances
-                                                    aprs[poolAPRkey] = (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) / tvl;
-                                                }
-                                                /** Fix to tackle discrepancies in the APRs when there is a whitelist */
-                                                if ((c.campaignParameters.whitelist?.length === 1 &&
-                                                    (isWhitelisted(alm.sender, c.campaignParameters.whitelist) ||
-                                                        isWhitelisted(alm.almAddress, c.campaignParameters.whitelist) ||
-                                                        isWhitelisted(!!alm?.target ? alm.target : "", c.campaignParameters.whitelist) ||
-                                                        isWhitelisted(!!alm?.owner ? alm.owner : "", c.campaignParameters.whitelist))) ||
-                                                    (!!targetForwarder?.owner &&
-                                                        isWhitelisted(targetForwarder?.owner, c.campaignParameters.whitelist))) {
-                                                    if (aprs[poolAPRkey] < distributionMeanAPR || !aprs[poolAPRkey] || aprs[poolAPRkey] > 1e12) {
-                                                        aprs[poolAPRkey] = distributionMeanAPR;
-                                                    }
-                                                }
-                                                distributionForwarders[index].almAPR = aprs[poolAPRkey];
-                                            }
-                                            catch (e) {
-                                                log.error("CLAMMDynamicData", `failed to compute ALM APR for ${alm.almAddress} (sender ${alm.sender}) on ${NETWORK_LABELS[chainId]}: ${e}`);
-                                            }
-                                        }
-                                    });
-                                }
-                                dynamicData.push({
-                                    ...campaign,
-                                    amm: pool.amm,
-                                    ammAlgo: AMMAlgorithmMapping[pool.amm],
-                                    ammAlgoName: AMMAlgorithm[AMMAlgorithmMapping[pool.amm]],
-                                    ammName: AMM[pool.amm],
-                                    apr: distributionMeanAPR,
-                                    aprs,
-                                    aprBreakdowns,
-                                    blacklistedBalance0,
-                                    blacklistedBalance1,
-                                    blacklistedLiquidity,
-                                    forwarders: distributionForwarders,
-                                    isLive,
-                                    isMock: c.campaignParameters.symbolRewardToken === "aglaMerkl",
-                                    poolBalanceToken0,
-                                    poolBalanceToken1,
-                                    poolTotalLiquidity,
-                                    symbolToken0,
-                                    symbolToken1,
-                                    tick: getTickAtSqrtRatio(JSBI.BigInt(sqrtPrice)),
-                                    priceRewardToken: priceRewardToken,
-                                    tvl: isStrykeCampaign(pool.amm)
-                                        ? (await axios.get(`https://api.stryke.xyz/clamm/stats/tvl/${pool.address}?chainId=${chainId}`)).data
-                                        : poolBalanceToken0 * priceToken0 + poolBalanceToken1 * priceToken1,
-                                });
-                            }
-                        }
-                    }
-                    return dynamicData;
-                },
-            },
-        };
-    }
-    // Fallback in case something fails
-    return {
-        cached: false,
-        call: {
-            callData: [],
-            handler: () => { },
-            reducer: async (_result) => {
-                return campaigns;
-            },
-        },
-    };
-}
-function getForwarderAprbreakDown(distributionForwarders, alm, campaign, pool, yearlyToken0Rewards, yearlyToken1Rewards, yearlyFeeRewards, poolBalanceToken0WithoutBlacklist, poolBalanceToken1WithoutBlacklist, poolLiquidityWithoutBlacklist, tvl, distributionMeanAPR, index, chainId, amm) {
-    if (!distributionForwarders)
-        return null;
-    let aprBreakdowns = null;
-    const targetForwarder = distributionForwarders.filter(f => f.almAddress.toLowerCase() === alm.target.toLowerCase())?.[0];
-    const isALMWhitelisted = campaign.campaignParameters.whitelist.length > 0
-        ? isStrykeCampaign(pool.amm)
-            ? true
-            : isWhitelisted(alm.sender, campaign.campaignParameters.whitelist) ||
-                isWhitelisted(alm.almAddress, campaign.campaignParameters.whitelist) ||
-                isWhitelisted(!!alm?.owner ? alm.owner : "", campaign.campaignParameters.whitelist) ||
-                isWhitelisted(!!alm?.target ? alm.target : "", campaign.campaignParameters.whitelist) ||
-                (!!targetForwarder?.owner && isWhitelisted(targetForwarder?.owner, campaign.campaignParameters.whitelist))
-        : true;
-    const isBlacklistedByCampaign = isBlacklisted(alm.sender, campaign.campaignParameters.blacklist) ||
-        isBlacklisted(alm.almAddress, campaign.campaignParameters.blacklist) ||
-        (!!alm?.target && isBlacklisted(alm?.target, campaign.campaignParameters.blacklist)) ||
-        !isALMWhitelisted;
-    if (!isBlacklistedByCampaign && !!alm.almTVL && alm.almTVL > 0) {
-        try {
-            // Token 0 APR
-            const almToken0APR = (yearlyToken0Rewards * (alm?.almBalance0 ?? 0 - alm?.almIdleBalance0 ?? 0)) /
-                poolBalanceToken0WithoutBlacklist /
-                alm.almTVL;
-            // Token 1 APR
-            const almToken1APR = (yearlyToken1Rewards * (alm?.almBalance1 ?? 0 - alm?.almIdleBalance1 ?? 0)) /
-                poolBalanceToken1WithoutBlacklist /
-                alm.almTVL;
-            // Fee APR
-            const almFeeAPR = (yearlyFeeRewards * (alm?.almInRangeLiquidity ?? 0)) / poolLiquidityWithoutBlacklist / alm.almTVL;
-            let aprValue = almToken0APR + almToken1APR + almFeeAPR;
-            // computation is less precise here as we don't have the details of balances
-            if (isStrykeCampaign(amm))
-                aprValue = (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) / tvl;
-            /** Fix to tackle discrepancies in the APRs when there is a whitelist */
-            if ((campaign.campaignParameters.whitelist?.length === 1 &&
-                (isWhitelisted(alm.sender, campaign.campaignParameters.whitelist) ||
-                    isWhitelisted(alm.almAddress, campaign.campaignParameters.whitelist) ||
-                    isWhitelisted(!!alm?.target ? alm.target : "", campaign.campaignParameters.whitelist) ||
-                    isWhitelisted(!!alm?.owner ? alm.owner : "", campaign.campaignParameters.whitelist))) ||
-                (!!targetForwarder?.owner && isWhitelisted(targetForwarder?.owner, campaign.campaignParameters.whitelist))) {
-                if (aprValue < distributionMeanAPR || !aprValue || aprValue > 1e12)
-                    aprValue = distributionMeanAPR;
-            }
-            aprBreakdowns = {
-                address: pool.address,
-                value: aprValue,
-                type: EAprBreakdownType.FORWARDER,
-                label: almName(alm.origin),
-            };
-            distributionForwarders[index].almAPR = aprValue; // @Hugo wip: new way to structure aprBreakdowns + check this
-        }
-        catch (e) {
-            log.error("CLAMMDynamicData", `failed to compute ALM APR for ${alm.almAddress} (sender ${alm.sender}) on ${NETWORK_LABELS[chainId]}: ${e}`);
-        }
-    }
-    return aprBreakdowns;
-}