@merkl/api 0.21.46 → 1.0.0

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

@@ -1,162 +0,0 @@
-import { getTokenPricesInfo } from "@/engine/deprecated/erc20SubTypeProcessors/subtypesPrices";
-import { getTokenTypeRound1 } from "@/engine/deprecated/erc20SubTypeProcessors/subtypesRound1";
-import { getTokenTypeRound2 } from "@/engine/deprecated/erc20SubTypeProcessors/subtypesRound2";
-import { getTokenTypeRound3 } from "@/engine/deprecated/erc20SubTypeProcessors/subtypesRound3";
-import { getTokenTypeRound4 } from "@/engine/deprecated/erc20SubTypeProcessors/subtypesRound4";
-import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
-import { TokenRepository } from "@/modules/v4/token/token.repository";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { parseDistributionType } from "@/utils/parseDistributionType";
-import { Pricer } from "@/utils/pricer";
-import { DistributionType } from "@db/api";
-import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainId, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
-import { getFixedApr } from "../utils/getFixedApr";
-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: Erc20SubType.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 apr = (priceRewardToken * BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) * YEAR * 100) /
-                campaign.campaignParameters.duration /
-                (whitelistedSupplyTargetToken * priceTargetToken);
-            const rewardTokens = await TokenService.findManyOrCreate([
-                { chainId: campaign.chainId, address: campaign.rewardToken },
-            ]);
-            const rewardToken = rewardTokens[0];
-            if (rewardToken.isPoint) {
-                apr = apr / 365 / 100;
-            }
-            else if (parseDistributionType(campaign.campaignParameters) !== DistributionType.DUTCH_AUCTION) {
-                apr = getFixedApr(campaign, priceRewardToken, priceTargetToken);
-            }
-            dynamicData.push({
-                ...campaign,
-                apr,
-                totalSupplyTargetToken,
-                tvl: whitelistedSupplyTargetToken * priceTargetToken,
-                displayTvl: campaign.chainId === ChainId.ETHERLINK
-                    ? tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply * priceTargetToken
-                    : undefined,
-                type: tokenTypesByCampaign[campaign.campaignId].type,
-                typeInfo: tokenTypesByCampaign[campaign.campaignId].typeInfo,
-                priceRewardToken: priceRewardToken,
-            });
-        }
-        return dynamicData;
-    }
-}

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

@@ -1,32 +0,0 @@
-import { Pricer } from "@/utils/pricer";
-import { BN2Number, ChainInteractionService, ERC20Interface, } from "@sdk";
-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/deprecated/dynamicData/implementations/EventBased.js

@@ -1,129 +0,0 @@
-import { BucketService } from "@/modules/v4/bucket/bucket.service";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { Pricer } from "@/utils/pricer";
-import { engineDbClient } from "@db";
-import { BN2Number, ChainInteractionService, NETWORK_LABELS, } from "@sdk";
-import moment from "moment";
-/**
- * Compute TVL
- * @dev important: using the most recent state save with current prices
- *      it's only an estimate
- */
-async function computeEventBasedPoolRewardsFromMostRecentStateSave(chainId, campaignID, _priceCurrency, _decimalsCurrency, computeMethod) {
-    let stateSave;
-    let blockNumber;
-    let states = {};
-    try {
-        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
-        const id = `EventBasedProcessor_${computeMethod}_${chainId}_${campaignID}`;
-        let mostRecentStateSave = await engineDbClient.stateSave.findFirst({
-            where: {
-                id: id,
-                blockNumber: {
-                    lte: currentBlock,
-                },
-            },
-            orderBy: {
-                blockNumber: "desc",
-            },
-        });
-        if (!mostRecentStateSave) {
-            const historicalId = `EventBasedProcessor_${chainId}_${campaignID}`;
-            mostRecentStateSave = await engineDbClient.stateSave.findFirst({
-                where: {
-                    id: historicalId,
-                    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 distributedRewards = 0;
-    if (!fileName || !bucketName) {
-        return { distributedRewards, blockNumber: blockNumber };
-    }
-    try {
-        const bucket = new BucketService("merkl-production-states", "merkl-production");
-        const storedStates = JSON.parse(await bucket.pull(fileName));
-        for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
-            distributedRewards += BN2Number(value.allTimeValue, 18);
-        }
-        distributedRewards = distributedRewards === 0 ? 1 : distributedRewards;
-    }
-    catch {
-        log.warn(`merklDynamic data - failed to decode state of event based on ${NETWORK_LABELS[chainId]}`);
-    }
-    return { distributedRewards, 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 { distributedRewards } = await computeEventBasedPoolRewardsFromMostRecentStateSave(chainId, campaign.campaignId, priceToken, decimalsCurrency0, campaign.campaignParameters.computeScoreParameters.computeMethod);
-                const c = campaign;
-                const amount = BN2Number(c.amount, c.campaignParameters.decimalsRewardToken);
-                const multiplier = 1;
-                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);
-                const rewardTokens = await TokenService.findManyOrCreate([
-                    { chainId: campaign.chainId, address: campaign.rewardToken },
-                ]);
-                const rewardToken = rewardTokens[0];
-                const tvl = distributedRewards / multiplier;
-                if (isLive) {
-                    /** Yearly rewards in $ */
-                    let fixRewardRate = multiplier * priceRewardToken;
-                    if (distributedRewards > (amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp)) {
-                        fixRewardRate =
-                            (fixRewardRate * amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp) / tvl;
-                    }
-                    distributionMeanAPR = fixRewardRate * 365 * 100;
-                    distributionMeanAPR = !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
-                    if (rewardToken.isPoint) {
-                        distributionMeanAPR = distributionMeanAPR / 365 / 100;
-                    }
-                    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/deprecated/dynamicData/implementations/Hyperdrive.js

@@ -1,112 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { Pricer } from "@/utils/pricer";
-import { BN2Number, Campaign, ChainInteractionService, ETH_ADDRESS, HyperDriveSubCampaignType, HyperdriveTargetInterface, YEAR, } from "@sdk";
-export class HyperdriveDynamicData {
-    async build(chainId, campaigns) {
-        const pricer = await Pricer.load();
-        const calls = [];
-        for (const campaign of campaigns) {
-            calls.push({
-                allowFailure: false,
-                callData: HyperdriveTargetInterface.encodeFunctionData("getPoolInfo"),
-                target: campaign.campaignParameters.targetToken,
-            }, {
-                allowFailure: false,
-                callData: HyperdriveTargetInterface.encodeFunctionData("getPoolConfig"),
-                target: campaign.campaignParameters.targetToken,
-            });
-        }
-        const result = await ChainInteractionService(chainId).fetchState(calls);
-        let i = 0;
-        const dynamicData = [];
-        for (const campaign of campaigns) {
-            try {
-                const poolInfo = HyperdriveTargetInterface.decodeFunctionResult("getPoolInfo", result[i].returnData)[0];
-                const poolConfig = HyperdriveTargetInterface.decodeFunctionResult("getPoolConfig", result[i + 1].returnData)[0];
-                // const priceRewardToken =
-                //   (await pricer.get({
-                //     address: campaign.rewardToken,
-                //     chainId,
-                //     symbol: campaign.campaignParameters.symbolRewardToken,
-                //   })) ?? 0;
-                const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
-                const lpSupply = BN2Number(poolInfo.lpTotalSupply, 18);
-                const longSupply = BN2Number(poolInfo.longsOutstanding, 18);
-                const shortSupply = BN2Number(poolInfo.shortsOutstanding, 18);
-                const marketSupply = lpSupply * BN2Number(poolInfo.lpSharePrice, 18);
-                const priceBaseToken = (poolConfig.baseToken === ETH_ADDRESS
-                    ? await pricer.get({
-                        chainId,
-                        symbol: "ETH",
-                    })
-                    : await pricer.get({
-                        address: campaign.campaignParameters.baseToken,
-                        chainId,
-                        symbol: campaign.campaignParameters.baseTokenSymbol,
-                    })) ?? 0;
-                let multiplier = 1;
-                if (campaign.campaignType === Campaign.HYPERDRIVELOGPROCESSOR) {
-                    const spot_price = ((BN2Number(poolConfig.initialVaultSharePrice, 18) *
-                        (BN2Number(poolInfo.shareReserves, 18) - BN2Number(poolInfo.shareAdjustment, 18))) /
-                        BN2Number(poolInfo.bondReserves)) **
-                        BN2Number(poolConfig.timeStretch);
-                    if (spot_price < 1) {
-                        multiplier = 1 / (1 - spot_price);
-                    }
-                }
-                const tvl = campaign.campaignSubType === HyperDriveSubCampaignType.LP
-                    ? priceBaseToken * marketSupply
-                    : campaign.campaignSubType === HyperDriveSubCampaignType.LONG
-                        ? priceBaseToken * longSupply
-                        : (priceBaseToken * shortSupply) / multiplier;
-                let apr = priceRewardToken !== 0
-                    ? (priceRewardToken *
-                        BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                        YEAR *
-                        100) /
-                        campaign.campaignParameters.duration /
-                        tvl
-                    : 0;
-                const rewardTokens = await TokenService.findManyOrCreate([
-                    { chainId: campaign.chainId, address: campaign.rewardToken },
-                ]);
-                const rewardToken = rewardTokens[0];
-                apr = rewardToken.isPoint ? apr / 365 / 100 : apr;
-                dynamicData.push({
-                    ...campaign,
-                    totalSupplyTargetToken: marketSupply,
-                    tvl: tvl,
-                    apr,
-                    priceRewardToken: priceRewardToken,
-                });
-            }
-            catch (e) {
-                dynamicData.push({
-                    ...campaign,
-                    totalSupplyTargetToken: 0,
-                    tvl: 0,
-                    apr: 0,
-                    priceRewardToken: 0,
-                });
-                console.error(e);
-            }
-            i += 2;
-        }
-        return dynamicData;
-    }
-}
-// enum AssetIdPrefix {
-//   LP = 0,
-//   Long = 1,
-//   Short = 2,
-//   WithdrawalShare = 3,
-// }
-// function encodeAssetId(prefix: AssetIdPrefix, timestamp: bigint): bigint {
-//   // Check if the timestamp is within the valid range
-//   const maxTimestamp = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-//   if (timestamp > maxTimestamp) {
-//     throw new Error("InvalidTimestamp");
-//   }
-//   // Encode the asset ID
-//   return (BigInt(prefix) << BigInt(248)) | timestamp;
-// }

package/dist/src/engine/deprecated/dynamicData/implementations/Morpho.js

@@ -1,132 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { Pricer } from "@/utils/pricer";
-import { BN2Number, ChainInteractionService, MetamorphoInterface, MorphoSubCampaignType, YEAR, morphoAddresses, } from "@sdk";
-import axios from "axios";
-import { utils } from "ethers";
-import { zeroAddress } from "viem";
-// TODO add the ABI
-const MORPHO_ABI = [
-    "function position(bytes32,address) external view returns (uint256,uint128,uint128)",
-    "function market(bytes32) external view returns (uint128,uint128,uint128,uint128,uint128,uint128)",
-];
-export const MORPHO_INTERFACE = new utils.Interface(MORPHO_ABI);
-export class MorphoDynamicData {
-    async build(chainId, campaigns) {
-        const pricer = await Pricer.load();
-        const calls = [];
-        const endpoint = "https://blue-api.morpho.org/graphql";
-        const headers = {
-            "content-type": "application/json",
-        };
-        for (const campaign of campaigns) {
-            if (campaign.campaignSubType === MorphoSubCampaignType.META) {
-                calls.push({
-                    allowFailure: true,
-                    callData: MetamorphoInterface.encodeFunctionData("totalAssets"),
-                    target: campaign.campaignParameters.targetToken,
-                }, {
-                    allowFailure: true,
-                    callData: MetamorphoInterface.encodeFunctionData("totalSupply"),
-                    target: campaign.campaignParameters.targetToken,
-                });
-            }
-            if (campaign.campaignSubType === MorphoSubCampaignType.BORROWING_BLUE ||
-                campaign.campaignSubType === MorphoSubCampaignType.SUPPLY_BLUE) {
-                calls.push({
-                    allowFailure: true,
-                    callData: MORPHO_INTERFACE.encodeFunctionData("market", [campaign.campaignParameters.marketId]),
-                    target: morphoAddresses[campaign.computeChainId] ?? zeroAddress,
-                });
-            }
-        }
-        const result = await ChainInteractionService(chainId).fetchState(calls);
-        const dynamicData = [];
-        let index = 0;
-        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);
-            let tvl = 0;
-            let totalSupplyTargetToken = 0;
-            if (campaign.campaignSubType === MorphoSubCampaignType.META) {
-                const totalAssets = BN2Number(MetamorphoInterface.decodeFunctionResult("totalAssets", result[index++].returnData)[0], campaign.campaignParameters.decimalsUnderlyingToken);
-                const totalSupply = BN2Number(MetamorphoInterface.decodeFunctionResult("totalSupply", result[index++].returnData)[0], campaign.campaignParameters.decimalsTargetToken);
-                const priceAsset = (await pricer.get({
-                    symbol: campaign.campaignParameters.symbolUnderlyingToken,
-                })) ?? 0;
-                tvl = priceAsset * totalAssets;
-                totalSupplyTargetToken = totalSupply;
-            }
-            if (campaign.campaignSubType === MorphoSubCampaignType.SUPPLY_BLUE) {
-                const totalSupplyAssets = BN2Number(MORPHO_INTERFACE.decodeFunctionResult("market", result[index++].returnData)[0], Number(campaign.campaignParameters.decimalsLoanToken));
-                const priceAsset = (await pricer.get({
-                    symbol: campaign.campaignParameters.symbolLoanToken,
-                })) ?? 0;
-                tvl = priceAsset * totalSupplyAssets;
-                totalSupplyTargetToken = totalSupplyAssets;
-            }
-            if (campaign.campaignSubType === MorphoSubCampaignType.BORROWING_BLUE) {
-                const totalBorrowAssets = BN2Number(MORPHO_INTERFACE.decodeFunctionResult("market", result[index++].returnData)[2], Number(campaign.campaignParameters.decimalsLoanToken));
-                const priceAsset = (await pricer.get({
-                    symbol: campaign.campaignParameters.symbolLoanToken,
-                })) ?? 0;
-                tvl = priceAsset * totalBorrowAssets;
-                totalSupplyTargetToken = totalBorrowAssets;
-            }
-            if (campaign.campaignSubType === MorphoSubCampaignType.COLLATERAL_BLUE) {
-                const graphqlQueryMarket = {
-                    query: `query MarketByUniqueKey($uniqueKey: String!, $chainId: Int) {
-              marketByUniqueKey(uniqueKey: $uniqueKey, chainId: $chainId) {
-                state {
-                  borrowAssetsUsd
-                  borrowAssets
-                  collateralAssets
-                  collateralAssetsUsd
-                  supplyAssets
-                  supplyAssetsUsd
-                }
-              }
-            }
-            `,
-                    variables: {
-                        uniqueKey: campaign.campaignParameters.marketId,
-                        chainId: campaign.computeChainId,
-                    },
-                };
-                try {
-                    const response = await axios({
-                        url: endpoint,
-                        method: "post",
-                        headers: headers,
-                        data: graphqlQueryMarket,
-                    });
-                    tvl = response.data.data.marketByUniqueKey.state.collateralAssetsUsd;
-                    totalSupplyTargetToken = response.data.data.marketByUniqueKey.state.collateralAssets;
-                }
-                catch (e) {
-                    console.log(e);
-                }
-            }
-            let apr = (priceRewardToken * BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) * YEAR * 100) /
-                campaign.campaignParameters.duration /
-                tvl;
-            const rewardTokens = await TokenService.findManyOrCreate([
-                { chainId: campaign.chainId, address: campaign.rewardToken },
-            ]);
-            const rewardToken = rewardTokens[0];
-            apr = rewardToken.isPoint ? apr / 365 / 100 : apr;
-            dynamicData.push({
-                ...campaign,
-                apr,
-                totalSupplyTargetToken,
-                tvl: tvl,
-                priceRewardToken: priceRewardToken,
-            });
-        }
-        return dynamicData;
-    }
-}