@merkl/api 0.19.6 → 0.19.8

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

@@ -0,0 +1,249 @@
+import { BucketService } from "@/modules/v4/bucket/bucket.service";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { engineDbClient } from "@db";
+import { BN2Number, ChainInteractionService, EAprBreakdownType, NETWORK_LABELS, UniswapV4Addresses, UniswapV4StateViewInterface, getSqrtRatioAtTick, shortenAddress, } from "@sdk";
+import moment from "moment";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+// Constants
+const CALLS_LENGTH = 2;
+/**
+ * Compute TVL
+ * @dev important: using the most recent state save with current prices
+ *      it's only an estimate
+ */
+async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID, priceCurrency0, priceCurrency1, decimalsCurrency0, decimalsCurrency1) {
+    let stateSave;
+    let blockNumber;
+    let states = {};
+    try {
+        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
+        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
+            where: {
+                id: `UniswapV4_${chainId}_${poolID}`,
+                blockNumber: {
+                    lte: currentBlock,
+                },
+            },
+            orderBy: {
+                blockNumber: "desc",
+            },
+        });
+        stateSave = mostRecentStateSave.state;
+        blockNumber = mostRecentStateSave?.blockNumber;
+        states = stateSave.states;
+        // const globalState = stateSave.globalState as { tick: number; liquidity: string };
+    }
+    catch (e) {
+        log.warn(`merklDynamic data - failed to read a recent state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
+    }
+    const { fileName, bucketName } = states;
+    // Bucket service
+    let tvl = 0;
+    let amount0 = 0;
+    let amount1 = 0;
+    try {
+        const bucket = new BucketService(bucketName, "merkl-production");
+        const storedStates = JSON.parse(await bucket.pull(fileName));
+        for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
+            amount0 += BN2Number(value.amount0, decimalsCurrency0);
+            amount1 += BN2Number(value.amount1, decimalsCurrency1);
+        }
+        tvl = amount0 * (priceCurrency0 ?? 0) + amount1 * (priceCurrency1 ?? 0);
+    }
+    catch (e) {
+        console.log(e);
+        log.warn(`merklDynamic data - failed to decode state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
+    }
+    return { tvl, amount0, amount1, blockNumber: blockNumber };
+}
+export class UniswapV4DynamicData {
+    async build(chainId, campaigns) {
+        const dynamicData = [];
+        const pricer = await Pricer.load();
+        const calls = [];
+        /** Dedupe pools from campaigns to build pool list */
+        const poolList = [];
+        for (const campaign of campaigns ?? []) {
+            /** Loop through all campaigns to add pools */
+            if (!poolList?.map(p => p.mainParameter.toLowerCase()).includes(campaign.mainParameter.toLowerCase())) {
+                poolList.push({
+                    poolId: campaign.campaignParameters.poolId,
+                    mainParameter: campaign.mainParameter, // FIXME
+                });
+            }
+        }
+        if (!!poolList) {
+            for (const pool of poolList) {
+                calls.push({
+                    allowFailure: true,
+                    callData: UniswapV4StateViewInterface.encodeFunctionData("getLiquidity", [pool.poolId]),
+                    target: UniswapV4Addresses[chainId].StateView,
+                }, {
+                    allowFailure: true,
+                    callData: UniswapV4StateViewInterface.encodeFunctionData("getSlot0", [pool.poolId]),
+                    target: UniswapV4Addresses[chainId].StateView,
+                });
+            }
+            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 sqrtPrice;
+                    let tick;
+                    let poolBalanceToken0 = 0;
+                    let poolBalanceToken1 = 0;
+                    const campaignsForPool = campaigns?.filter(campaign => campaign.mainParameter.toLowerCase() === pool.mainParameter.toLowerCase());
+                    const prevI = i;
+                    try {
+                        poolTotalLiquidity = UniswapV4StateViewInterface.decodeFunctionResult("getLiquidity", result[i++].returnData)[0].toString();
+                        const poolData = UniswapV4StateViewInterface.decodeFunctionResult("getSlot0", result[i++].returnData);
+                        tick = poolData.tick;
+                        sqrtPrice = getSqrtRatioAtTick(tick).toString();
+                    }
+                    catch {
+                        log.warn(`merklDynamic data - failed to decode state of pool ${pool.poolId} on ${NETWORK_LABELS[chainId]}`);
+                        i = prevI + CALLS_LENGTH;
+                        continue;
+                    }
+                    const decimalsCurrency0 = campaignsForPool[0].campaignParameters.decimalsCurrency0;
+                    const decimalsCurrency1 = campaignsForPool[0].campaignParameters.decimalsCurrency1;
+                    const symbolCurrency0 = campaignsForPool[0].campaignParameters.symbolCurrency0;
+                    const symbolCurrency1 = campaignsForPool[0].campaignParameters.symbolCurrency1;
+                    const priceToken0 = (await pricer.get({
+                        address: campaignsForPool[0].campaignParameters.currency0,
+                        chainId: chainId,
+                        symbol: symbolCurrency0,
+                    }));
+                    const priceToken1 = (await pricer.get({
+                        address: campaignsForPool[0].campaignParameters.currency1,
+                        chainId: chainId,
+                        symbol: symbolCurrency1,
+                    }));
+                    const { tvl, amount0, amount1, blockNumber } = await computeUniV4PoolTVLFromMostRecentStateSave(chainId, pool.poolId, priceToken0, priceToken1, decimalsCurrency0, decimalsCurrency1);
+                    poolBalanceToken0 += amount0;
+                    poolBalanceToken1 += amount1;
+                    /** Iterate over distributions to compute APRs */
+                    for (const campaign of campaignsForPool) {
+                        const c = campaign;
+                        const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
+                        const startTimestamp = BN2Number(c.startTimestamp, 0);
+                        const endTimestamp = BN2Number(c.endTimestamp, 0);
+                        const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
+                        const totalWeight = BN2Number(c.campaignParameters.weightFees, 4) +
+                            BN2Number(c.campaignParameters.weightToken0, 4) +
+                            BN2Number(c.campaignParameters.weightToken1, 4);
+                        // Proportions in percentage
+                        const propFees = (BN2Number(c.campaignParameters.weightFees, 4) / totalWeight) * 100;
+                        const propToken0 = (BN2Number(c.campaignParameters.weightToken0, 4) / totalWeight) * 100;
+                        const propToken1 = (BN2Number(c.campaignParameters.weightToken1, 4) / totalWeight) * 100;
+                        let distributionMeanAPR = 0;
+                        const blacklistedBalance0 = 0;
+                        const blacklistedBalance1 = 0;
+                        const blacklistedLiquidity = 0;
+                        const aprs = {};
+                        const aprBreakdowns = [];
+                        let priceRewardToken = 0;
+                        if (isLive && c.campaignParameters.symbolRewardToken !== "aglaMerkl") {
+                            // priceRewardToken = (await pricer.get({
+                            //   address: c.rewardToken,
+                            //   chainId: chainId,
+                            //   symbol: c.campaignParameters.symbolRewardToken,
+                            // })) as number;
+                            priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                            /**
+                             * Handle whitelisted/blacklisted addresses to compute APR
+                             */
+                            if (c.campaignParameters.whitelist.length > 0) {
+                                // TODO
+                            }
+                            else if (c.campaignParameters.blacklist.length > 0) {
+                                // TODO
+                            }
+                            /** Yearly rewards in $ */
+                            const yearlyToken0Rewards = (propToken0 * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
+                            const yearlyToken1Rewards = (propToken1 * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
+                            const yearlyFeeRewards = (propFees * priceRewardToken * amount * (365 * 24 * 3_600)) / (endTimestamp - startTimestamp);
+                            let poolAPRkey = "";
+                            /**
+                             * General APR (@notice potentially with a boost)
+                             */
+                            const poolBalanceToken0WithoutBlacklist = poolBalanceToken0;
+                            const poolBalanceToken1WithoutBlacklist = poolBalanceToken1;
+                            //   const poolLiquidityWithoutBlacklist = poolTotalLiquidity - (blacklistedLiquidity ?? 0);
+                            const tvl = poolBalanceToken0WithoutBlacklist * priceToken0 + poolBalanceToken1WithoutBlacklist * priceToken1;
+                            distributionMeanAPR = (yearlyToken0Rewards + yearlyToken1Rewards + yearlyFeeRewards) / tvl;
+                            distributionMeanAPR = !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
+                            /**
+                             * @dev We cannot include a whitelisted distrib apr into the mean APR
+                             */
+                            if (c.campaignParameters.whitelist.length === 0) {
+                                poolAPRkey = "Average APR (rewards / pool TVL)";
+                                if (!aprs[poolAPRkey])
+                                    aprs[poolAPRkey] = 0;
+                                aprs[poolAPRkey] += distributionMeanAPR;
+                                // @Hugo wip: new way to structure aprBreakdowns
+                                aprBreakdowns.push({
+                                    address: pool.poolId,
+                                    value: distributionMeanAPR,
+                                    type: EAprBreakdownType.AVERAGE,
+                                    label: "Average APR (rewards / pool TVL)",
+                                });
+                                // APR per token
+                                poolAPRkey = `APR for holding ${c.campaignParameters.symbolCurrency0} in pool`;
+                                if (!aprs[poolAPRkey])
+                                    aprs[poolAPRkey] = 0;
+                                aprs[poolAPRkey] += yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0);
+                                // @Hugo wip: new way to structure aprBreakdowns
+                                aprBreakdowns.push({
+                                    address: pool.poolId,
+                                    value: yearlyToken0Rewards / (poolBalanceToken0WithoutBlacklist * priceToken0),
+                                    type: EAprBreakdownType.TOKEN1,
+                                    label: c.campaignParameters.symbolCurrency0,
+                                });
+                                poolAPRkey = `APR for holding  ${c.campaignParameters.symbolCurrency1} in pool`;
+                                if (!aprs[poolAPRkey])
+                                    aprs[poolAPRkey] = 0;
+                                aprs[poolAPRkey] += yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1);
+                                // @Hugo wip: new way to structure aprBreakdowns
+                                aprBreakdowns.push({
+                                    address: pool.poolId,
+                                    value: yearlyToken1Rewards / (poolBalanceToken1WithoutBlacklist * priceToken1),
+                                    type: EAprBreakdownType.TOKEN2,
+                                    label: c.campaignParameters.symbolCurrency1,
+                                });
+                            }
+                            else {
+                                for (const _ of c.campaignParameters.whitelist) {
+                                    const poolAPRkey = `Whitelisted campaign on UniswapV4 via address ${shortenAddress(c.campaignParameters.whitelist[0])} Average APR`;
+                                    if (!aprs[poolAPRkey])
+                                        aprs[poolAPRkey] = 0;
+                                }
+                                aprs[poolAPRkey] += distributionMeanAPR;
+                            }
+                        }
+                        dynamicData.push({
+                            ...campaign,
+                            apr: distributionMeanAPR,
+                            aprs,
+                            aprBreakdowns,
+                            blacklistedBalance0,
+                            blacklistedBalance1,
+                            blacklistedLiquidity,
+                            poolBalanceToken0,
+                            poolBalanceToken1,
+                            poolTotalLiquidity,
+                            sqrtPrice,
+                            tick: tick,
+                            priceRewardToken: priceRewardToken,
+                            tvl: poolBalanceToken0 * priceToken0 + poolBalanceToken1 * priceToken1,
+                        });
+                    }
+                }
+            }
+        }
+        return dynamicData;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+export declare const VEST_TREASURY = "0x7ccF5BbeC69c790D27dA3b5398B9e0d6D6EeC9F3";
+export declare const VEST_TOKEN = "0x3355df6D4c9C3035724Fd0e3914dE96A5a83aaf4";
+type campaignType = Campaign.VEST;
+export declare class VestDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<VestCampaignDynamicData[]>;
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { BN2Number, ChainInteractionService, ERC20Interface, YEAR, } from "@sdk";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+export const VEST_TREASURY = "0x7ccF5BbeC69c790D27dA3b5398B9e0d6D6EeC9F3";
+export const VEST_TOKEN = "0x3355df6D4c9C3035724Fd0e3914dE96A5a83aaf4";
+export class VestDynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        for (const _campaign of campaigns) {
+            calls.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("balanceOf", [VEST_TREASURY]),
+                target: VEST_TOKEN,
+            });
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupply;
+            try {
+                totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++].returnData)[0], 6);
+            }
+            catch {
+                log.warn(`Error getting totalSupply for campaign ${campaign.campaignId}`);
+                totalSupply = 0.0000001;
+            }
+            // const priceRewardToken =
+            //   (await pricer.get({
+            //     address: campaign.rewardToken,
+            //     chainId: campaign.chainId,
+            //     symbol: campaign.campaignParameters.symbolRewardToken,
+            //   })) ?? 0;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            const priceTargetToken = (await pricer.get({
+                address: VEST_TOKEN,
+                chainId: campaign.computeChainId,
+                symbol: "USDC.e",
+            })) ?? 0;
+            const tvl = totalSupply * priceTargetToken;
+            dynamicData.push({
+                ...campaign,
+                apr: (priceRewardToken *
+                    BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                    YEAR *
+                    100) /
+                    campaign.campaignParameters.duration /
+                    (totalSupply * priceTargetToken),
+                totalSupplyTargetToken: totalSupply,
+                tvl,
+                priceRewardToken: priceRewardToken,
+            });
+        }
+        return dynamicData;
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { Campaign as CampaignEnum, CampaignParameters, MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+export declare class DefaultDynamicData implements DynamicDataBuilder<CampaignEnum> {
+    build(_chainId: MerklChainId, campaigns: CampaignParameters<CampaignEnum>[]): Promise<CampaignParameters<CampaignEnum>[]>;
+}

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

@@ -0,0 +1,5 @@
+export class DefaultDynamicData {
+    async build(_chainId, campaigns) {
+        return campaigns;
+    }
+}

package/dist/src/{libs/campaigns → engine/dynamicData}/utils/getEulerV2Vaults.js

@@ -1,4 +1,5 @@
 import { Redis } from "@/cache";
+import { fetchEulerVaultName } from "@/engine/erc20SubTypeProcessors/helpers/eulerVaultNames";
 import { batchMulticallCallWithRetry } from "@/utils/generic";
 import { log } from "@/utils/logger";
 import { providers } from "@/utils/providers";
@@ -6,7 +7,6 @@ import { apiDbClient } from "@db";
 import { ChainInteractionService, ERC20Interface, EULER_ADDRESSES, EulerEVKInterface, EulerVaultLensInterface, EulerVault__factory, NETWORK_LABELS, eulerChainIds, getContractCreationBlock, } from "@sdk";
 import { getAddress } from "ethers/lib/utils";
 import _ from "lodash";
-import { fetchEulerVaultName } from "../campaignTypes/ERC20SubTypes/helpers/eulerVaultNames";
 import { safeFetchLogs } from "./fetchLogs";
 export var LoggedEntityType;
 (function (LoggedEntityType) {

package/dist/src/{libs/campaigns/campaignTypes/ERC20SubTypes → engine/erc20SubTypeProcessors}/GenericProcessor.d.ts

@@ -1,6 +1,6 @@
 import type { Pricer } from "@/utils/pricer";
 import { type CallDto, type Campaign, type CampaignParameters } from "@sdk";
-import type { ERC20SupportedCampaignType } from "../ERC20DynamicData";
+import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
 import { type tokenType, type tokenTypeStruct } from "./helpers/tokenType";
 export declare enum Round {
     one = "round1",

package/dist/src/{libs/campaigns/campaignTypes/ERC20SubTypes → engine/erc20SubTypeProcessors}/helpers/tokenType.d.ts

@@ -90,7 +90,8 @@ export declare enum tokenType {
     katana = "katana",
     balancerV3 = "balancerV3",
     hanji_liquidity_vault_token = "hanji_liquidity_vault_token",
-    xU308 = "xU308"
+    xU308 = "xU308",
+    bunniV2 = "bunniV2"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

package/dist/src/{libs/campaigns/campaignTypes/ERC20SubTypes → engine/erc20SubTypeProcessors}/helpers/tokenType.js

@@ -92,6 +92,7 @@ export var tokenType;
     tokenType["balancerV3"] = "balancerV3";
     tokenType["hanji_liquidity_vault_token"] = "hanji_liquidity_vault_token";
     tokenType["xU308"] = "xU308";
+    tokenType["bunniV2"] = "bunniV2";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave", action: OpportunityAction.BORROW },
@@ -184,4 +185,5 @@ export const tokenTypeToProtocol = {
     [tokenType.balancerV3]: { protocol: "Balancer", action: OpportunityAction.POOL },
     [tokenType.hanji_liquidity_vault_token]: { protocol: "Hanji", action: OpportunityAction.POOL },
     [tokenType.xU308]: { protocol: "Uranium", action: OpportunityAction.HOLD },
+    [tokenType.bunniV2]: { protocol: "Bunni V2", action: OpportunityAction.HOLD },
 };

package/dist/src/engine/erc20SubTypeProcessors/implementations/BunniV2Processor.d.ts

@@ -0,0 +1,45 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters, type UniswapV4PoolKey } from "@sdk";
+import type { PoolStateStructOutput } from "libs/sdk/src/generated/BunniV2Hub";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawBunniV2;
+    call: string;
+    target: keyof callKeysBunniV2;
+    metaData?: keyof callKeysBunniV2;
+};
+type callKeysBunniV2 = mandatoryCallKeys & {
+    decimalsToken0: string;
+    decimalsToken1: string;
+    hub: string;
+    poolId: string;
+    poolKey: string;
+    poolState: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    token0: string;
+    token1: string;
+    totalSupply: string;
+};
+type dataRawBunniV2 = callKeysBunniV2 & {
+    poolId: string;
+    poolKey: UniswapV4PoolKey;
+    poolState: PoolStateStructOutput;
+};
+type dataTypeBunniV2 = dataType & {
+    poolId: string;
+    balance0: string;
+    balance1: string;
+};
+export declare class BunniV2Processor extends GenericProcessor<callKeysBunniV2, dataRawBunniV2, dataTypeBunniV2> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawBunniV2): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBunniV2, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBunniV2>;
+}
+export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/BunniV2Processor.js

@@ -0,0 +1,87 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number, computeUniswapV4PoolId } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class BunniV2Processor extends GenericProcessor {
+    rounds = {
+        round1: [
+            {
+                key: "hub",
+                call: "hub",
+                target: "tokenAddress",
+            },
+            {
+                key: "poolKey",
+                call: "poolKey",
+                target: "tokenAddress",
+            },
+            {
+                key: "token0",
+                call: "token0",
+                target: "tokenAddress",
+            },
+            {
+                key: "token1",
+                call: "token1",
+                target: "tokenAddress",
+            },
+        ],
+        round2: [
+            {
+                key: "poolState",
+                call: "poolState",
+                target: "hub",
+                metaData: "poolId",
+            },
+        ],
+        round3: [
+            {
+                key: "decimalsToken0",
+                call: "decimals",
+                target: "token0",
+            },
+            {
+                key: "symbolToken0",
+                call: "symbol",
+                target: "token0",
+            },
+            {
+                key: "decimalsToken1",
+                call: "decimals",
+                target: "token1",
+            },
+            {
+                key: "symbolToken1",
+                call: "symbol",
+                target: "token1",
+            },
+        ],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    processingRound2(typeInfo) {
+        typeInfo.poolId = computeUniswapV4PoolId(typeInfo.poolKey);
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const decimalsToken0 = Number(typeInfo.decimalsToken0);
+        const decimalsToken1 = Number(typeInfo.decimalsToken1);
+        const amount0 = BN2Number(typeInfo.poolState.rawBalance0, decimalsToken0) +
+            BN2Number(typeInfo.poolState.reserve0, decimalsToken0);
+        const amount1 = BN2Number(typeInfo.poolState.rawBalance1, decimalsToken0) +
+            BN2Number(typeInfo.poolState.reserve1, decimalsToken1);
+        const token0PRice = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const token1Price = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        const tvl = token0PRice * amount0 + token1Price * amount1;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            balance0: amount0.toString(),
+            balance1: amount1.toString(),
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+            priceTargetToken: priceTargetToken,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+        };
+    }
+}

package/dist/src/{libs/campaigns/campaignTypes/ERC20SubTypes → engine/erc20SubTypeProcessors}/implementations/processorMapping.js

@@ -8,6 +8,7 @@ import { BalancerGaugeProcessor } from "./BalancerGaugeProcessor";
 import { BalancerPoolProcessor } from "./BalancerPoolProcessor";
 import { BalancerV3PoolProcessor } from "./BalancerV3PoolProcessor";
 import { BeefyProcessor } from "./BeefyProcessor";
+import { BunniV2Processor } from "./BunniV2Processor";
 import { CompoundProcessor } from "./CompoundProcessor";
 import { ERC4626Processor } from "./ERC4626Processor";
 import { EnzymeProcessor } from "./EnzymeProcessor";
@@ -134,4 +135,5 @@ export const processorMapping = {
     [tokenType.balancerV3]: BalancerV3PoolProcessor,
     [tokenType.hanji_liquidity_vault_token]: HanjiVaultProcessor,
     [tokenType.xU308]: xU308Processor,
+    [tokenType.bunniV2]: BunniV2Processor,
 };

package/dist/src/{libs/campaigns/campaignTypes/ERC20SubTypes → engine/erc20SubTypeProcessors}/subtypesRound1.js

@@ -149,6 +149,8 @@ function satisfiesNameConditions(name, type) {
             return lowerCaseName.includes("spectra") && lowerCaseName.includes("curve");
         case tokenType.spectra_yt:
             return lowerCaseName.includes("yield") && lowerCaseName.includes("token");
+        case tokenType.bunniV2:
+            return lowerCaseName.includes("bunni");
         default:
             return false;
     }

package/dist/src/{libs/campaigns/campaignTypes/ERC20SubTypes → engine/erc20SubTypeProcessors}/subtypesRound2.d.ts

@@ -1,4 +1,4 @@
 import type { CampaignParameters, ResultDto } from "@sdk";
-import type { ERC20SupportedCampaignType } from "../ERC20DynamicData";
+import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
 import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
 export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: ResultDto[], campaign?: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;

package/dist/src/{factories → engine}/opportunityMetadata/implementations/Erc20.js

@@ -1,6 +1,6 @@
+import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
 import { log } from "@/utils/logger";
 import { Campaign as CampaignEnum } from "@sdk";
-import { CampaignService } from "../../../modules/v4/campaign";
 import { ProtocolService } from "../../../modules/v4/protocol/protocol.service";
 export class Erc20Metadata {
     async build(computeChainId, params, _subType, rewardTokenAddress, distributionChainId, campaignId) {
@@ -9,7 +9,7 @@ export class Erc20Metadata {
         let mainProtocolId = undefined;
         const tokens = [{ chainId: computeChainId, address: params.targetToken }];
         try {
-            const [dynamicData] = (await CampaignService.fetchDynamicData(computeChainId, CampaignEnum[CampaignEnum.ERC20], [
+            const [dynamicData] = await dynamicDataBuilderFactory(CampaignEnum.ERC20).build(computeChainId, [
                 {
                     campaignId,
                     rewardToken: rewardTokenAddress,
@@ -18,7 +18,7 @@ export class Erc20Metadata {
                     computeChainId,
                     campaignParameters: params,
                 },
-            ]));
+            ]);
             action = dynamicData?.typeInfo?.action ?? action;
             name = dynamicData?.typeInfo?.cardName;
             mainProtocolId = dynamicData?.typeInfo?.protocol?.toLowerCase().replace(" ", "");

package/dist/src/{factories → engine}/opportunityMetadata/implementations/Euler.d.ts

@@ -2,7 +2,7 @@ import { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from
 import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.EULER;
 export declare class EulerMetadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string, _distributionChainId: ChainId, campaignId: string): Promise<{
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string, distributionChainId: ChainId, campaignId: string): Promise<{
         name: string;
         tokens: {
             chainId: ChainId;

package/dist/src/{factories → engine}/opportunityMetadata/implementations/Euler.js

@@ -1,21 +1,21 @@
+import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
 import { log } from "@/utils/logger";
 import { OpportunityAction } from "@db/api";
 import { Campaign as CampaignEnum } from "@sdk";
-import { CampaignService } from "../../../modules/v4/campaign";
 export class EulerMetadata {
-    async build(computeChainId, params, subType, rewardTokenAddress, _distributionChainId, campaignId) {
+    async build(computeChainId, params, subType, rewardTokenAddress, distributionChainId, campaignId) {
         let name = `Hold ${params.symbolTargetToken}`;
         try {
-            const [dynamicData] = (await CampaignService.fetchDynamicData(computeChainId, CampaignEnum[CampaignEnum.EULER], [
+            const [dynamicData] = await dynamicDataBuilderFactory(CampaignEnum.EULER).build(computeChainId, [
                 {
-                    campaignSubType: subType,
-                    campaignParameters: params,
-                    computeChainId,
                     campaignId,
                     rewardToken: rewardTokenAddress,
                     amount: "1",
+                    chainId: distributionChainId,
+                    computeChainId,
+                    campaignParameters: params,
                 },
-            ]));
+            ]);
             name = dynamicData?.typeInfo?.cardName;
         }
         catch {

package/dist/src/{factories → engine}/opportunityMetadata/implementations/EventBased.d.ts

@@ -3,7 +3,7 @@ import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.EVENT_BASED;
 export declare class EventBasedMetadata implements MetadataBuilder<campaignType> {
     build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
-        action: "HOLD";
+        action: "SWAP";
         name: string;
         tokens: {
             chainId: ChainId;

package/dist/src/{factories → engine}/opportunityMetadata/implementations/EventBased.js

@@ -1,7 +1,7 @@
 export class EventBasedMetadata {
     async build(computeChainId, params, _subType) {
         try {
-            const action = "HOLD";
+            const action = "SWAP";
             const mainProtocolId = "Hanji";
             let name = `${params.eventID.split("(")[0]} on ${mainProtocolId}`;
             let tokens = [{ chainId: computeChainId, address: params.contract }];
@@ -33,7 +33,7 @@ export class EventBasedMetadata {
                 mainProtocol: mainProtocolId,
             };
         }
-        catch (error) {
+        catch {
             return {
                 action: "INVALID",
                 name: "Event Based Campaign",

package/dist/src/{factories → engine}/opportunityMetadata/implementations/Vest.js

@@ -1,4 +1,4 @@
-import { VEST_TOKEN } from "@/libs/campaigns/campaignTypes/VestDynamicData";
+import { VEST_TOKEN } from "@/engine/dynamicData/implementations/Vest";
 import { OpportunityAction } from "@db/api";
 export class VestMetadata {
     async build(computeChainId, _params, _subType) {