@merkl/api 0.19.7 → 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}/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/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) {

package/dist/src/index.d.ts

@@ -4551,8 +4551,8 @@ declare const app: Elysia<"", false, {
                 query: {
                     types?: string | number | string[] | number[] | undefined;
                     chainIds?: string | string[] | undefined;
-                    live?: boolean | undefined;
                     creatorTag?: string | undefined;
+                    live?: boolean | undefined;
                     hideTestTokens?: string | undefined;
                 };
                 headers: unknown;
@@ -4655,16 +4655,8 @@ declare const app: Elysia<"", false, {
                 query: {};
                 headers: unknown;
                 response: {
-                    200: {
-                        [x: string]: {
-                            address: string;
-                            symbolCToken: string;
-                            decimalsCToken: number;
-                            underlying: string;
-                            symbolUnderlying: string;
-                            decimalsUnderlying: number;
-                        }[];
-                    };
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };
@@ -5218,11 +5210,8 @@ declare const app: Elysia<"", false, {
                 query: {};
                 headers: unknown;
                 response: {
-                    200: {
-                        [x: string]: {
-                            [poolId: string]: UniswapV4PoolType;
-                        } | undefined;
-                    };
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };

package/dist/src/jobs/update-euler-vaults.js

@@ -1,6 +1,6 @@
 import { Redis } from "@/cache";
-import { fetchEulerVaultName } from "@/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/eulerVaultNames";
-import { LoggedEntityType, getEulerV2Vaults } from "@/libs/campaigns/utils/getEulerV2Vaults";
+import { LoggedEntityType, getEulerV2Vaults } from "@/engine/dynamicData/utils/getEulerV2Vaults";
+import { fetchEulerVaultName } from "@/engine/erc20SubTypeProcessors/helpers/eulerVaultNames";
 import { batchMulticallCallWithRetry } from "@/utils/generic";
 import { log } from "@/utils/logger";
 import { apiDbClient } from "@db";

package/dist/src/modules/v4/apr/apr.service.d.ts

@@ -2,5 +2,5 @@ import { type CampaignDynamicData, Campaign as CampaignTypeV3 } from "@sdk";
 import type { AprRecord } from "./apr.model";
 export declare abstract class AprService {
     static hashId(opportunityId: string, timestamp: bigint): string;
-    static extractFromDynamicData<C extends CampaignTypeV3>(type: C, campaignsDynamicData: CampaignDynamicData<C>[], timestamp?: bigint): AprRecord["model"];
+    static extractFromDynamicData<C extends CampaignTypeV3>(type: C, campaigns: CampaignDynamicData<C>[], timestamp?: bigint): AprRecord["model"];
 }

package/dist/src/modules/v4/apr/apr.service.js

@@ -5,18 +5,18 @@ export class AprService {
     static hashId(opportunityId, timestamp) {
         return Bun.hash(`${opportunityId}${timestamp}`).toString();
     }
-    static extractFromDynamicData(type, campaignsDynamicData, timestamp = BigInt(moment().unix())) {
+    static extractFromDynamicData(type, campaigns, timestamp = BigInt(moment().unix())) {
         const typesWithoutApr = [CampaignTypeV3.INVALID, CampaignTypeV3.JSON_AIRDROP, CampaignTypeV3.ERC20_SNAPSHOT];
         if (typesWithoutApr.includes(type))
             return { timestamp, cumulated: 0, breakdowns: [] };
-        let cumulated = campaignsDynamicData.reduce((sum, campaign) => {
+        let cumulated = campaigns.reduce((sum, campaign) => {
             const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
             if (!isLive)
                 return sum;
             return sum + (Number.isNaN(Number(campaign.apr)) ? 0 : Number(campaign.apr));
         }, 0) ?? 0;
         cumulated = Number.isNaN(Number(cumulated)) || !Number.isFinite(cumulated) ? 0 : cumulated;
-        const breakdowns = campaignsDynamicData.map(campaign => {
+        const breakdowns = campaigns.map(campaign => {
             const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
             return {
                 identifier: campaign.campaignId,
@@ -25,7 +25,7 @@ export class AprService {
             };
         });
         if (type === CampaignTypeV3.CLAMM) {
-            for (const campaign of campaignsDynamicData) {
+            for (const campaign of campaigns) {
                 const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
                 if (campaign.forwarders) {
                     for (const forwarder of campaign.forwarders) {

package/dist/src/modules/v4/campaign/campaign.service.d.ts

@@ -722,14 +722,6 @@ export declare abstract class CampaignService {
         createdAt: Date;
     };
     static formatAsCampaignParameters<C extends CampaignEnum>(campaign: CampaignWithParams): CampaignParameters<C>;
-    /**
-     * Fetches the campaign dynamic data for a v3 campaign onchain
-     * @param chainId
-     * @param campaignType
-     * @param campaigns of v3 type
-     * @returns
-     */
-    static fetchDynamicData(chainId: number, campaignType: string, campaigns: CampaignParameters<any>[]): Promise<any>;
     /**
      * Shortcut to get daily amount from total
      * @param start timestamp

package/dist/src/modules/v4/campaign/campaign.service.js

@@ -1,11 +1,9 @@
 import { HttpError } from "@/errors";
-import { campaignsDynamicData } from "@/libs/campaigns/campaignsDynamicData";
 import { OpportunityService } from "@/modules/v4/opportunity";
 import { StatusService } from "@/modules/v4/status/status.service";
 import { TokenRepository } from "@/modules/v4/token/token.repository";
 import { TokenService } from "@/modules/v4/token/token.service";
 import { CannotParseOpportunity, InvalidParameter } from "@/utils/error";
-import { executeSimple } from "@/utils/execute";
 import { log } from "@/utils/logger";
 import { Campaign as CampaignEnum, NETWORK_LABELS, } from "@sdk";
 import { utils } from "ethers";
@@ -293,17 +291,6 @@ export class CampaignService {
             amount: campaign.amount,
         };
     }
-    /**
-     * Fetches the campaign dynamic data for a v3 campaign onchain
-     * @param chainId
-     * @param campaignType
-     * @param campaigns of v3 type
-     * @returns
-     */
-    static async fetchDynamicData(chainId, campaignType, campaigns) {
-        const calls = campaignsDynamicData(chainId, campaigns, CampaignEnum[campaignType]);
-        return await executeSimple(chainId, calls);
-    }
     /**
      * Shortcut to get daily amount from total
      * @param start timestamp

package/dist/src/modules/v4/dynamicData/dynamicData.service.js

@@ -1,8 +1,7 @@
+import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
 import { HttpError } from "@/errors";
-import { campaignsDynamicData } from "@/libs/campaigns/campaignsDynamicData";
 import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
 import bigintToString from "@/utils/bigintToString";
-import { executeSimple } from "@/utils/execute";
 import { log } from "@/utils/logger";
 import { Campaign, NETWORK_LABELS } from "@sdk";
 import { Campaign as CampaignEnum } from "@sdk";
@@ -43,7 +42,7 @@ export class DynamicDataService {
             },
         ];
         log.info(`querying mock campaign on chain: ${NETWORK_LABELS[chainId]}`);
-        const result = await executeSimple(Number(chainId), campaignsDynamicData(Number(chainId), campaigns, Campaign.ERC20));
+        const result = await dynamicDataBuilderFactory(Campaign.ERC20).build(Number(chainId), campaigns);
         return {
             priceTargetToken: result[0]?.typeInfo.priceTargetToken,
             totalSupply: result[0]?.typeInfo.totalSupply,
@@ -56,7 +55,7 @@ export class DynamicDataService {
     static async updateForCampaignType(campaigns, type) {
         const chainId = campaigns[0].computeChainId;
         const dynamicDataArray = [];
-        const dynamicData = await executeSimple(chainId, campaignsDynamicData(chainId, campaigns, type));
+        const dynamicData = await dynamicDataBuilderFactory(typeof type === "number" ? type : Campaign[type]).build(chainId, campaigns);
         const oppMap = {};
         for (const data of dynamicData) {
             if (!!data) {

package/dist/src/modules/v4/opportunity/opportunity.service.js

@@ -10,7 +10,7 @@ import { Prisma, Status } from "@db/api";
 import { record } from "@elysiajs/opentelemetry";
 import { Campaign as CampaignEnum } from "@sdk";
 import moment from "moment";
-import { metadataBuilderFactory } from "../../../factories/opportunityMetadata/factory";
+import { metadataBuilderFactory } from "../../../engine/opportunityMetadata/factory";
 import { OpportunityRepository } from "./opportunity.repository";
 export class OpportunityService {
     static hashId(opportunity) {

package/dist/src/modules/v4/uniswapV4/uniswapV4.controller.d.ts

@@ -27,10 +27,10 @@ export declare const uniswapV4Controller: Elysia<"uniswap-v4", false, {
                             poolId: string;
                             poolKey: {
                                 hooks: string;
-                                currency0: string;
-                                currency1: string;
                                 fee: number;
                                 tickSpacing: number;
+                                currency0: string;
+                                currency1: string;
                             };
                             decimalsCurrency0: number;
                             decimalsCurrency1: number;

package/dist/src/modules/v4/uniswapV4/uniswapV4.service.d.ts

@@ -7,10 +7,10 @@ export declare abstract class UniswapV4Service {
             poolId: string;
             poolKey: {
                 hooks: string;
-                currency0: string;
-                currency1: string;
                 fee: number;
                 tickSpacing: number;
+                currency0: string;
+                currency1: string;
             };
             decimalsCurrency0: number;
             decimalsCurrency1: number;