@merkl/api 0.15.17 → 0.15.19

package/dist/src/constants.d.ts

@@ -1,3 +1,4 @@
+import { ChainId, type MerklChainId } from "@sdk";
 import Big from "big.js";
 export declare const zeroBN: Big.Big;
 export declare const baseTestAnalyticsGraphUrl = "https://api.thegraph.com/subgraphs/name/angleprotocol/test-analytics-";
@@ -29,7 +30,6 @@ export declare const RFX_DATASTORE = "0x895124783008C6c68eFcccac24c482Fdf30439B2
 export declare const DOPEX_OPTION_MARKET: {
     [market: string]: string;
 };
-import { ChainId } from "@sdk";
 export declare const constantChain: {
     [x: number]: {
         apw: string;
@@ -349,3 +349,6 @@ export declare const constantChain: {
     };
 };
 export declare const MAVERICK_ZKSYNC_BP_LENS_ADDRESS = "0xd32CE31CaC98CAC0631764B8286358c0606D87F9";
+export declare const NETWORK_SLUGS: {
+    [chainId in MerklChainId]?: string;
+};

package/dist/src/constants.js

@@ -1,3 +1,4 @@
+import { ChainId } from "@sdk";
 import Big from "big.js";
 export const zeroBN = new Big(0);
 export const baseTestAnalyticsGraphUrl = "https://api.thegraph.com/subgraphs/name/angleprotocol/test-analytics-";
@@ -42,7 +43,6 @@ export const DOPEX_OPTION_MARKET = {
     ["0xd9e2a1a61b6e61b275cec326465d417e52c1b95c".toLowerCase()]: "0x501B03BdB431154b8Df17BF1c00756E3a8F21744", // wETH / USDC
     ["0x9fFCA51D23Ac7F7df82da414865Ef1055E5aFCc3".toLowerCase()]: "0x4eed3A2b797Bf5630517EcCe2e31C1438A76bb92", // ARB / USDC
 };
-import { ChainId } from "@sdk";
 const COMMON_PREFIX_STAKE = "https://lockers.stakedao.org/api/strategies/cache/curve";
 const COMMON_PREFIX_CONVEX = "https://www.convexfinance.com/api/curve-apys";
 export const constantChain = {
@@ -118,3 +118,11 @@ export const constantChain = {
     },
 };
 export const MAVERICK_ZKSYNC_BP_LENS_ADDRESS = "0xd32CE31CaC98CAC0631764B8286358c0606D87F9";
+export const NETWORK_SLUGS = {
+    [ChainId.MAINNET]: "mainnet",
+    [ChainId.ARBITRUM]: "arbitrum",
+    [ChainId.OPTIMISM]: "optimism",
+    [ChainId.BASE]: "base",
+    [ChainId.POLYGON]: "polygon",
+    [ChainId.SONIC]: "sonic",
+};

package/dist/src/entities/opportunity.js

@@ -1122,6 +1122,64 @@ export const extractOpportunities = {
         };
         return opportunity;
     },
+    [Campaign.UNISWAP_V4]: ({ chainId, mainParameter, tvl, campaignParameters: params, poolBalanceToken0, poolBalanceToken1, computeChainId }, campaigns, prices) => {
+        const { active, all } = campaigns;
+        const pair = `${params.symbolCurrency0}-${params.symbolCurrency1}`;
+        // const tvlDetails = active.reduce(
+        //   (res, campaign) => {
+        //     for (const forwarder of campaign?.forwarders ?? []) {
+        //       const key = `${almName(forwarder.type)} ${forwarder.almAddress}`;
+        //       if (!res[key])
+        //         res[key] = {
+        //           value: forwarder.almTVL,
+        //           address: forwarder.almAddress,
+        //           type: EAprBreakdownType.FORWARDER,
+        //           label: forwarder.label.split(" ")[0],
+        //         };
+        //     }
+        //     return res;
+        //   },
+        //   {} as { [key: string]: tvlBreakdown }
+        // );
+        // // @Hugo wip: new way to structure aprBreakdowns
+        // const aprBreakdownByType = sumAprBreakdownsByType(campaigns.active);
+        // const campaignApr = getCampaignsApr<Campaign.CLAMM>(active);
+        // const aprBreakdown2 = [...aprBreakdownByType, ...campaignApr];
+        const aprBreakdown = active.reduce((res, campaign) => {
+            if (!campaign.aprs)
+                return res;
+            return res;
+        }, {});
+        const holdings = [
+            { symbol: params.symbolCurrency0, amount: poolBalanceToken0 ?? 0 },
+            { symbol: params.symbolCurrency1, amount: poolBalanceToken1 ?? 0 },
+        ];
+        const platform = "UniswapV4";
+        const opportunity = {
+            id: `${Campaign.UNISWAP_V4}_${mainParameter}`,
+            platform,
+            name: [platform, pair, params.lpFee && `${params.lpFee} %`].join(" "),
+            chainId: computeChainId ?? chainId,
+            distributionChainId: chainId,
+            action: "pool",
+            status: getStatus(all),
+            tvlBreakdown: {
+                tokens: holdings,
+                details: {},
+            },
+            aprBreakdown,
+            aprBreakdown2: {},
+            tvl: !!tvl ? tvl : holdings.reduce((prev, curr) => (prices[curr?.symbol] ?? 0) * curr?.amount + prev, 0),
+            apr: getApr(active),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: [params.symbolCurrency0, params.symbolCurrency1],
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            campaigns: { ...campaigns, type: Campaign.UNISWAP_V4, ids: campaigns.all.map(c => c.campaignId) },
+        };
+        return opportunity;
+    },
 };
 /**
  * @returns the opportunities map with their corresponding campaign's data added

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -83,7 +83,9 @@ export declare enum tokenType {
     takotako_lending = "takotako_lending",
     equalizer_gauge = "equalizer_gauge",
     vicuna_lending = "vicuna_lending",
-    vicuna_borrowing = "vicuna_borrowing"
+    vicuna_borrowing = "vicuna_borrowing",
+    spectra_lpt = "spectra_lpt",
+    spectra_yt = "spectra_yt"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.js

@@ -85,6 +85,8 @@ export var tokenType;
     tokenType["equalizer_gauge"] = "equalizer_gauge";
     tokenType["vicuna_lending"] = "vicuna_lending";
     tokenType["vicuna_borrowing"] = "vicuna_borrowing";
+    tokenType["spectra_lpt"] = "spectra_lpt";
+    tokenType["spectra_yt"] = "spectra_yt";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave", action: OpportunityAction.BORROW },
@@ -170,4 +172,6 @@ export const tokenTypeToProtocol = {
     [tokenType.equalizer_gauge]: { protocol: "Equalizer", action: OpportunityAction.HOLD },
     [tokenType.vicuna_lending]: { protocol: "Vicuna", action: OpportunityAction.LEND },
     [tokenType.vicuna_borrowing]: { protocol: "Vicuna", action: OpportunityAction.BORROW },
+    [tokenType.spectra_lpt]: { protocol: "Spectra", action: OpportunityAction.POOL },
+    [tokenType.spectra_yt]: { protocol: "Spectra", action: OpportunityAction.POOL },
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/BeefyProcessor.js

@@ -24,7 +24,6 @@ export class BeefyProcessor extends GenericProcessor {
             { key: "totalSupplyUnderlying", call: "totalSupply", target: "underlying" },
         ],
     };
-    // override computeRound1(): void {}
     async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SpectraProcessor.d.ts

@@ -0,0 +1,31 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawSpectra;
+    call: string;
+    target: keyof callKeysSpectra;
+    metaData?: any;
+};
+type callKeysSpectra = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+    minter: string;
+};
+type dataRawSpectra = callKeysSpectra & {
+    curvePool: string;
+};
+type dataTypeSpectra = dataType & {
+    tokenPrice: string;
+};
+export declare class SpectraProcessor extends GenericProcessor<callKeysSpectra, dataRawSpectra, dataTypeSpectra> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawSpectra, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSpectra>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SpectraProcessor.js

@@ -0,0 +1,41 @@
+import { NETWORK_SLUGS } from "../../../../../constants";
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { GenericProcessor } from "./GenericProcessor";
+export class SpectraProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "curvePool", call: "minter", target: "tokenAddress" }],
+        round2: [],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    async processingRound5(_index, type, typeInfo, _calls, campaign, _pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        if (!NETWORK_SLUGS[campaign.computeChainId]) {
+            throw new Error("Network slug not found");
+        }
+        const curvePool = typeInfo.curvePool.toLowerCase();
+        const spectraData = (await (await fetch(`https://app.spectra.finance/api/v1/${NETWORK_SLUGS[campaign.computeChainId]}/pools`, {
+            headers: {
+                "x-client-id": "Merkl Studio",
+                source: "Merkl Studio",
+            },
+        })).json());
+        const poolData = spectraData
+            .find(d => d.pools.map(pool => pool.address.toLowerCase()).includes(curvePool))
+            ?.pools.find(pool => pool.address.toLowerCase() === curvePool);
+        if (!poolData) {
+            throw new Error("Pool not found in Spectra API");
+        }
+        const tvl = poolData.liquidity.usd; // in USD
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SpectraYTProcessor.d.ts

@@ -0,0 +1,31 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawSpectra;
+    call: string;
+    target: keyof callKeysSpectra;
+    metaData?: any;
+};
+type callKeysSpectra = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+    principalToken: string;
+};
+type dataRawSpectra = callKeysSpectra & {
+    principalToken: string;
+};
+type dataTypeSpectra = dataType & {
+    tokenPrice: string;
+};
+export declare class SpectraYTProcessor extends GenericProcessor<callKeysSpectra, dataRawSpectra, dataTypeSpectra> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawSpectra, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSpectra>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SpectraYTProcessor.js

@@ -0,0 +1,39 @@
+import { NETWORK_SLUGS } from "../../../../../constants";
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { GenericProcessor } from "./GenericProcessor";
+export class SpectraYTProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "principalToken", call: "principalToken", target: "tokenAddress" }],
+        round2: [],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    async processingRound5(_index, type, typeInfo, _calls, campaign, _pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        if (!NETWORK_SLUGS[campaign.computeChainId]) {
+            throw new Error("Network slug not found");
+        }
+        const principalToken = typeInfo.principalToken.toLowerCase();
+        const spectraData = (await (await fetch(`https://app.spectra.finance/api/v1/${NETWORK_SLUGS[campaign.computeChainId]}/pools`, {
+            headers: {
+                "x-client-id": "Merkl Studio",
+                source: "Merkl Studio",
+            },
+        })).json());
+        const poolData = spectraData.find(d => d.address.toLowerCase() === principalToken);
+        if (!poolData) {
+            throw new Error("Pool not found in Spectra API");
+        }
+        const tvl = poolData.pools[0].ytPrice.usd * totalSupply; // in USD
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/processorMapping.js

@@ -26,6 +26,8 @@ import { PendleYTProcessor } from "./PendleYTProcessor";
 import { RadiantProcessor } from "./RadiantProcessor";
 import { RfxProcessor } from "./RfxProcessor";
 import { SatlayerProcessor } from "./Satlayer";
+import { SpectraProcessor } from "./SpectraProcessor";
+import { SpectraYTProcessor } from "./SpectraYTProcessor";
 import { SpliceProcessor } from "./SpliceProcessor";
 import { StakingProcessor } from "./StakingProcessor";
 import { SturdySiloProcessor } from "./SturdySiloProcessor";
@@ -122,4 +124,6 @@ export const processorMapping = {
     [tokenType.vicuna_borrowing]: AaveProcessor,
     [tokenType.vicuna_lending]: AaveProcessor,
     [tokenType.anglesLiquid]: AnglesLiquidProcessor,
+    [tokenType.spectra_lpt]: SpectraProcessor,
+    [tokenType.spectra_yt]: SpectraYTProcessor,
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1.js

@@ -142,6 +142,10 @@ function satisfiesNameConditions(name, type) {
             return lowerCaseName.includes("concrete");
         case tokenType.equalizer_gauge:
             return lowerCaseName.includes("equalizer");
+        case tokenType.spectra_lpt:
+            return lowerCaseName.includes("spectra") && lowerCaseName.includes("curve");
+        case tokenType.spectra_yt:
+            return lowerCaseName.includes("yield") && lowerCaseName.includes("token");
         default:
             return false;
     }
@@ -301,7 +305,7 @@ export function getTokenTypeRound1(calls, targetToken, index, campaign) {
     try {
         name = decodeCall(returnValueOfCalls, index + 2, "name");
     }
-    catch (e) {
+    catch {
         return generateResult(tokenType.unknown, "Unknown", targetToken, {});
     }
     result = parseForBalancer(returnValue, targetToken, name);

package/dist/src/libs/campaigns/campaignTypes/UniswapV4DynamicData.d.ts

@@ -0,0 +1,3 @@
+import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function UniswapV4DynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.UNISWAP_V4>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.UNISWAP_V4>[]>>>;

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

@@ -0,0 +1,228 @@
+import { BN2Number, EAprBreakdownType, NETWORK_LABELS, UniswapV4Addresses, UniswapV4StateViewInterface, getSqrtRatioAtTick, shortenAddress, } from "@sdk";
+import moment from "moment";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+const CALLS_LENGTH = 2;
+export async function UniswapV4DynamicData(chainId, campaigns) {
+    const dynamicData = [];
+    const pricer = await Pricer.load();
+    const calls = [];
+    /** Dedupe pools from campaigns to build pool list */
+    const poolList = [];
+    for (const campaign of campaigns ?? []) {
+        /** Loop through all campaigns to add pools */
+        if (!poolList?.map(p => p.mainParameter.toLowerCase()).includes(campaign.mainParameter.toLowerCase())) {
+            poolList.push({
+                poolId: campaign.campaignParameters.poolId,
+                mainParameter: campaign.mainParameter, // FIXME
+            });
+        }
+    }
+    if (!!poolList) {
+        for (const pool of poolList) {
+            calls.push({
+                allowFailure: true,
+                callData: UniswapV4StateViewInterface.encodeFunctionData("getLiquidity", [pool.poolId]),
+                target: UniswapV4Addresses[chainId].StateView,
+            }, {
+                allowFailure: true,
+                callData: UniswapV4StateViewInterface.encodeFunctionData("getSlot0", [pool.poolId]),
+                target: UniswapV4Addresses[chainId].StateView,
+            }
+            // {
+            //   allowFailure: true,
+            //   callData: ERC20Interface.encodeFunctionData("balanceOf", [pool.address]),
+            //   target: d.campaignParameters.token0,
+            // },
+            // {
+            //   allowFailure: true,
+            //   callData: ERC20Interface.encodeFunctionData("balanceOf", [pool.address]),
+            //   target: d.campaignParameters.token1,
+            // }
+            );
+        }
+        return {
+            cached: false,
+            call: {
+                callData: calls,
+                handler: () => { },
+                reducer: async (result) => {
+                    let i = 0;
+                    if (!!poolList) {
+                        for (const pool of poolList) {
+                            // 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 tick;
+                            const poolBalanceToken0 = 0;
+                            const poolBalanceToken1 = 0;
+                            const campaignsForPool = campaigns?.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase());
+                            //   const decimalsToken0 = d.campaignParameters.decimalsCurrency0;
+                            //   const decimalsToken1 = d.campaignParameters.decimalsCurrency1;
+                            const symbolToken0 = campaignsForPool[0].campaignParameters.symbolCurrency0;
+                            const symbolToken1 = campaignsForPool[0].campaignParameters.symbolCurrency1;
+                            const prevI = i;
+                            try {
+                                poolTotalLiquidity = UniswapV4StateViewInterface.decodeFunctionResult("getLiquidity", result[i++])[0].toString();
+                                const poolData = UniswapV4StateViewInterface.decodeFunctionResult("getSlot0", result[i++]);
+                                tick = poolData.tick;
+                                sqrtPrice = getSqrtRatioAtTick(tick).toString();
+                                // poolBalanceToken0 = BN2Number(
+                                //   ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0],
+                                //   decimalsToken0
+                                // );
+                                // poolBalanceToken1 = BN2Number(
+                                //   ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0],
+                                //   decimalsToken1
+                                // );
+                            }
+                            catch {
+                                log.warn(`merklDynamic data - failed to decode state of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                                i = prevI + CALLS_LENGTH;
+                                continue;
+                            }
+                            const priceToken0 = (await pricer.get({
+                                address: campaignsForPool[0].campaignParameters.currency0,
+                                chainId: chainId,
+                                symbol: symbolToken0,
+                            }));
+                            const priceToken1 = (await pricer.get({
+                                address: campaignsForPool[0].campaignParameters.currency1,
+                                chainId: chainId,
+                                symbol: symbolToken1,
+                            }));
+                            /** Iterate over distributions to compute APRs */
+                            for (const campaign of campaignsForPool) {
+                                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;
+                                const blacklistedBalance0 = 0;
+                                const blacklistedBalance1 = 0;
+                                const blacklistedLiquidity = 0;
+                                const aprs = {};
+                                const aprBreakdowns = [];
+                                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) {
+                                        // TODO
+                                    }
+                                    else if (c.campaignParameters.blacklist.length > 0) {
+                                        // TODO
+                                    }
+                                    /** 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 = "";
+                                    /**
+                                     * General APR (@notice potentially with a boost)
+                                     */
+                                    const poolBalanceToken0WithoutBlacklist = 0;
+                                    const poolBalanceToken1WithoutBlacklist = 0;
+                                    //   const poolLiquidityWithoutBlacklist = poolTotalLiquidity - (blacklistedLiquidity ?? 0);
+                                    const tvl = 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.poolId,
+                                            value: distributionMeanAPR,
+                                            type: EAprBreakdownType.AVERAGE,
+                                            label: "Average APR (rewards / pool TVL)",
+                                        });
+                                        // APR per token
+                                        poolAPRkey = `APR for holding ${c.campaignParameters.symbolCurrency0} in pool`;
+                                        if (!aprs[poolAPRkey])
+                                            aprs[poolAPRkey] = 0;
+                                        aprs[poolAPRkey] += yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0);
+                                        // @Hugo wip: new way to structure aprBreakdowns
+                                        aprBreakdowns.push({
+                                            address: pool.poolId,
+                                            value: yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0),
+                                            type: EAprBreakdownType.TOKEN1,
+                                            label: c.campaignParameters.symbolCurrency0,
+                                        });
+                                        poolAPRkey = `APR for holding  ${c.campaignParameters.symbolCurrency1} in pool`;
+                                        if (!aprs[poolAPRkey])
+                                            aprs[poolAPRkey] = 0;
+                                        aprs[poolAPRkey] += yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1);
+                                        // @Hugo wip: new way to structure aprBreakdowns
+                                        aprBreakdowns.push({
+                                            address: pool.poolId,
+                                            value: yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1),
+                                            type: EAprBreakdownType.TOKEN2,
+                                            label: c.campaignParameters.symbolCurrency1,
+                                        });
+                                    }
+                                    else {
+                                        for (const _ of c.campaignParameters.whitelist) {
+                                            const poolAPRkey = `Whitelisted campaign on UniswapV4 via address ${shortenAddress(c.campaignParameters.whitelist[0])} Average APR`;
+                                            if (!aprs[poolAPRkey])
+                                                aprs[poolAPRkey] = 0;
+                                        }
+                                        aprs[poolAPRkey] += distributionMeanAPR;
+                                    }
+                                }
+                                dynamicData.push({
+                                    ...campaign,
+                                    apr: distributionMeanAPR,
+                                    aprs,
+                                    aprBreakdowns,
+                                    blacklistedBalance0,
+                                    blacklistedBalance1,
+                                    blacklistedLiquidity,
+                                    poolBalanceToken0,
+                                    poolBalanceToken1,
+                                    poolTotalLiquidity,
+                                    sqrtPrice,
+                                    tick: tick,
+                                    priceRewardToken: priceRewardToken,
+                                    tvl: poolBalanceToken0 * priceToken0 + poolBalanceToken1 * priceToken1,
+                                });
+                            }
+                        }
+                    }
+                    return dynamicData;
+                },
+            },
+        };
+    }
+    // Fallback in case something fails
+    return {
+        cached: false,
+        call: {
+            callData: [],
+            handler: () => { },
+            reducer: async (_result) => {
+                return campaigns;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignsDynamicData.js

@@ -14,6 +14,7 @@ import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData
 import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
 import { RadiantDynamicData } from "./campaignTypes/RadiantDynamicData";
 import { SILODynamicData } from "./campaignTypes/SILODynamicData";
+import { UniswapV4DynamicData } from "./campaignTypes/UniswapV4DynamicData";
 import { VestDynamicData } from "./campaignTypes/VestDynamicData";
 export async function campaignsDynamicData(chainId, campaigns, type) {
     try {
@@ -82,6 +83,9 @@ export async function campaignsDynamicData(chainId, campaigns, type) {
         case Campaign.AMBIENTPROCESSOR: {
             return AmbientDynamicData(chainId, campaigns);
         }
+        case Campaign.UNISWAP_V4: {
+            return UniswapV4DynamicData(chainId, campaigns);
+        }
     }
     return {
         cached: false,

package/dist/src/modules/v4/campaign/campaign.model.d.ts

@@ -46,6 +46,7 @@ export declare const campaignTypeToEnumMap: {
     readonly M0: any;
     readonly MORPHOSUPPLY: any;
     readonly SYNCSWAP_VAULT: any;
+    readonly UNISWAP_V4_LP: any;
 };
 export type ConvertedCampaignType<C extends CampaignType> = (typeof campaignTypeToEnumMap)[C];
 export declare const CampaignUniqueDto: import("@sinclair/typebox").TObject<{

package/dist/src/modules/v4/campaign/campaign.model.js

@@ -33,6 +33,7 @@ export const campaignTypeToEnumMap = {
     M0: CampaignTypeEnum.M0,
     MORPHOSUPPLY: CampaignTypeEnum.MORPHOSUPPLY,
     SYNCSWAP_VAULT: CampaignTypeEnum.SYNCSWAP_VAULT,
+    UNISWAP_V4_LP: CampaignTypeEnum.UNISWAP_V4,
 };
 // ─── DTOs ────────────────────────────────────────────────────────────────────
 export const CampaignUniqueDto = t.Object({

package/dist/src/modules/v4/reward/reward.service.js

@@ -41,15 +41,13 @@ export class RewardService {
     static format(rewards) {
         return rewards.map(reward => {
             const { Breakdown, RewardToken, id, rewardTokenId, ...rest } = reward;
-            const pending = Breakdown.reduce((sum, { pending }) => sum + BigInt(pending), 0n);
-            const claimed = Breakdown.reduce((sum, { claimed }) => sum + BigInt(claimed), 0n);
             return {
                 ...rest,
                 token: RewardToken,
                 breakdowns: Breakdown.map(RewardService.formatBreakdown),
-                claimed,
+                claimed: BigInt(rest.claimed),
                 amount: BigInt(rest.amount),
-                pending,
+                pending: BigInt(rest.pending),
             };
         });
     }