@merkl/api 0.19.6 → 0.19.8

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

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.COMPOUND;
+export declare class CompoundDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<CompoundCampaignDynamicData[]>;
+}
+export {};

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

@@ -0,0 +1,136 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+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 class CompoundDynamicData {
+    async build(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,
+                    });
+                }
+            }
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        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++].returnData)[0], campaign.campaignParameters.decimalsUnderlyingToken);
+                    }
+                    else {
+                        if (campaign.campaignParameters.compFork === CompFork.LayerBank) {
+                            borrowedAmount = BN2Number(LayerBankERC20Interface.decodeFunctionResult("totalBorrow", result[i++].returnData)[0], campaign.campaignParameters.decimalsUnderlyingToken);
+                        }
+                        else {
+                            borrowedAmount = BN2Number(CTokenInterface.decodeFunctionResult("totalBorrows", result[i++].returnData)[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++].returnData)[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++].returnData)[0], campaign.campaignParameters.decimalsUnderlyingToken);
+                    }
+                    else {
+                        totalSupplyTargetToken = BN2Number(CTokenInterface.decodeFunctionResult("totalBorrows", result[i++].returnData)[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 priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            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/engine/dynamicData/implementations/Dolomite.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.DOLOMITE;
+export declare class DolomiteDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<CampaignDynamicData<Campaign.DOLOMITE>[]>;
+}
+export {};

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

@@ -0,0 +1,53 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { Pricer } from "@/utils/pricer";
+import { BN2Number, DolomiteSubCampaignType, YEAR, } from "@sdk";
+import axios from "axios";
+import { log } from "../../../utils/logger";
+export class DolomiteDynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        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 priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                const priceTargetToken = (await pricer.get({
+                    address: tokenData.id,
+                    chainId,
+                    symbol: tokenData.symbol,
+                })) ?? 0;
+                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/engine/dynamicData/implementations/EigenLayer.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.EIGENLAYER;
+export declare class EigenLayerDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<EigenLayerCampaignDynamicData[]>;
+}
+export {};

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

@@ -0,0 +1,64 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { Pricer } from "@/utils/pricer";
+import { BN2Number, ChainInteractionService, EigenLayerStrategyInterface, EigenLayerStrategy__factory, YEAR, } from "@sdk";
+import { log } from "../../../utils/logger";
+export class EigenLayerDynamicData {
+    async build(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,
+            });
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupplyShares;
+            let totalSupplyStrategy;
+            try {
+                totalSupplyShares = EigenLayerStrategyInterface.decodeFunctionResult("totalShares", result[i++].returnData)[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 priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            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/engine/dynamicData/implementations/Encompassing.d.ts

@@ -0,0 +1,7 @@
+import type { Campaign, CampaignParameters, MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.ENCOMPASSING;
+export declare class EncompassingDynamicData implements DynamicDataBuilder<campaignType> {
+    build(_chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<any[]>;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import axios from "axios";
+export class EncompassingDynamicData {
+    async build(_chainId, campaigns) {
+        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/engine/dynamicData/implementations/Erc20.d.ts

@@ -0,0 +1,6 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+export type ERC20SupportedCampaignType = Campaign.ERC20 | Campaign.ERC20LOGPROCESSOR | Campaign.ERC20REBASELOGPROCESSOR | Campaign.EULER;
+export declare class Erc20DynamicData implements DynamicDataBuilder<ERC20SupportedCampaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<ERC20SupportedCampaignType>[]): Promise<any[]>;
+}

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

@@ -0,0 +1,159 @@
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { getTokenPricesInfo } from "@/engine/erc20SubTypeProcessors/subtypesPrices";
+import { getTokenTypeRound1 } from "@/engine/erc20SubTypeProcessors/subtypesRound1";
+import { getTokenTypeRound2 } from "@/engine/erc20SubTypeProcessors/subtypesRound2";
+import { getTokenTypeRound3 } from "@/engine/erc20SubTypeProcessors/subtypesRound3";
+import { getTokenTypeRound4 } from "@/engine/erc20SubTypeProcessors/subtypesRound4";
+import { ComputedValueService } from "@/modules/v4/computedValue";
+import { TokenRepository } from "@/modules/v4/token/token.repository";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { log } from "@/utils/logger";
+import { Pricer } from "@/utils/pricer";
+import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
+export class Erc20DynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        // 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);
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            // const priceRewardToken =
+            //   (await pricer.get({
+            //     address: campaign.rewardToken,
+            //     chainId,
+            //     symbol: campaign.campaignParameters.symbolRewardToken,
+            //   })) ?? 0;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            // 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.map(r => r.returnData), 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/engine/dynamicData/implementations/Erc20Snapshot.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.ERC20_SNAPSHOT;
+export declare class Erc20SnapshotDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<any[]>;
+}
+export {};

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

@@ -0,0 +1,32 @@
+import { BN2Number, ChainInteractionService, ERC20Interface, } from "@sdk";
+import { Pricer } from "../../../utils/pricer";
+export class Erc20SnapshotDynamicData {
+    async build(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,
+            });
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        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++].returnData)[0], campaign.campaignParameters.decimalsTargetToken);
+            dynamicData.push({
+                ...campaign,
+                totalSupplyTargetToken,
+                tvl: totalSupplyTargetToken * priceTargetToken,
+            });
+        }
+        return dynamicData;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.EVENT_BASED;
+export declare class EventBasedDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<EventBasedCampaignDynamicData[]>;
+}
+export {};

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

@@ -0,0 +1,104 @@
+import { BucketService } from "@/modules/v4/bucket/bucket.service";
+import { TokenService } from "@/modules/v4/token/token.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";
+/**
+ * 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 {
+        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 {
+        log.warn(`merklDynamic data - failed to decode state of event based on ${NETWORK_LABELS[chainId]}`);
+    }
+    return { tvl, blockNumber: blockNumber };
+}
+export class EventBasedDynamicData {
+    async build(chainId, campaigns) {
+        const dynamicData = [];
+        const pricer = await Pricer.load();
+        for (const campaign of campaigns) {
+            try {
+                const decimalsCurrency0 = 6;
+                const symbolCurrency0 = "USDC";
+                const priceToken = (await pricer.get({
+                    chainId: chainId,
+                    symbol: symbolCurrency0,
+                }));
+                const { tvl } = 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 = await TokenService.getRewardTokenPrice(campaign);
+                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 {
+                dynamicData.push({
+                    ...campaign,
+                    apr: 0,
+                    priceRewardToken: 0,
+                    tvl: 1,
+                });
+            }
+        }
+        return dynamicData;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.HYPERDRIVELOGPROCESSOR | Campaign.HYPERDRIVELOGFIXPROCESSOR;
+export declare class HyperdriveDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<any[]>;
+}
+export {};