@merkl/api 0.10.129 → 0.10.130

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)}`,
+    }));
+}

package/dist/src/errors/BadRequest.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class BadRequestError extends HttpError {
+    constructor(message = "Bad Request", legalValues) {
+        super(message, 400, { legalValues });
+        this.name = "BadRequestError";
+    }
+}

package/dist/src/errors/Conflict.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class ConflictError extends HttpError {
+    constructor(message = "Conflict") {
+        super(message, 409);
+        this.name = "ConflictError";
+    }
+}

package/dist/src/errors/HttpError.js

@@ -0,0 +1,11 @@
+export class HttpError extends Error {
+    code;
+    httpCode;
+    info;
+    constructor(message = "Internal Server Error", httpCode = 500, info) {
+        super(message);
+        this.code = "HttpError";
+        this.httpCode = httpCode;
+        this.info = info;
+    }
+}

package/dist/src/errors/NotFound.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class NotFoundError extends HttpError {
+    constructor(message = "Not Found") {
+        super(message, 404);
+        this.name = "NotFoundError";
+    }
+}

package/dist/src/errors/Opportunity.error.js

@@ -0,0 +1,11 @@
+export class OpportunityError extends Error {
+    code;
+    httpCode;
+    info;
+    constructor(message, name, info) {
+        super(message);
+        this.code = "OpportunityError";
+        this.name = name;
+        this.info = info;
+    }
+}

package/dist/src/errors/Unauthorized.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class UnauthorizedError extends HttpError {
+    constructor(message = "Unauthorized") {
+        super(message, 401);
+        this.name = "UnauthorizedError";
+    }
+}

package/dist/src/errors/index.js

@@ -0,0 +1,5 @@
+export * from "./HttpError";
+export * from "./Unauthorized.error";
+export * from "./NotFound.error";
+export * from "./BadRequest.error";
+export * from "./Conflict.error";

package/dist/src/guards/BackOffice.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "../errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function BackOfficeGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.BACKOFFICE_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/guards/Engine.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "../errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function EngineGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.ENGINE_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/guards/TokenAuth.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "../errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function TokenAuthGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.API_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/hooks/checkQueryAddressValidity.js

@@ -0,0 +1,7 @@
+import { throwOnInvalidAddress } from "../utils/throw";
+export default function checkQueryAddressValidity(queryKey = "user") {
+    return (app) => app.onBeforeHandle(({ query }) => {
+        const address = query?.[queryKey];
+        query[queryKey] = throwOnInvalidAddress(address ?? "");
+    });
+}

package/dist/src/hooks/checkQueryChainIdValidity.js

@@ -0,0 +1,7 @@
+import { throwOnUnsupportedChainId } from "../utils/throw";
+export default function checkQueryChainIdValidity(queryKey = "chainId") {
+    return (app) => app.onBeforeHandle(({ query }) => {
+        const chainId = query?.[queryKey];
+        chainId !== undefined && throwOnUnsupportedChainId(chainId);
+    });
+}