@merkl/api 0.19.6 → 0.19.8

package/dist/src/libs/campaigns/campaignTypes/CompoundDynamicData.d.ts

@@ -1,3 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-export declare function CompoundDynamicData(_chainId: MerklChainId, campaigns: CampaignParameters<Campaign.COMPOUND>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.COMPOUND>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/CompoundDynamicData.js

@@ -1,139 +0,0 @@
-import { BN2Number, CTokenInterface, ChainInteractionService, CompFork, CompoundSubCampaignType, ERC20Interface, IonicERC20_INTERFACE, LayerBankERC20Interface, NULL_ADDRESS, YEAR, } from "@sdk";
-import { log } from "../../../utils/logger";
-import { Pricer } from "../../../utils/pricer";
-export async function CompoundDynamicData(_chainId, campaigns) {
-    const pricer = await Pricer.load();
-    const calls = [];
-    for (const campaign of campaigns) {
-        if (campaign.campaignSubType === CompoundSubCampaignType.supply) {
-            if (campaign.campaignParameters.compFork === CompFork.Ionic) {
-                calls.push({
-                    allowFailure: true,
-                    callData: IonicERC20_INTERFACE.encodeFunctionData("getTotalUnderlyingSupplied"),
-                    target: campaign.campaignParameters.targetToken,
-                });
-            }
-            else {
-                if (campaign.campaignParameters.compFork === CompFork.LayerBank) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: LayerBankERC20Interface.encodeFunctionData("totalBorrow"),
-                        target: campaign.campaignParameters.targetToken,
-                    });
-                }
-                else {
-                    calls.push({
-                        allowFailure: true,
-                        callData: CTokenInterface.encodeFunctionData("totalBorrows"),
-                        target: campaign.campaignParameters.targetToken,
-                    });
-                }
-                if (campaign.campaignParameters.underlyingToken !== NULL_ADDRESS) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: ERC20Interface.encodeFunctionData("balanceOf", [campaign.campaignParameters.targetToken]),
-                        target: campaign.campaignParameters.underlyingToken,
-                    });
-                }
-            }
-        }
-        else {
-            if (campaign.campaignParameters.compFork === CompFork.LayerBank) {
-                calls.push({
-                    allowFailure: true,
-                    callData: LayerBankERC20Interface.encodeFunctionData("totalBorrow"),
-                    target: campaign.campaignParameters.targetToken,
-                });
-            }
-            else {
-                calls.push({
-                    allowFailure: true,
-                    callData: CTokenInterface.encodeFunctionData("totalBorrows"),
-                    target: campaign.campaignParameters.targetToken,
-                });
-            }
-        }
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let i = 0;
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    let totalSupplyTargetToken;
-                    let borrowedAmount;
-                    let nonUtilizedSupplied;
-                    if (campaign.campaignSubType === CompoundSubCampaignType.supply) {
-                        try {
-                            if (campaign.campaignParameters.compFork === CompFork.Ionic) {
-                                totalSupplyTargetToken = BN2Number(IonicERC20_INTERFACE.decodeFunctionResult("getTotalUnderlyingSupplied", result[i++])[0], campaign.campaignParameters.decimalsUnderlyingToken);
-                            }
-                            else {
-                                if (campaign.campaignParameters.compFork === CompFork.LayerBank) {
-                                    borrowedAmount = BN2Number(LayerBankERC20Interface.decodeFunctionResult("totalBorrow", result[i++])[0], campaign.campaignParameters.decimalsUnderlyingToken);
-                                }
-                                else {
-                                    borrowedAmount = BN2Number(CTokenInterface.decodeFunctionResult("totalBorrows", result[i++])[0], campaign.campaignParameters.decimalsUnderlyingToken);
-                                }
-                                if (campaign.campaignParameters.underlyingToken === NULL_ADDRESS) {
-                                    // For the case of ETH
-                                    nonUtilizedSupplied = BN2Number(await ChainInteractionService(campaign.computeChainId)
-                                        .provider()
-                                        .getBalance(campaign.campaignParameters.targetToken), 18);
-                                }
-                                else {
-                                    nonUtilizedSupplied = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i++])[0], campaign.campaignParameters.decimalsUnderlyingToken);
-                                }
-                                totalSupplyTargetToken = borrowedAmount + nonUtilizedSupplied;
-                            }
-                        }
-                        catch {
-                            log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
-                            totalSupplyTargetToken = 0.0000001;
-                        }
-                    }
-                    else {
-                        try {
-                            if (campaign.campaignParameters.compFork === CompFork.LayerBank) {
-                                totalSupplyTargetToken = BN2Number(LayerBankERC20Interface.decodeFunctionResult("totalBorrow", result[i++])[0], campaign.campaignParameters.decimalsUnderlyingToken);
-                            }
-                            else {
-                                totalSupplyTargetToken = BN2Number(CTokenInterface.decodeFunctionResult("totalBorrows", result[i++])[0], campaign.campaignParameters.decimalsUnderlyingToken);
-                            }
-                        }
-                        catch {
-                            log.warn(`Error getting totalBorrows for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
-                            totalSupplyTargetToken = 0.0000001;
-                        }
-                    }
-                    const priceRewardToken = (await pricer.get({
-                        address: campaign.rewardToken,
-                        chainId: campaign.chainId,
-                        symbol: campaign.campaignParameters.symbolRewardToken,
-                    })) ?? 0;
-                    const priceTargetToken = (await pricer.get({
-                        address: campaign.campaignParameters.underlyingToken,
-                        chainId: campaign.computeChainId,
-                        symbol: campaign.campaignParameters.symbolUnderlyingToken,
-                    })) ?? 0;
-                    dynamicData.push({
-                        ...campaign,
-                        apr: (priceRewardToken *
-                            BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                            YEAR *
-                            100) /
-                            campaign.campaignParameters.duration /
-                            (totalSupplyTargetToken * priceTargetToken),
-                        totalSupplyTargetToken,
-                        tvl: totalSupplyTargetToken * priceTargetToken,
-                        priceRewardToken: priceRewardToken,
-                    });
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignTypes/DolomiteDynamicData.d.ts

@@ -1,5 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-type campaignType = Campaign.DOLOMITE;
-export declare function DolomiteDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<UncachedResult<Partial<CampaignDynamicData<campaignType>[]>>>;
-export {};

package/dist/src/libs/campaigns/campaignTypes/DolomiteDynamicData.js

@@ -1,60 +0,0 @@
-import { BN2Number, DolomiteSubCampaignType, YEAR, } from "@sdk";
-import axios from "axios";
-import { log } from "../../../utils/logger";
-import { Pricer } from "../../../utils/pricer";
-export async function DolomiteDynamicData(chainId, campaigns) {
-    const pricer = await Pricer.load();
-    const calls = [];
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let i = 0;
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    try {
-                        const apiRes = (await axios.get(`https://api.dolomite.io/balances/${campaign.computeChainId}/total-supply`))
-                            .data.Result;
-                        const tokenIndex = apiRes.findIndex(x => Number.parseFloat(x.token.marketId) === campaign.campaignParameters.marketIndex);
-                        const tokenData = apiRes[tokenIndex].token;
-                        const totalSupplyTargetToken = campaign.campaignSubType === DolomiteSubCampaignType.borrow
-                            ? Number.parseFloat(tokenData.borrowLiquidity)
-                            : campaign.campaignSubType === DolomiteSubCampaignType.supply
-                                ? Number.parseFloat(tokenData.supplyLiquidity)
-                                : Number.parseFloat(tokenData.supplyLiquidity) - Number.parseFloat(tokenData.borrowLiquidity);
-                        const priceRewardToken = (await pricer.get({
-                            address: campaign.rewardToken,
-                            chainId,
-                            symbol: campaign.campaignParameters.symbolRewardToken,
-                        })) ?? 0;
-                        const priceTargetToken = (await pricer.get({
-                            address: tokenData.id,
-                            chainId,
-                            symbol: tokenData.symbol,
-                        })) ?? 0;
-                        i++;
-                        dynamicData.push({
-                            ...campaign,
-                            apr: (priceRewardToken *
-                                BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                                YEAR *
-                                100) /
-                                campaign.campaignParameters.duration /
-                                (totalSupplyTargetToken * priceTargetToken),
-                            totalSupplyTargetToken,
-                            tvl: totalSupplyTargetToken * priceTargetToken,
-                        });
-                    }
-                    catch (e) {
-                        log.error("Failed to fetch Dolomite data", e);
-                        // In this case we return just the staticData
-                        dynamicData.push({ ...campaign });
-                    }
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicData.d.ts

@@ -1,4 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-export type ERC20SupportedCampaignType = Campaign.ERC20 | Campaign.ERC20LOGPROCESSOR | Campaign.ERC20REBASELOGPROCESSOR | Campaign.EULER;
-export declare function ERC20DynamicData(chainId: MerklChainId, campaigns: CampaignParameters<ERC20SupportedCampaignType>[]): Promise<UncachedResult<Partial<CampaignDynamicData<ERC20SupportedCampaignType>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicData.js

@@ -1,164 +0,0 @@
-import { merklChainDataWithCache } from "@/libs/merklChainData";
-import { ComputedValueService } from "@/modules/v4/computedValue";
-import { TokenRepository } from "@/modules/v4/token/token.repository";
-import { log } from "@/utils/logger";
-import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
-import { Pricer } from "../../../utils/pricer";
-import { tokenType } from "./ERC20SubTypes/helpers/tokenType";
-import { getTokenPricesInfo } from "./ERC20SubTypes/subtypesPrices";
-import { getTokenTypeRound1 } from "./ERC20SubTypes/subtypesRound1";
-import { getTokenTypeRound2 } from "./ERC20SubTypes/subtypesRound2";
-import { getTokenTypeRound3 } from "./ERC20SubTypes/subtypesRound3";
-import { getTokenTypeRound4 } from "./ERC20SubTypes/subtypesRound4";
-export async function ERC20DynamicData(chainId, campaigns) {
-    const pricer = await Pricer.load();
-    const currentRoot = (await merklChainDataWithCache(chainId)).merkleRoot;
-    // Round 1: Get the high level type for each token (will need to be refined lated with more calls)
-    const callsRounds1 = [];
-    const tokenTypesByCampaign = {};
-    for (const campaign of campaigns) {
-        const typeStruct = {
-            type: tokenType.unknown,
-            calls: [],
-            typeInfo: {},
-        };
-        const targetToken = campaign.campaignParameters.targetToken;
-        typeStruct.calls = [
-            {
-                allowFailure: true,
-                callData: FactoryInterface.encodeFunctionData("factory"),
-                target: targetToken,
-            },
-            {
-                allowFailure: true,
-                callData: MetamorphoInterface.encodeFunctionData("MORPHO"),
-                target: targetToken,
-            },
-            {
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("name"),
-                target: targetToken,
-            },
-            {
-                allowFailure: true,
-                callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
-                target: targetToken,
-            },
-            {
-                allowFailure: true,
-                callData: EnzymeInterface.encodeFunctionData("getCreator"),
-                target: targetToken,
-            },
-            {
-                allowFailure: true,
-                callData: LayerBankERC20Interface.encodeFunctionData("owner"),
-                target: targetToken,
-            },
-            {
-                allowFailure: true,
-                callData: BalancerV3StablePoolInterface.encodeFunctionData("getVault"),
-                target: targetToken,
-            },
-        ];
-        callsRounds1.push(...typeStruct.calls);
-        tokenTypesByCampaign[campaign.campaignId] = typeStruct;
-    }
-    const resultRound1 = await ChainInteractionService(chainId).fetchState(callsRounds1);
-    // Round 2: Decode result from round 1 and get some additional info for the types before the final calls
-    const callsRounds2 = [];
-    let i = 0;
-    for (const campaign of campaigns) {
-        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
-        i += callsForCampaign;
-        callsRounds2.push(...tokenTypesByCampaign[campaign.campaignId].calls);
-    }
-    const resultRound2 = await ChainInteractionService(chainId).fetchState(callsRounds2);
-    // Round 3: Decode result from round 2 and get some additional info for the types before the final calls
-    const callsRounds3 = [];
-    let j = 0;
-    for (const campaign of campaigns) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound2(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultRound2, campaign);
-        j += callsForCampaign;
-        callsRounds3.push(...tokenTypesByCampaign[campaign.campaignId].calls);
-    }
-    const resultRound3 = await ChainInteractionService(chainId).fetchState(callsRounds3);
-    // Final round before execute
-    let callsFinal = [];
-    j = 0;
-    for (const campaign of campaigns) {
-        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound3(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultRound3);
-        j += callsForCampaign;
-        callsFinal = callsFinal.concat(tokenTypesByCampaign[campaign.campaignId].calls);
-    }
-    // Round 4: Get the final data
-    const resultsFinal = await ChainInteractionService(chainId).fetchState(callsFinal);
-    j = 0;
-    let calls = [];
-    for (const campaign of campaigns) {
-        const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-        tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound4(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultsFinal, campaign);
-        j += callsForCampaign;
-        calls = calls.concat(tokenTypesByCampaign[campaign.campaignId].calls);
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let i = 0;
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    const priceRewardToken = (await pricer.get({
-                        address: campaign.rewardToken,
-                        chainId,
-                        symbol: campaign.campaignParameters.symbolRewardToken,
-                    })) ?? 0;
-                    // Get the data from the final round and process it to get the price of the target token and some extra info
-                    const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
-                    tokenTypesByCampaign[campaign.campaignId] = await getTokenPricesInfo(i, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, result, campaign, pricer);
-                    try {
-                        if (!!tokenTypesByCampaign[campaign.campaignId]?.typeInfo.priceTargetToken && getEnv() === "prod")
-                            await TokenRepository.updateAddressPrices(campaign.campaignParameters.targetToken, tokenTypesByCampaign[campaign.campaignId]?.typeInfo.priceTargetToken);
-                    }
-                    catch (e) {
-                        log.warn(`failed to update target token price: ${e}`);
-                    }
-                    i += callsForCampaign;
-                    const whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
-                    const totalSupplyTargetToken = whitelistedSupplyTargetToken;
-                    const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
-                    let lastEligibilityRatio = 1;
-                    if (!!campaign.campaignParameters.hooks?.length) {
-                        lastEligibilityRatio =
-                            (await ComputedValueService.findCampaignValue({
-                                campaignId: `${campaign.campaignId}-${chainId}`,
-                                field: "averageBoost",
-                            }))?.averageBoost ?? 1;
-                    }
-                    dynamicData.push({
-                        ...campaign,
-                        apr: (lastEligibilityRatio *
-                            (priceRewardToken *
-                                BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                                YEAR *
-                                100)) /
-                            campaign.campaignParameters.duration /
-                            (whitelistedSupplyTargetToken * priceTargetToken),
-                        totalSupplyTargetToken,
-                        tvl: whitelistedSupplyTargetToken * priceTargetToken,
-                        type: tokenTypesByCampaign[campaign.campaignId].type,
-                        typeInfo: tokenTypesByCampaign[campaign.campaignId].typeInfo,
-                        priceRewardToken: priceRewardToken,
-                        lastEligibilityRatio,
-                    });
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignTypes/ERC20_SNAPSHOTDynamicData.d.ts

@@ -1,5 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-type ReturnType = CampaignDynamicData<Campaign.ERC20_SNAPSHOT>[];
-export declare function ERC20_SNAPSHOTDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.ERC20_SNAPSHOT>[]): Promise<UncachedResult<Partial<ReturnType>>>;
-export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20_SNAPSHOTDynamicData.js

@@ -1,38 +0,0 @@
-import { BN2Number, ERC20Interface, } from "@sdk";
-import { Pricer } from "../../../utils/pricer";
-export async function ERC20_SNAPSHOTDynamicData(chainId, campaigns) {
-    const pricer = await Pricer.load();
-    const calls = [];
-    for (const campaign of campaigns) {
-        calls.push({
-            allowFailure: false,
-            callData: ERC20Interface.encodeFunctionData("totalSupply"),
-            target: campaign.campaignParameters.targetToken,
-        });
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let i = 0;
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    const priceTargetToken = await pricer.get({
-                        address: campaign.campaignParameters.targetToken,
-                        chainId,
-                        symbol: campaign.campaignParameters.symbolTargetToken,
-                    });
-                    const totalSupplyTargetToken = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[i++])[0], campaign.campaignParameters.decimalsTargetToken);
-                    dynamicData.push({
-                        ...campaign,
-                        totalSupplyTargetToken,
-                        tvl: totalSupplyTargetToken * priceTargetToken,
-                    });
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignTypes/EigenLayerDynamicData.d.ts

@@ -1,3 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-export declare function EigenLayerDynamicData(_chainId: MerklChainId, campaigns: CampaignParameters<Campaign.EIGENLAYER>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.EIGENLAYER>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/EigenLayerDynamicData.js

@@ -1,67 +0,0 @@
-import { BN2Number, ChainInteractionService, EigenLayerStrategyInterface, EigenLayerStrategy__factory, YEAR, } from "@sdk";
-import { log } from "../../../utils/logger";
-import { Pricer } from "../../../utils/pricer";
-export async function EigenLayerDynamicData(_chainId, campaigns) {
-    const pricer = await Pricer.load();
-    const calls = [];
-    for (const campaign of campaigns) {
-        calls.push({
-            allowFailure: true,
-            callData: EigenLayerStrategyInterface.encodeFunctionData("totalShares"),
-            target: campaign.campaignParameters.strategy,
-        });
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                let i = 0;
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    let totalSupplyShares;
-                    let totalSupplyStrategy;
-                    try {
-                        totalSupplyShares = EigenLayerStrategyInterface.decodeFunctionResult("totalShares", result[i++])[0];
-                    }
-                    catch {
-                        log.warn(`Error getting totalShares for campaign ${campaign.campaignId} and strategy ${campaign.campaignParameters.strategy}`);
-                        totalSupplyShares = 0.0000001;
-                    }
-                    try {
-                        totalSupplyStrategy = BN2Number(await EigenLayerStrategy__factory.connect(campaign.campaignParameters.strategy, ChainInteractionService(campaign.computeChainId).provider()).sharesToUnderlying(totalSupplyShares), campaign.campaignParameters.decimalsUnderlyingToken);
-                    }
-                    catch {
-                        log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and strategy ${campaign.campaignParameters.strategy}`);
-                        totalSupplyStrategy = 0.0000001;
-                    }
-                    const priceRewardToken = (await pricer.get({
-                        address: campaign.rewardToken,
-                        chainId: campaign.chainId,
-                        symbol: campaign.campaignParameters.symbolRewardToken,
-                    })) ?? 0;
-                    const priceTargetToken = (await pricer.get({
-                        address: campaign.campaignParameters.underlyingToken,
-                        chainId: campaign.computeChainId,
-                        symbol: campaign.campaignParameters.symbolUnderlyingToken,
-                    })) ?? 0;
-                    const tvl = totalSupplyStrategy * priceTargetToken;
-                    dynamicData.push({
-                        ...campaign,
-                        apr: (priceRewardToken *
-                            BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                            YEAR *
-                            100) /
-                            campaign.campaignParameters.duration /
-                            (totalSupplyStrategy * priceTargetToken),
-                        totalSupplyTargetToken: totalSupplyStrategy,
-                        tvl,
-                        priceRewardToken: priceRewardToken,
-                    });
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignTypes/EncompassingDynamicData.d.ts

@@ -1,5 +0,0 @@
-import type { Campaign, CampaignDynamicData, CampaignParameters, MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-type ReturnType = CampaignDynamicData<Campaign.ENCOMPASSING>[];
-export declare function EncompassingDynamicData(_chainId: MerklChainId, campaigns: CampaignParameters<Campaign.ENCOMPASSING>[]): Promise<UncachedResult<Partial<ReturnType>>>;
-export {};

package/dist/src/libs/campaigns/campaignTypes/EncompassingDynamicData.js

@@ -1,34 +0,0 @@
-import axios from "axios";
-export async function EncompassingDynamicData(_chainId, campaigns) {
-    const calls = [];
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (_result) => {
-                const dynamicData = [];
-                for (const campaign of campaigns) {
-                    let tvl = 0;
-                    let apr = 0;
-                    if (campaign.campaignParameters.dataUrl) {
-                        try {
-                            const dataResponse = await axios.get(campaign.campaignParameters.dataUrl);
-                            if (dataResponse.data) {
-                                tvl = dataResponse.data.tvl ?? 0;
-                                apr = dataResponse.data.apr ?? 0;
-                            }
-                        }
-                        catch { }
-                    }
-                    dynamicData.push({
-                        ...campaign,
-                        tvl,
-                        apr,
-                    });
-                }
-                return dynamicData;
-            },
-        },
-    };
-}

package/dist/src/libs/campaigns/campaignTypes/EventBasedDynamicData.d.ts

@@ -1,3 +0,0 @@
-import { type Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { UncachedResult } from "../../../utils/execute";
-export declare function EventBasedDynamicData(chainId: MerklChainId, campaigns: CampaignParameters<Campaign.EVENT_BASED>[]): Promise<UncachedResult<Partial<CampaignDynamicData<Campaign.EVENT_BASED>[]>>>;

package/dist/src/libs/campaigns/campaignTypes/EventBasedDynamicData.js

@@ -1,114 +0,0 @@
-import { BucketService } from "@/modules/v4/bucket/bucket.service";
-import { engineDbClient } from "@db";
-import { BN2Number, ChainInteractionService, NETWORK_LABELS, } 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 computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaignID, priceCurrency, decimalsCurrency) {
-    let stateSave;
-    let blockNumber;
-    let states = {};
-    try {
-        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
-        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
-            where: {
-                id: `EventBasedProcessor_${chainId}_${campaignID}`,
-                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 ${campaignID} on ${NETWORK_LABELS[chainId]}`);
-    }
-    const { fileName, bucketName } = states;
-    // Bucket service
-    let tvl = 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)) {
-            tvl += BN2Number(value.allTimeValue, decimalsCurrency);
-        }
-        tvl = tvl * priceCurrency;
-        tvl = Math.max(tvl, 1);
-    }
-    catch (e) {
-        log.warn(`merklDynamic data - failed to decode state of event based on ${NETWORK_LABELS[chainId]}`);
-    }
-    return { tvl, blockNumber: blockNumber };
-}
-export async function EventBasedDynamicData(chainId, campaigns) {
-    const dynamicData = [];
-    const pricer = await Pricer.load();
-    const calls = [];
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                for (const campaign of campaigns) {
-                    try {
-                        const decimalsCurrency0 = 6;
-                        const symbolCurrency0 = "USDC";
-                        const priceToken = (await pricer.get({
-                            chainId: chainId,
-                            symbol: symbolCurrency0,
-                        }));
-                        const { tvl, blockNumber } = await computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaign.campaignId, priceToken, decimalsCurrency0);
-                        const c = campaign;
-                        const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
-                        const multiplier = BN2Number(c.campaignParameters.topicToData[0].multiplier, 12 + 9);
-                        const startTimestamp = BN2Number(c.startTimestamp, 0);
-                        const endTimestamp = BN2Number(c.endTimestamp, 0);
-                        const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
-                        let distributionMeanAPR = 0;
-                        const priceRewardToken = 1;
-                        if (isLive) {
-                            /** Yearly rewards in $ */
-                            const fixRewardRate = multiplier * priceRewardToken;
-                            distributionMeanAPR = fixRewardRate;
-                            if (tvl * fixRewardRate >
-                                (amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp)) {
-                                distributionMeanAPR =
-                                    (fixRewardRate * amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp) / tvl;
-                            }
-                            distributionMeanAPR = !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
-                            dynamicData.push({
-                                ...campaign,
-                                apr: distributionMeanAPR,
-                                priceRewardToken: priceRewardToken,
-                                tvl: tvl,
-                            });
-                        }
-                    }
-                    catch (e) {
-                        dynamicData.push({
-                            ...campaign,
-                            apr: 0,
-                            priceRewardToken: 0,
-                            tvl: 1,
-                        });
-                    }
-                }
-                return dynamicData;
-            },
-        },
-    };
-}