@merkl/api 0.19.6 → 0.19.8

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 {};

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

@@ -0,0 +1,84 @@
+import { CDPMANAGER_ADDRESS, EBTC_ADDRESS, SORTEDCDPS_ADDRESS } from "@/constants";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { log } from "@/utils/logger";
+import { Pricer } from "@/utils/pricer";
+import { BN2Number, CdpManagerInterface, ChainInteractionService, SortedCdpsInterface, YEAR, } from "@sdk";
+export class BadgerDynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        calls.push({
+            allowFailure: false,
+            callData: CdpManagerInterface.encodeFunctionData("getSystemDebt"),
+            target: CDPMANAGER_ADDRESS,
+        });
+        const dynamicData = [];
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        for (const campaign of campaigns) {
+            try {
+                // Blacklist management
+                let blacklistSupply = 0;
+                let calls = [];
+                for (const blacklisted of [
+                    "0xFBC472DdbE6DaE23fc0771518d1791D06a52cf4D",
+                    "0x690C74AF48BE029e763E61b4aDeB10E06119D3ba",
+                    "0xD0A7A8B98957b9CD3cFB9c0425AbE44551158e9e",
+                    "0x68682e8857D24A5Bb71fCd5C6Dc5867731226B62",
+                ]) {
+                    calls.push({
+                        allowFailure: false,
+                        callData: SortedCdpsInterface.encodeFunctionData("getCdpsOf", [blacklisted]),
+                        target: SORTEDCDPS_ADDRESS,
+                    });
+                }
+                const resCdps = await ChainInteractionService(chainId).fetchState(calls);
+                calls = [];
+                for (const res of resCdps) {
+                    const cdp = SortedCdpsInterface.decodeFunctionResult("getCdpsOf", res.returnData)[0];
+                    if (cdp.length !== 0) {
+                        calls.push({
+                            allowFailure: false,
+                            callData: CdpManagerInterface.encodeFunctionData("Cdps", cdp),
+                            target: CDPMANAGER_ADDRESS,
+                        });
+                    }
+                }
+                const resBlacklist = await ChainInteractionService(chainId).fetchState(calls);
+                for (const res of resBlacklist) {
+                    const cdpBlacklistedSupply = CdpManagerInterface.decodeFunctionResult("Cdps", res.returnData)[0];
+                    blacklistSupply += BN2Number(cdpBlacklistedSupply, campaign.campaignParameters.decimalsTargetToken);
+                }
+                const totalSupplyTargetToken = BN2Number(CdpManagerInterface.decodeFunctionResult("getSystemDebt", result[0].returnData)[0], campaign.campaignParameters.decimalsTargetToken) - blacklistSupply;
+                // const priceRewardToken =
+                //   (await pricer.get({
+                //     address: campaign.rewardToken,
+                //     chainId,
+                //     symbol: campaign.campaignParameters.symbolRewardToken,
+                //   })) ?? 0;
+                const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                const priceTargetToken = (await pricer.get({
+                    address: EBTC_ADDRESS,
+                    chainId,
+                    symbol: campaign.campaignParameters.symbolTargetToken,
+                })) ?? 0;
+                dynamicData.push({
+                    ...campaign,
+                    apr: (priceRewardToken *
+                        BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                        YEAR *
+                        100) /
+                        campaign.campaignParameters.duration /
+                        (totalSupplyTargetToken * priceTargetToken),
+                    totalSupplyTargetToken,
+                    tvl: totalSupplyTargetToken * priceTargetToken,
+                });
+            }
+            catch (e) {
+                log.error("Failed to fetch Dolomite data", e);
+                // In this case we return just the staticData
+                dynamicData.push({ ...campaign });
+            }
+        }
+        return dynamicData;
+    }
+}

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

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