@merkl/api 0.10.129 → 0.10.131

package/dist/src/entities/campaign.js

@@ -0,0 +1,134 @@
+import { Redis } from "../cache";
+import { Campaign, Int256 } from "@sdk";
+import moment from "moment";
+export const activeCampaign = (v) => v.startTimestamp < moment().unix() && v.endTimestamp > moment().unix();
+export const inactiveCampaign = (v) => v.startTimestamp > moment().unix() || v.endTimestamp < moment().unix();
+export const removeTestTokens = (v) => !["aglamerkl", "test"].includes(v.campaignParameters.symbolRewardToken?.toLowerCase());
+export async function getCampaignsFor(chainIds, filters = { onlyLive: false }) {
+    const cachePrefix = filters?.onlyLive ? "LiveCampaigns" : "Campaigns";
+    const cacheKeys = chainIds.map(chain => `${cachePrefix}_${chain}`);
+    return (await Redis.getMany(cacheKeys)).reduce((prev, allData, index) => {
+        if (!!allData) {
+            const chain = chainIds[index];
+            prev[chain] = Object.keys(allData).reduce((acc, curr) => {
+                const [type, mainParameter] = curr.split("_");
+                const campaignType = Number.parseInt(type);
+                if (!filters?.types?.length || filters?.types?.includes(campaignType))
+                    acc[`${campaignType}_${mainParameter}`] = allData[curr];
+                return acc;
+            }, {});
+        }
+        return prev;
+    }, {});
+}
+/**
+ * @returns all opportunityIds in the campaign data
+ */
+export function extractIds(campaigns) {
+    const chains = Object.keys(campaigns).map(n => Number.parseInt(n));
+    return chains.flatMap(chainId => Object.keys(campaigns[chainId] ?? {})?.map(opportunityId => `${chainId}_${opportunityId}`));
+}
+/**
+ * @returns the daily price of all rewards from the campaign array
+ */
+export function getDailyRewards(campaigns, prices) {
+    const rewardPrices = campaigns
+        .map(({ campaignParameters: c, amount, endTimestamp, startTimestamp, campaignType }) => {
+        const isSporadic = [Campaign.ERC20_SNAPSHOT, Campaign.JSON_AIRDROP].includes(campaignType);
+        const timespan = Math.abs(endTimestamp - startTimestamp);
+        let dayspan = isSporadic ? 1 : Math.floor(timespan / (60 * 60 * 24));
+        if (dayspan === 0)
+            dayspan = 1; // If distribution periode < 1 day -> avoid division by 0
+        return [c.symbolRewardToken, Int256.from(amount, c.decimalsRewardToken).div(dayspan)];
+    })
+        .map(([symbol, amount]) => {
+        return Math.max(prices?.[symbol] ?? 0, 0) * (amount?.toNumber() ?? 0);
+    });
+    return rewardPrices?.length > 0 ? rewardPrices.reduce((a, b) => a + b) : 0;
+}
+/**
+ * @returns the status of an opportunity based on its campaigns
+ */
+export function getStatus(campaigns) {
+    const active = campaigns?.filter(activeCampaign);
+    const inactive = campaigns?.filter(inactiveCampaign);
+    if (active?.length)
+        return "live";
+    if (inactive?.some(v => v.startTimestamp > moment().unix()))
+        return "soon";
+    return "past";
+}
+/**
+ * @returns the sum of the APRs from a campaigns array
+ */
+export function getApr(campaigns) {
+    return campaigns.reduce((res, campaign) => res + (campaign.apr ?? 0), 0);
+}
+/**
+ * @returns the sum of the all tags
+ */
+export function getTags(campaigns) {
+    const tags = Array.from(campaigns.reduce((res, campaign) => {
+        campaign.tags?.forEach(tag => {
+            res.add(tag);
+        });
+        return res;
+    }, new Set()));
+    return tags.length === 0 ? undefined : tags;
+}
+/**
+ * @returns all the reward token symbols from a compaign array
+ */
+export function getRewardTokenIcons(campaigns) {
+    const rewardTokens = new Set();
+    campaigns.forEach(({ rewardToken }) => rewardTokens.add(rewardToken));
+    return Array.from(rewardTokens);
+}
+/**
+ * @returns the daily reward token symbols from a compaign array
+ */
+export function getRewardTokens(campaigns) {
+    const rewardTokens = {};
+    campaigns.forEach(({ amount, rewardToken, campaignParameters: { symbolRewardToken: symbol }, ...c }) => {
+        const timespan = Math.abs(c.endTimestamp - c.startTimestamp);
+        const dayspan = Math.max(Math.floor(timespan / (60 * 60 * 24)), 1);
+        const dailyAmount = BigInt(amount) / BigInt(dayspan);
+        if (!rewardTokens[symbol])
+            rewardTokens[symbol] = { amount: dailyAmount, address: rewardToken };
+        else
+            rewardTokens[symbol].amount += dailyAmount;
+    });
+    return Object.entries(rewardTokens).map(([symbol, { amount, address }]) => ({
+        symbol,
+        address,
+        amount: amount.toString(),
+    }));
+}
+/**
+ * @returns campaigns that match the opportunityIds
+ */
+export function splitCampaigns(campaigns, ids, showTest) {
+    if (!campaigns || !ids?.length)
+        return [];
+    const campaignAt = (id) => {
+        const [chainId, type, mainParameter] = id.split("_");
+        return (campaigns?.[chainId]?.[`${type}_${mainParameter}`] ??
+            Object.entries(campaigns[chainId] ?? {}).find(([t_m]) => t_m?.toLowerCase() === id?.toLowerCase())?.[1]);
+    };
+    return ids
+        .filter(id => campaignAt(id) !== undefined)
+        .map(id => {
+        let all = Object.values(campaignAt(id) ?? {});
+        if (!showTest)
+            all = all.filter(removeTestTokens);
+        const active = all?.filter(activeCampaign);
+        const inactive = all?.filter(inactiveCampaign);
+        return {
+            id,
+            all,
+            active,
+            inactive,
+        };
+    })
+        .filter(opportunity => opportunity?.all?.length);
+}

package/dist/src/entities/opportunity.js

@@ -0,0 +1,549 @@
+import { AjnaSubCampaignType, BN2Number, Campaign, ChainId, CompFork, CompoundSubCampaignType, DolomiteSubCampaignType, EAprBreakdownType, EulerSubCampaignType, MorphoSubCampaignType, almName, ammName, } from "@sdk";
+import { activeCampaign, getApr, getCampaignsFor, getDailyRewards, getRewardTokenIcons, getRewardTokens, getStatus, getTags, inactiveCampaign, removeTestTokens, } from "./campaign";
+export const extractOpportunities = {
+    [Campaign.CLAMM]: ({ chainId, amm, mainParameter, tvl, campaignParameters: params, poolBalanceToken0, poolBalanceToken1, computeChainId, }, campaigns, prices) => {
+        const { active, all } = campaigns;
+        const pair = `${params.symbolToken0}-${params.symbolToken1}`;
+        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;
+        }, {});
+        // @Hugo wip: new way to structure aprBreakdowns
+        const aprBreakdownByType = sumAprBreakdownsByType(campaigns.active);
+        const campaignApr = getCampaignsApr(active);
+        const aprBreakdown2 = [...aprBreakdownByType, ...campaignApr];
+        const aprBreakdown = active.reduce((res, campaign) => {
+            if (!campaign.aprs)
+                return res;
+            for (const key of Object.keys(campaign?.aprs)) {
+                const forwarder = campaign.forwarders?.find(f => f.label.toLocaleLowerCase() === key.toLocaleLowerCase());
+                if (!res[key])
+                    res[key] = { value: 0, address: null, type: EAprBreakdownType.DETAILS, label: "" };
+                res[key].value += campaign.aprs[key];
+                res[key].address = forwarder?.almAddress ?? res[key].address; // should put token address
+                res[key].type =
+                    (forwarder ? EAprBreakdownType.FORWARDER : EAprBreakdownType.DETAILS) ?? EAprBreakdownType.DETAILS;
+            }
+            return res;
+        }, {});
+        const holdings = [
+            { symbol: params.symbolToken0, amount: poolBalanceToken0 ?? 0 },
+            { symbol: params.symbolToken1, amount: poolBalanceToken1 ?? 0 },
+        ];
+        let platform = ammName(amm ?? params.amm);
+        if (platform === "BaseSwap" && chainId === ChainId.MODE)
+            platform = "SwapMode";
+        if (platform === "BaseSwap" && chainId === ChainId.ARBITRUM)
+            platform = "Arbidex";
+        if (platform === "BaseSwap" && chainId === ChainId.OPTIMISM)
+            platform = "SuperSwap";
+        if (platform === "Izumi") {
+            if (chainId === ChainId.ROOTSTOCK)
+                platform = "WoodSwap";
+            else
+                platform = "iZUMi";
+        }
+        const opportunity = {
+            id: `${Campaign.CLAMM}_${mainParameter}`,
+            platform: platform,
+            name: [platform, pair, params.poolFee && `${params.poolFee} %`].join(" "),
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            action: "pool",
+            status: getStatus(all),
+            tvlBreakdown: {
+                tokens: holdings,
+                details: tvlDetails,
+            },
+            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.symbolToken0, params.symbolToken1],
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            campaigns: { ...campaigns, type: Campaign.CLAMM, ids: campaigns.all.map(c => c.campaignId) },
+        };
+        return opportunity;
+    },
+    [Campaign.SILO]: ({ chainId, tvl, mainParameter, campaignSubType, campaignParameters: params, computeChainId }, campaigns, prices) => {
+        const { active, all } = campaigns;
+        let suffix = ["Deposit", "Protected Deposit", "Debt"][campaignSubType];
+        if (all?.[0]?.campaignParameters?.forwarders.length === 1 &&
+            all?.[0]?.campaignParameters?.forwarders[0].siloAssetSymbol) {
+            suffix += ` (${all?.[0].campaignParameters.forwarders[0].siloAssetSymbol} Market)`;
+        }
+        const aprBreakdown = active.reduce((res, campaign) => {
+            res[`Campaign ${campaign.campaignId.slice(0, 8)}`] = {
+                value: campaign.apr ?? 0,
+                address: campaign.campaignId,
+                type: EAprBreakdownType.CAMPAIGN,
+            };
+            return res;
+        }, {});
+        // @Hugo WIP todo for aprBreakdown2
+        const aprBreakdown2 = getCampaignsApr(active);
+        const opportunity = {
+            id: `${Campaign.SILO}_${mainParameter}`,
+            platform: "Silo",
+            name: ["Silo", params.symbolTargetToken, suffix].join(" "),
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            tvl,
+            action: campaignSubType <= 1 ? "lend" : "borrow",
+            subtype: campaignSubType,
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: [params.symbolTargetToken],
+            campaigns: { ...campaigns, type: Campaign.SILO, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            apr: getApr(active),
+            aprBreakdown,
+            aprBreakdown2,
+        };
+        return opportunity;
+    },
+    [Campaign.RADIANT]: (campaign, campaigns, prices) => {
+        const { chainId, tvl, campaignSubType, campaignParameters: params, computeChainId } = campaign;
+        const { active, all } = campaigns;
+        let icons = [params.symbolTargetToken];
+        if (params.symbolTargetToken?.startsWith("r"))
+            icons = [params.symbolTargetToken.slice("r".length)];
+        if (params.symbolTargetToken?.startsWith("variableDebt"))
+            icons = [params.symbolTargetToken.slice("variableDebt".length)];
+        const aprBreakdown = active.reduce((res, campaign) => {
+            res[`Campaign ${campaign.campaignId.slice(0, 8)}`] = {
+                value: campaign.apr ?? 0,
+                address: campaign.campaignId,
+                type: EAprBreakdownType.DETAILS,
+            };
+            return res;
+        }, {});
+        // @Hugo WIP todo for aprBreakdown2
+        const aprBreakdown2 = getCampaignsApr(active);
+        const opportunity = {
+            id: `${Campaign.RADIANT}_${campaign.mainParameter}`,
+            platform: "Radiant",
+            name: ["Radiant", params.symbolTargetToken].join(" "),
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            tvl,
+            action: campaignSubType <= 1 ? "lend" : "borrow",
+            subtype: campaignSubType,
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: icons,
+            campaigns: { ...campaigns, type: Campaign.RADIANT, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            apr: getApr(active),
+            aprBreakdown,
+            aprBreakdown2,
+        };
+        return opportunity;
+    },
+    [Campaign.DOLOMITE]: (campaign, campaigns, prices) => {
+        const { chainId, tvl, campaignSubType, campaignParameters: params, computeChainId } = campaign;
+        const { active, all } = campaigns;
+        const aprBreakdown = active.reduce((res, campaign) => {
+            res[`Campaign ${campaign.campaignId.slice(0, 8)}`] = {
+                value: campaign.apr ?? 0,
+                address: campaign.campaignId,
+                type: EAprBreakdownType.DETAILS,
+            };
+            return res;
+        }, {});
+        // @Hugo WIP todo for aprBreakdown2
+        const aprBreakdown2 = getCampaignsApr(active);
+        const opportunity = {
+            id: `${Campaign.DOLOMITE}_${campaign.mainParameter}`,
+            platform: "Dolomite",
+            name: ["Dolomite", params.symbolTargetToken, " - ", DolomiteSubCampaignType[campaign.campaignSubType]].join(" "),
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            tvl,
+            action: campaignSubType <= 1 ? "lend" : "borrow",
+            subtype: campaignSubType,
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: [params.symbolTargetToken],
+            campaigns: { ...campaigns, type: Campaign.DOLOMITE, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            apr: getApr(active),
+            aprBreakdown,
+            aprBreakdown2,
+        };
+        return opportunity;
+    },
+    [Campaign.ERC20]: (campaign, campaigns, prices) => {
+        const { chainId, tvl, campaignParameters: params, typeInfo, computeChainId, mainParameter } = campaign;
+        const { active, all } = campaigns;
+        const map = {
+            actions: {
+                pool: [
+                    "uniswapv2",
+                    "velodrome",
+                    "aerodrome",
+                    "balancerGauge",
+                    "balancerPool",
+                    "curve",
+                    "aura",
+                    "akron",
+                    "beefy",
+                    "dragonswap",
+                    "poolside",
+                    "koi",
+                ],
+                borrow: ["radiant_borrow", "aave_borrowing", "euler_borrow"],
+                lend: [
+                    "gearbox",
+                    "compound",
+                    "radiant_lend",
+                    "aave_lending",
+                    "sturdy_aggregator",
+                    "sturdy_silo",
+                    "fraxlend",
+                    "moonwell",
+                    "ionic",
+                    "fluid",
+                    "silostaking",
+                    "euler_lend",
+                    "layerbank",
+                ],
+            },
+            icons: {
+                pool: () => {
+                    if (["balancerGauge", "balancerPool"].includes(campaign.type ?? ""))
+                        return Object.values(typeInfo.poolTokens ?? {})
+                            .map(tkn => tkn?.symbol)
+                            .filter(tkn => tkn);
+                    if (["curve"].includes(campaign.type ?? ""))
+                        return Object.values(typeInfo.poolTokens ?? {}).filter(tkn => tkn);
+                    return [typeInfo.symbolToken0, typeInfo.symbolToken1];
+                },
+                lend: () => (campaign.type === "compound" ? [typeInfo.symbolBaseToken] : [typeInfo.symbolUnderlyingToken]),
+                borrow: () => [typeInfo.symbolUnderlyingToken],
+                hold: () => {
+                    if (["toros", "enzyme"].includes(campaign.type))
+                        return [typeInfo.symbolUnderlyingToken];
+                    return [campaign.campaignParameters.symbolTargetToken];
+                },
+            },
+        };
+        const action = Object.entries(map.actions).find(([_action, _types]) => _types.includes(campaign.type ?? ""))?.[0] ?? "hold";
+        const icons = map.icons[action]();
+        const opportunity = {
+            id: `${Campaign.ERC20}_${mainParameter}`,
+            platform: params.symbolTargetToken,
+            name: typeInfo?.cardName,
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            tvl,
+            action,
+            apr: getApr(active),
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: icons,
+            campaigns: { ...campaigns, type: Campaign.ERC20, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+        };
+        return opportunity;
+    },
+    [Campaign.ERC20_SNAPSHOT]: ({ chainId, tvl, mainParameter, campaignParameters: params }, campaigns) => {
+        const opportunity = {
+            id: `${Campaign.ERC20_SNAPSHOT}_${mainParameter}`,
+            name: ["Airdrop for", params.symbolTargetToken, "holders"].join(" "),
+            chainId,
+            tvl,
+            action: "drop",
+            tags: getTags(campaigns.all),
+            status: getStatus(campaigns.all),
+            tokenIcons: [params.symbolTargetToken],
+            campaigns: { ...campaigns, type: Campaign.ERC20_SNAPSHOT, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+        };
+        return opportunity;
+    },
+    [Campaign.JSON_AIRDROP]: ({ chainId, creator, mainParameter, campaignParameters: params }, campaigns) => {
+        const ACI = "0xdeadD8aB03075b7FBA81864202a2f59EE25B312b".toLowerCase();
+        const aaveDAO = "0x5300A1a15135EA4dc7aD5a167152C01EFc9b192A".toLowerCase();
+        const aciPrefix = creator.toLowerCase() === ACI && "Aave Merit Rewards -";
+        const aavePrefix = creator.toLowerCase() === aaveDAO && "Aave - aAMPL distribution -";
+        const prefix = aavePrefix ? aavePrefix : aciPrefix ? aciPrefix : "Airdrop in";
+        const opportunity = {
+            id: `${Campaign.JSON_AIRDROP}_${mainParameter}`,
+            name: [prefix, params.symbolRewardToken].join(" "),
+            chainId,
+            action: "drop",
+            status: getStatus(campaigns.all),
+            tags: getTags(campaigns.all),
+            tokenIcons: [params.symbolRewardToken],
+            campaigns: { ...campaigns, type: Campaign.JSON_AIRDROP, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+        };
+        return opportunity;
+    },
+    [Campaign.MORPHO]: ({ chainId, tvl, mainParameter, campaignSubType, campaignParameters: params, computeChainId }, campaigns, prices) => {
+        const { active, all } = campaigns;
+        const suffix = ["Meta", "Supply", "Borrow", "Collateral"][campaignSubType];
+        const opportunity = {
+            id: `${Campaign.MORPHO}_${mainParameter}`,
+            platform: "Morpho",
+            name: campaignSubType === MorphoSubCampaignType.META
+                ? ["MetaMorpho", params.nameTargetToken].join(" ")
+                : campaignSubType === MorphoSubCampaignType.BORROWING_BLUE ||
+                    campaignSubType === MorphoSubCampaignType.SUPPLY_BLUE
+                    ? [
+                        "Morpho - ",
+                        suffix,
+                        `${params.symbolLoanToken} on ${params.symbolLoanToken}/${params.symbolBorrowToken}`,
+                        `${BN2Number(params.LLTV, 16)}%`,
+                    ].join(" ")
+                    : [
+                        "Morpho - ",
+                        suffix,
+                        `${params.symbolBorrowToken} on ${params.symbolLoanToken}/${params.symbolBorrowToken}`,
+                        `${BN2Number(params.LLTV, 16)}%`,
+                    ].join(" "),
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            tvl,
+            action: campaignSubType !== 2 ? "lend" : "borrow",
+            subtype: campaignSubType,
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: [params.symbolTargetToken],
+            campaigns: { ...campaigns, type: Campaign.MORPHO, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            apr: getApr(active),
+        };
+        return opportunity;
+    },
+    [Campaign.BADGER]: (campaign, campaigns, prices) => {
+        const { chainId, tvl, campaignSubType, campaignParameters: params, computeChainId } = campaign;
+        const { active, all } = campaigns;
+        const aprBreakdown = active.reduce((res, campaign) => {
+            res[`Campaign ${campaign.campaignId.slice(0, 8)}`] = {
+                value: campaign.apr ?? 0,
+                address: campaign.campaignId,
+                type: EAprBreakdownType.DETAILS,
+            };
+            return res;
+        }, {});
+        // @Hugo WIP todo for aprBreakdown2
+        const aprBreakdown2 = getCampaignsApr(active);
+        const opportunity = {
+            id: `${Campaign.BADGER}_${campaign.mainParameter}`,
+            platform: "Badger",
+            name: ["Badger", "Borrow", params.symbolTargetToken].join(" "),
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            tvl,
+            action: "borrow",
+            subtype: 0,
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: [params.symbolTargetToken],
+            campaigns: { ...campaigns, type: Campaign.BADGER, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            apr: getApr(active),
+            aprBreakdown,
+            aprBreakdown2,
+        };
+        return opportunity;
+    },
+    [Campaign.AJNA]: (campaign, campaigns, prices) => {
+        const { chainId, tvl, campaignSubType, campaignParameters: params, computeChainId } = campaign;
+        const { active, all } = campaigns;
+        const aprBreakdown = active.reduce((res, campaign) => {
+            res[`Campaign ${campaign.campaignId.slice(0, 8)}`] = {
+                value: campaign.apr ?? 0,
+                address: campaign.campaignId,
+                type: EAprBreakdownType.DETAILS,
+            };
+            return res;
+        }, {});
+        // @Hugo WIP todo for aprBreakdown2
+        const aprBreakdown2 = getCampaignsApr(active);
+        const opportunity = {
+            id: `${Campaign.AJNA}_${campaign.mainParameter}`,
+            platform: "Ajna",
+            name: [
+                "AJNA",
+                params.subCampaignType === AjnaSubCampaignType.lend
+                    ? `Supply ${params.symbolQuoteToken} on `
+                    : `Borrow ${params.symbolQuoteToken} on`,
+                params.symbolCollateralToken,
+                " / ",
+                params.symbolQuoteToken,
+            ].join(" "),
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            tvl,
+            action: campaignSubType === AjnaSubCampaignType.lend ? "lend" : "borrow",
+            subtype: campaignSubType,
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: [params.symbolQuoteToken, params.symbolCollateralToken],
+            campaigns: { ...campaigns, type: Campaign.AJNA, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            apr: getApr(active),
+            aprBreakdown,
+            aprBreakdown2,
+        };
+        return opportunity;
+    },
+    [Campaign.EULER]: (campaign, campaigns, prices) => {
+        const { chainId, tvl, campaignSubType, campaignParameters: params, computeChainId } = campaign;
+        const { active, all } = campaigns;
+        const aprBreakdown = active.reduce((res, campaign) => {
+            res[`Campaign ${campaign.campaignId.slice(0, 8)}`] = {
+                value: campaign.apr ?? 0,
+                address: campaign.campaignId,
+                type: EAprBreakdownType.DETAILS,
+            };
+            return res;
+        }, {});
+        // @Hugo WIP todo for aprBreakdown2
+        const aprBreakdown2 = getCampaignsApr(active);
+        const opportunity = {
+            id: `${Campaign.EULER}_${campaign.mainParameter}`,
+            platform: "Euler",
+            name: campaign.typeInfo.cardName,
+            chainId: computeChainId ?? chainId,
+            distributionChainId: chainId,
+            tvl,
+            action: campaignSubType === EulerSubCampaignType.LEND ? "lend" : "borrow",
+            subtype: campaignSubType,
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: [params.symbolAsset],
+            campaigns: { ...campaigns, type: Campaign.EULER, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            apr: getApr(active),
+            aprBreakdown,
+            aprBreakdown2,
+        };
+        return opportunity;
+    },
+    [Campaign.COMPOUND]: (campaign, campaigns, prices) => {
+        const { chainId, tvl, campaignSubType, campaignParameters: params, computeChainId } = campaign;
+        const { active, all } = campaigns;
+        const aprBreakdown = active.reduce((res, campaign) => {
+            res[`Campaign ${campaign.campaignId.slice(0, 8)}`] = {
+                value: campaign.apr ?? 0,
+                address: campaign.campaignId,
+                type: EAprBreakdownType.DETAILS,
+            };
+            return res;
+        }, {});
+        // @Hugo WIP todo for aprBreakdown2
+        const aprBreakdown2 = getCampaignsApr(active);
+        const opportunity = {
+            id: `${Campaign.COMPOUND}_${campaign.mainParameter}`,
+            platform: CompFork[campaign.campaignParameters.compFork],
+            name: [
+                CompFork[campaign.campaignParameters.compFork],
+                params.subCampaignType === CompoundSubCampaignType.supply
+                    ? `Supply ${params.symbolTargetToken}`
+                    : `Borrow ${params.symbolTargetToken}`,
+            ].join(" "),
+            chainId: !computeChainId ? chainId : computeChainId,
+            distributionChainId: chainId,
+            tvl,
+            action: campaignSubType === CompoundSubCampaignType.supply ? "lend" : "borrow",
+            subtype: campaignSubType,
+            status: getStatus(all),
+            tags: getTags(campaigns.all),
+            dailyrewards: getDailyRewards(active, prices),
+            tokenIcons: [params.symbolUnderlyingToken],
+            campaigns: { ...campaigns, type: Campaign.COMPOUND, ids: campaigns.all.map(c => c.campaignId) },
+            rewardTokenIcons: getRewardTokenIcons(campaigns.active),
+            dailyRewardTokens: getRewardTokens(campaigns.active),
+            apr: getApr(active),
+            aprBreakdown,
+            aprBreakdown2,
+        };
+        return opportunity;
+    },
+};
+/**
+ * @returns the opportunities map with their corresponding campaign's data added
+ */
+export async function fillCampaigns(opportunities, onlyCampaignIds, showTest) {
+    const [includedChainIds, includedTypes] = Object.values(opportunities).reduce(([chains, types], { chainId, campaigns: oppCampaigns }) => [
+        chains.add(chainId),
+        types.add(Number.parseInt(oppCampaigns?.type ?? "0")),
+    ], [new Set(), new Set()]);
+    const campaigns = await getCampaignsFor(Array.from(includedChainIds), {
+        onlyLive: false,
+        types: Array.from(includedTypes),
+    });
+    for (const [id, opportunity] of Object.entries(opportunities)) {
+        const matchingCampaigns = Object.entries(campaigns?.[opportunity.chainId] ?? {}).find(([_id]) => _id?.toLowerCase() === id?.toLowerCase());
+        const opportunityCampaigns = Object.values(matchingCampaigns?.[1] ?? {}).filter(campaign => {
+            if (!showTest)
+                return removeTestTokens(campaign);
+            return true;
+        });
+        opportunities[id].campaigns.ids = opportunityCampaigns?.map(({ campaignId }) => campaignId).filter(c => c);
+        opportunities[id].campaigns.active = opportunityCampaigns?.filter(activeCampaign) ?? [];
+        opportunities[id].campaigns.inactive = opportunityCampaigns?.filter(inactiveCampaign) ?? [];
+    }
+    return opportunities;
+}
+function sumAprBreakdownsByType(campaigns) {
+    const map = new Map();
+    let specificAprTypes = [];
+    campaigns.forEach(campaign => {
+        campaign.aprBreakdowns?.forEach(breakdown => {
+            if (breakdown.type === EAprBreakdownType.FORWARDER)
+                return;
+            const existing = map.get(breakdown.type);
+            if (existing)
+                existing.value += breakdown.value;
+            else {
+                map.set(breakdown.type, breakdown);
+            }
+        });
+        specificAprTypes = campaign.aprBreakdowns?.filter(breakdown => breakdown.type === EAprBreakdownType.FORWARDER);
+    });
+    // Convert the map to an array of AprBreakdown
+    return Array.from(map.values()).concat(specificAprTypes);
+}
+function getCampaignsApr(active) {
+    return active.map(campaign => ({
+        value: campaign.apr ?? 0,
+        address: campaign.campaignId,
+        type: EAprBreakdownType.CAMPAIGN,
+        label: `Campaign ${campaign.campaignId.slice(0, 8)}`,
+    }));
+}