@merkl/api 0.19.7 → 0.19.9

package/dist/src/backgroundJobs/index.js

@@ -1,8 +1,8 @@
 // @ts-nocheck
 import { Redis } from "@/cache";
 import { redisClient } from "@/cache/redis";
-import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/libs/campaigns/utils/getEulerV2Vaults";
-import { getUniswapV4Pools } from "@/libs/campaigns/utils/getUniswapV4Pools";
+import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dynamicData/utils/getEulerV2Vaults";
+import { getUniswapV4Pools } from "@/engine/dynamicData/utils/getUniswapV4Pools";
 import { log } from "@/utils/logger";
 import { engineDbClient } from "@db";
 import { swagger } from "@elysiajs/swagger";

package/dist/src/backgroundJobs/jobs/campaignsCacheUpdater.js

@@ -1,4 +1,5 @@
 import { Redis } from "@/cache";
+import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
 import { campaignsToOldFormat } from "@/libs/deprecated-merklv3";
 import { AprService } from "@/modules/v4/apr";
 import { CacheService } from "@/modules/v4/cache";
@@ -12,11 +13,9 @@ import { engineDbClient } from "@db";
 import { Campaign, ChainId, NETWORK_LABELS, isSupportedChain, } from "@sdk";
 import { Elysia, t } from "elysia";
 import moment from "moment";
-import { campaignsDynamicData } from "../../libs/campaigns/campaignsDynamicData";
 import { merklChainData } from "../../libs/merklChainData";
 import { staticCampaignWithCache } from "../../libs/staticCampaigns";
 import { InvalidParameter, UnsupportedNetwork } from "../../utils/error";
-import { executeSimple } from "../../utils/execute";
 import { log } from "../../utils/logger";
 import { ALL_CAMPAIGNS_FOR_CHAIN_AFTER } from "../../utils/queries/allCampaigns";
 const highCampaignsChains = [ChainId.ARBITRUM, ChainId.POLYGON, ChainId.BLAST, ChainId.BASE];
@@ -83,7 +82,9 @@ export const campaignCacheUpdate = async (rawChainId, queryCampaignTypes, highCa
             // Fetch dynamic data for all these types
             const promisesPerType = campaignTypes.map(async (campaignType) => {
                 const campaigns = staticData.filter(campaign => campaign.campaignType === campaignType);
-                await executeSimple(chainId, campaignsDynamicData(chainId, campaigns, campaignType)).then(r => {
+                await dynamicDataBuilderFactory(campaignType)
+                    .build(chainId, campaigns)
+                    .then(r => {
                     for (const d of r) {
                         if (!!d) {
                             // Main Parameter OVERRIDING

package/dist/src/eden/index.d.ts

@@ -7340,8 +7340,8 @@ declare const eden: {
                 query: {
                     types?: string | number | string[] | number[] | undefined;
                     chainIds?: string | string[] | undefined;
-                    live?: boolean | undefined;
                     creatorTag?: string | undefined;
+                    live?: boolean | undefined;
                     hideTestTokens?: string | undefined;
                 };
                 fetch?: RequestInit | undefined;
@@ -7419,16 +7419,8 @@ declare const eden: {
                 query: {};
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: {
-                    [x: string]: {
-                        address: string;
-                        symbolCToken: string;
-                        decimalsCToken: number;
-                        underlying: string;
-                        symbolUnderlying: string;
-                        decimalsUnderlying: number;
-                    }[];
-                };
+                [x: string]: any;
+                200: any;
             }>>;
         };
         createCampaign: {
@@ -7854,11 +7846,8 @@ declare const eden: {
                 query: {};
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: {
-                    [x: string]: {
-                        [poolId: string]: UniswapV4PoolType;
-                    } | undefined;
-                };
+                [x: string]: any;
+                200: any;
             }>>;
         };
     };
@@ -12423,8 +12412,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query: {
                     types?: string | number | string[] | number[] | undefined;
                     chainIds?: string | string[] | undefined;
-                    live?: boolean | undefined;
                     creatorTag?: string | undefined;
+                    live?: boolean | undefined;
                     hideTestTokens?: string | undefined;
                 };
                 headers: unknown;
@@ -12527,16 +12516,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query: {};
                 headers: unknown;
                 response: {
-                    200: {
-                        [x: string]: {
-                            address: string;
-                            symbolCToken: string;
-                            decimalsCToken: number;
-                            underlying: string;
-                            symbolUnderlying: string;
-                            decimalsUnderlying: number;
-                        }[];
-                    };
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };
@@ -13090,11 +13071,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query: {};
                 headers: unknown;
                 response: {
-                    200: {
-                        [x: string]: {
-                            [poolId: string]: UniswapV4PoolType;
-                        } | undefined;
-                    };
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };
@@ -20447,8 +20425,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query: {
                     types?: string | number | string[] | number[] | undefined;
                     chainIds?: string | string[] | undefined;
-                    live?: boolean | undefined;
                     creatorTag?: string | undefined;
+                    live?: boolean | undefined;
                     hideTestTokens?: string | undefined;
                 };
                 fetch?: RequestInit | undefined;
@@ -20526,16 +20504,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query: {};
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: {
-                    [x: string]: {
-                        address: string;
-                        symbolCToken: string;
-                        decimalsCToken: number;
-                        underlying: string;
-                        symbolUnderlying: string;
-                        decimalsUnderlying: number;
-                    }[];
-                };
+                [x: string]: any;
+                200: any;
             }>>;
         };
         createCampaign: {
@@ -20961,11 +20931,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query: {};
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                200: {
-                    [x: string]: {
-                        [poolId: string]: UniswapV4PoolType;
-                    } | undefined;
-                };
+                [x: string]: any;
+                200: any;
             }>>;
         };
     };

package/dist/src/engine/dynamicData/factory.d.ts

@@ -0,0 +1,3 @@
+import { Campaign } from "@sdk";
+import type { DynamicDataBuilder } from "./interface";
+export declare const dynamicDataBuilderFactory: (campaignType: Campaign) => DynamicDataBuilder<typeof campaignType>;

package/dist/src/engine/dynamicData/factory.js

@@ -0,0 +1,54 @@
+import { Campaign } from "@sdk";
+import { AjnaDynamicData } from "./implementations/Ajna";
+import { AmbiantDynamicData } from "./implementations/Ambiant";
+import { BadgerDynamicData } from "./implementations/Badger";
+import { ClammDynamicData } from "./implementations/Clamm";
+import { CompoundDynamicData } from "./implementations/Compound";
+import { DolomiteDynamicData } from "./implementations/Dolomite";
+import { EigenLayerDynamicData } from "./implementations/EigenLayer";
+import { EncompassingDynamicData } from "./implementations/Encompassing";
+import { Erc20DynamicData } from "./implementations/Erc20";
+import { Erc20SnapshotDynamicData } from "./implementations/Erc20Snapshot";
+import { EventBasedDynamicData } from "./implementations/EventBased";
+import { HyperdriveDynamicData } from "./implementations/Hyperdrive";
+import { MorphoDynamicData } from "./implementations/Morpho";
+import { RadiantDynamicData } from "./implementations/Radiant";
+import { SiloDynamicData } from "./implementations/Silo";
+import { UniswapV4DynamicData } from "./implementations/UniswapV4";
+import { VestDynamicData } from "./implementations/Vest";
+import { DefaultDynamicData } from "./implementations/default";
+// @dev Casts are made to enforce type safety
+// @dev A type error must be thrown if a new campaign type is added and the corresponding builder is not implemented
+const map = {
+    [Campaign.INVALID]: new DefaultDynamicData(),
+    [Campaign.JSON_AIRDROP]: new DefaultDynamicData(),
+    [Campaign.AJNA]: new AjnaDynamicData(),
+    [Campaign.AMBIENTPROCESSOR]: new AmbiantDynamicData(),
+    [Campaign.BADGER]: new BadgerDynamicData(),
+    [Campaign.CLAMM]: new ClammDynamicData(),
+    [Campaign.COMPOUND]: new CompoundDynamicData(),
+    [Campaign.DOLOMITE]: new DolomiteDynamicData(),
+    [Campaign.EIGENLAYER]: new EigenLayerDynamicData(),
+    [Campaign.ENCOMPASSING]: new EncompassingDynamicData(),
+    [Campaign.ERC20_SNAPSHOT]: new Erc20SnapshotDynamicData(),
+    [Campaign.EVENT_BASED]: new EventBasedDynamicData(),
+    [Campaign.HYPERDRIVELOGFIXPROCESSOR]: new HyperdriveDynamicData(),
+    [Campaign.HYPERDRIVELOGPROCESSOR]: new HyperdriveDynamicData(),
+    [Campaign.ERC20]: new Erc20DynamicData(),
+    [Campaign.ERC20LOGPROCESSOR]: new Erc20DynamicData(),
+    [Campaign.ERC20REBASEFIXAPR]: new Erc20DynamicData(),
+    [Campaign.ERC20REBASELOGPROCESSOR]: new Erc20DynamicData(),
+    [Campaign.ERC20_FIX_APR]: new Erc20DynamicData(),
+    [Campaign.EULER]: new Erc20DynamicData(),
+    [Campaign.MORPHO]: new MorphoDynamicData(),
+    [Campaign.RADIANT]: new RadiantDynamicData(),
+    [Campaign.SILO]: new SiloDynamicData(),
+    [Campaign.UNISWAP_V4]: new UniswapV4DynamicData(),
+    [Campaign.VEST]: new VestDynamicData(),
+    [Campaign.ION]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC20TRANSFERS]: new DefaultDynamicData(), // TODO
+    [Campaign.M0]: new DefaultDynamicData(), // TODO
+    [Campaign.MORPHOSUPPLY]: new DefaultDynamicData(), // TODO
+    [Campaign.SYNCSWAP_VAULT]: new DefaultDynamicData(), // TODO
+};
+export const dynamicDataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/dynamicData/implementations/Ajna.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.AJNA;
+export declare class AjnaDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<CampaignDynamicData<Campaign.AJNA>[]>;
+}
+export {};

package/dist/src/engine/dynamicData/implementations/Ajna.js

@@ -0,0 +1,101 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { providers } from "@/utils/providers";
+import { AjnaSubCampaignType, BN2Number, ChainInteractionService, ERC20Pool__factory, NETWORK_LABELS, PoolInfoUtilsInterface, YEAR, } from "@sdk";
+import { POOL_INFO_UTILS } from "@sdk";
+import axios from "axios";
+import { log } from "../../../utils/logger";
+export class AjnaDynamicData {
+    async build(chainId, campaigns) {
+        const calls = [];
+        for (const campaign of campaigns) {
+            if (campaign.campaignParameters.subCampaignType === AjnaSubCampaignType.lend) {
+                calls.push({
+                    allowFailure: true,
+                    callData: PoolInfoUtilsInterface.encodeFunctionData("poolPricesInfo", [campaign.campaignParameters.poolId]),
+                    target: POOL_INFO_UTILS[campaign.computeChainId],
+                });
+            }
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        const dynamicData = [];
+        let index = 0;
+        for (const campaign of campaigns) {
+            const res = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[chainId].toLowerCase()}/pools/${campaign.campaignParameters.poolId.toLowerCase()}`);
+            try {
+                let totalSupplyTargetToken = 0;
+                let totalComputedTargetToken = 0;
+                let blacklistedSupply = 0;
+                let blacklistedPosition;
+                if (campaign.campaignParameters.subCampaignType === AjnaSubCampaignType.lend) {
+                    totalSupplyTargetToken = res?.data.results?.quote_token_balance;
+                    const htpIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", result[index].returnData)[3];
+                    const lupIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", result[index].returnData)[5];
+                    const threshold = BN2Number(lupIndex, 0) === 0 ? lupIndex : lupIndex.gt(htpIndex) ? lupIndex.add(22) : htpIndex.add(22);
+                    const InterestEarningSupplyRes = await ERC20Pool__factory.connect(campaign.campaignParameters.poolId, providers[campaign.computeChainId]).depositUpToIndex(threshold);
+                    totalComputedTargetToken = BN2Number(InterestEarningSupplyRes, 18);
+                    index++;
+                }
+                else {
+                    totalSupplyTargetToken = res?.data.results?.debt;
+                }
+                totalComputedTargetToken =
+                    campaign.campaignSubType === AjnaSubCampaignType.lend ? totalComputedTargetToken : totalSupplyTargetToken;
+                if (campaign.campaignParameters.blacklist.length !== 0 && totalComputedTargetToken !== 0) {
+                    for (const blacklisted of campaign.campaignParameters.blacklist) {
+                        const res = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[chainId].toLowerCase()}/wallets/${blacklisted}/pools/?days_ago=1&order=-debt&p_size=50`);
+                        let nextRoute = null;
+                        if (!!res.data.next) {
+                            nextRoute = `https://${res.data.next.slice(res.data.next.indexOf(":") + 1)}`;
+                        }
+                        blacklistedPosition = res.data.results.find((position) => position.pool_address === campaign.campaignParameters.poolId);
+                        blacklistedSupply = !blacklistedPosition
+                            ? 0
+                            : campaign.campaignSubType === AjnaSubCampaignType.lend
+                                ? Number(blacklistedPosition.supply)
+                                : Number(blacklistedPosition.debt);
+                        while (nextRoute !== null && blacklistedSupply !== 0) {
+                            const res = await axios.get(nextRoute);
+                            blacklistedPosition = res.data.results.find((position) => position.pool_address === campaign.campaignParameters.poolId);
+                            blacklistedSupply = !blacklistedPosition
+                                ? 0
+                                : campaign.campaignSubType === AjnaSubCampaignType.lend
+                                    ? Number(blacklistedPosition.supply)
+                                    : Number(blacklistedPosition.debt);
+                            if (!!res.data.next) {
+                                nextRoute = `https://${res.data.next.slice(res.data.next.indexOf(":") + 1)}`;
+                            }
+                            else {
+                                nextRoute = null;
+                            }
+                        }
+                    }
+                }
+                totalComputedTargetToken -= blacklistedSupply;
+                const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                // (await pricer.get({
+                //   address: campaign.rewardToken,
+                //   chainId,
+                //   symbol: campaign.campaignParameters.symbolRewardToken,
+                // })) ?? 0;
+                dynamicData.push({
+                    ...campaign,
+                    apr: (priceRewardToken *
+                        BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                        YEAR *
+                        100) /
+                        campaign.campaignParameters.duration /
+                        (totalComputedTargetToken * res?.data.results?.quote_token_underlying_price),
+                    totalSupplyTargetToken,
+                    tvl: res?.data.results?.tvl,
+                    computedtotalSupply: totalComputedTargetToken,
+                });
+            }
+            catch (e) {
+                log.error("Failed to fetch Ajna data", e);
+                // In this case we return just the staticData
+                dynamicData.push({ ...campaign });
+            }
+        }
+        return dynamicData;
+    }
+}

package/dist/src/engine/dynamicData/implementations/Ambiant.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.AMBIENTPROCESSOR;
+export declare class AmbiantDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<AmbientCampaignDynamicData[]>;
+}
+export {};

package/dist/src/engine/dynamicData/implementations/Ambiant.js

@@ -0,0 +1,227 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { AmbientAddresses, AmbientLens, BN2Number, ChainInteractionService, EAprBreakdownType, NETWORK_LABELS, YEAR, } from "@sdk";
+import moment from "moment";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+import { fetchAmbientPotentialPositions } from "../utils/fetchAmbientInfo";
+var AmbiantPositionType;
+(function (AmbiantPositionType) {
+    AmbiantPositionType["Concentrated"] = "concentrated";
+    AmbiantPositionType["Ambient"] = "ambient";
+    AmbiantPositionType["Knockout"] = "knockout";
+})(AmbiantPositionType || (AmbiantPositionType = {}));
+function encodeCall(chainId, holder) {
+    if (holder.positionType === AmbiantPositionType.Concentrated) {
+        return [
+            {
+                allowFailure: true,
+                callData: AmbientLens.encodeFunctionData("queryRangeTokens", [
+                    holder.owner,
+                    holder.base,
+                    holder.quote,
+                    holder.poolIdx,
+                    holder.lowerTick,
+                    holder.upperTick,
+                ]),
+                target: AmbientAddresses[chainId].CrocQuery,
+            },
+        ];
+    }
+    return [
+        {
+            allowFailure: true,
+            callData: AmbientLens.encodeFunctionData("queryAmbientTokens", [
+                holder.owner,
+                holder.base,
+                holder.quote,
+                holder.poolIdx,
+            ]),
+            target: AmbientAddresses[chainId].CrocQuery,
+        },
+    ];
+}
+async function decodeCall(result, holder) {
+    let amount0 = BigInt(0n);
+    let amount1 = BigInt(0n);
+    if (holder.positionType === AmbiantPositionType.Concentrated) {
+        const resTok = AmbientLens.decodeFunctionResult("queryRangeTokens", result);
+        amount0 = BigInt(resTok[1]);
+        amount1 = BigInt(resTok[2]);
+    }
+    if (holder.positionType === AmbiantPositionType.Ambient) {
+        const resTok = AmbientLens.decodeFunctionResult("queryAmbientTokens", result);
+        amount0 = BigInt(resTok[1]);
+        amount1 = BigInt(resTok[2]);
+    }
+    return { amount0, amount1 };
+}
+export class AmbiantDynamicData {
+    async build(chainId, campaigns) {
+        const dynamicData = [];
+        const pricer = await Pricer.load();
+        let 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({
+                    id: campaign.campaignParameters.poolId,
+                    mainParameter: campaign.mainParameter, // main parameter containes info of poolAddress + AMM (in case its a priority AMM)
+                    baseToken: campaign.campaignParameters.baseToken,
+                    quoteToken: campaign.campaignParameters.quoteToken,
+                    poolIdx: campaign.campaignParameters.poolIdx,
+                    potentialHolders: await fetchAmbientPotentialPositions(campaign.campaignParameters.poolId, campaign.computeChainId),
+                });
+            }
+        }
+        if (!!poolList) {
+            for (const pool of poolList) {
+                calls.push({
+                    allowFailure: true,
+                    callData: AmbientLens.encodeFunctionData("queryLiquidity", [pool.baseToken, pool.quoteToken, pool.poolIdx]),
+                    target: AmbientAddresses[chainId].CrocQuery,
+                }, {
+                    allowFailure: true,
+                    callData: AmbientLens.encodeFunctionData("queryCurveTick", [pool.baseToken, pool.quoteToken, pool.poolIdx]),
+                    target: AmbientAddresses[chainId].CrocQuery,
+                });
+                calls = calls.concat(...pool.potentialHolders.map(holder => encodeCall(chainId, holder)));
+            }
+            const result = await ChainInteractionService(chainId).fetchState(calls);
+            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 activeTick;
+                    let poolBalanceToken0 = 0;
+                    let poolBalanceToken1 = 0;
+                    const d = campaigns?.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase())[0];
+                    const decimalsBaseToken = d.campaignParameters.decimalsBaseToken;
+                    const decimalsQuoteToken = d.campaignParameters.decimalsQuoteToken;
+                    const symbolBaseToken = d.campaignParameters.symbolBaseToken;
+                    const symbolQuoteToken = d.campaignParameters.symbolQuoteToken;
+                    const prevI = i;
+                    try {
+                        poolTotalLiquidity = BN2Number(AmbientLens.decodeFunctionResult("queryLiquidity", result[i++].returnData)[0]);
+                        activeTick = Number(AmbientLens.decodeFunctionResult("queryCurveTick", result[i++].returnData)[0]);
+                        for (let index = 0; index < pool.potentialHolders.length; index++) {
+                            // to verify
+                            if (calls.length === 0) {
+                                break;
+                            }
+                            const res = await decodeCall(result[i++].returnData, pool.potentialHolders[index]);
+                            poolBalanceToken0 += BN2Number(res.amount0, decimalsBaseToken);
+                            poolBalanceToken1 += BN2Number(res.amount1, decimalsQuoteToken);
+                        }
+                    }
+                    catch (e) {
+                        log.warn(`merklDynamic data - failed to decode state of pool ${pool.id} on ${NETWORK_LABELS[chainId]}`);
+                        i = prevI + 2 + pool.potentialHolders.length;
+                        continue;
+                    }
+                    const priceToken0 = (await pricer.get({
+                        address: d.campaignParameters.baseToken,
+                        chainId: chainId,
+                        symbol: symbolBaseToken,
+                    }));
+                    const priceToken1 = (await pricer.get({
+                        address: d.campaignParameters.quoteToken,
+                        chainId: chainId,
+                        symbol: symbolQuoteToken,
+                    }));
+                    /** 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;
+                        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,
+                            // })) as number;
+                            priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                            /** Yearly rewards in $ */
+                            const yearlyToken0Rewards = (propToken0 * priceRewardToken * amount * YEAR) / (endTimestamp - startTimestamp);
+                            const yearlyToken1Rewards = (propToken1 * priceRewardToken * amount * YEAR) / (endTimestamp - startTimestamp);
+                            const yearlyFeeRewards = (propFees * priceRewardToken * amount * YEAR) / (endTimestamp - startTimestamp);
+                            let poolAPRkey = "";
+                            const tvl = poolBalanceToken0 * priceToken0 + poolBalanceToken1 * 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.id,
+                                    value: distributionMeanAPR,
+                                    type: EAprBreakdownType.AVERAGE,
+                                    label: "Average APR (rewards / pool TVL)",
+                                });
+                                // APR per token
+                                poolAPRkey = `APR for holding ${c.campaignParameters.symbolBaseToken} in pool`;
+                                if (!aprs[poolAPRkey])
+                                    aprs[poolAPRkey] = 0;
+                                aprs[poolAPRkey] += yearlyToken0Rewards / (poolBalanceToken0 * priceToken0);
+                                // @Hugo wip: new way to structure aprBreakdowns
+                                aprBreakdowns.push({
+                                    address: pool.id,
+                                    value: yearlyToken0Rewards / (poolBalanceToken0 * priceToken0),
+                                    type: EAprBreakdownType.TOKEN1,
+                                    label: c.campaignParameters.symbolBaseToken,
+                                });
+                                poolAPRkey = `APR for holding  ${c.campaignParameters.symbolQuoteToken} in pool`;
+                                if (!aprs[poolAPRkey])
+                                    aprs[poolAPRkey] = 0;
+                                aprs[poolAPRkey] += yearlyToken1Rewards / (poolBalanceToken1 * priceToken1);
+                                // @Hugo wip: new way to structure aprBreakdowns
+                                aprBreakdowns.push({
+                                    address: pool.id,
+                                    value: yearlyToken1Rewards / (poolBalanceToken1 * priceToken1),
+                                    type: EAprBreakdownType.TOKEN2,
+                                    label: c.campaignParameters.symbolQuoteToken,
+                                });
+                            }
+                            else {
+                            }
+                        }
+                        dynamicData.push({
+                            ...campaign,
+                            apr: distributionMeanAPR,
+                            aprs,
+                            forwarders: [],
+                            poolBalanceToken0,
+                            poolBalanceToken1,
+                            poolTotalLiquidity,
+                            tick: activeTick,
+                            priceRewardToken: priceRewardToken,
+                            tvl: poolBalanceToken0 * priceToken0 + poolBalanceToken1 * priceToken1,
+                        });
+                    }
+                }
+            }
+        }
+        return dynamicData;
+    }
+}

package/dist/src/engine/dynamicData/implementations/Badger.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.BADGER;
+export declare class BadgerDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<CampaignDynamicData<Campaign.BADGER>[]>;
+}
+export {};