@merkl/api 0.21.46 → 1.0.0

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

@@ -1,60 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { TvlType } from "@db/api";
-import { ChainInteractionService, EigenLayerStrategyInterface, bigIntToNumber, } from "@sdk";
-export class EigenLayerTVLBuilder {
-    async build(computeChainId, campaigns) {
-        const tvls = [];
-        const firstRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
-            const { campaignId, campaignParameters } = campaign;
-            const { strategy } = campaignParameters;
-            return [
-                {
-                    callData: EigenLayerStrategyInterface.encodeFunctionData("totalShares"),
-                    target: strategy,
-                    key: `${campaignId}_totalShares`,
-                    decoder: (data) => BigInt(EigenLayerStrategyInterface.decodeFunctionResult("totalShares", data)[0].toString()),
-                },
-            ];
-        }));
-        const secondRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
-            const { campaignId, campaignParameters } = campaign;
-            const { strategy } = campaignParameters;
-            let totalShares = firstRound[`${campaignId}_totalShares`];
-            if (!totalShares) {
-                log.warn(`Error getting totalShares for campaign ${campaign.campaignId} and strategy ${campaign.campaignParameters.strategy}`);
-                totalShares = 10n;
-            }
-            return [
-                {
-                    callData: EigenLayerStrategyInterface.encodeFunctionData("sharesToUnderlying", [totalShares]),
-                    target: strategy,
-                    key: `${campaignId}_totalUnderlying`,
-                    decoder: (data) => BigInt(EigenLayerStrategyInterface.decodeFunctionResult("sharesToUnderlying", data)[0].toString()),
-                },
-            ];
-        }));
-        for (const campaign of campaigns) {
-            const { campaignId, campaignParameters } = campaign;
-            const { underlyingToken: underlyingTokenAddress } = campaignParameters;
-            const totalUnderlying = secondRound[`${campaignId}_totalUnderlying`];
-            // We don't fetch token data everytime, we use the database and the associated service
-            const underlyingToken = await TokenService.findUniqueFillOrThrow({
-                chainId: computeChainId,
-                address: underlyingTokenAddress,
-            });
-            tvls.push({
-                campaign,
-                tvl: (bigIntToNumber(totalUnderlying, underlyingToken.decimals) ?? 0) * (underlyingToken.price ?? 0),
-                tvlBreakdown: [
-                    {
-                        identifier: underlyingToken.id,
-                        type: TvlType.TOKEN,
-                        value: bigIntToNumber(totalUnderlying, underlyingToken.decimals),
-                    },
-                ],
-            });
-        }
-        return tvls;
-    }
-}

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

@@ -1,43 +0,0 @@
-import { protocolIdList } from "@/modules/v4/protocol/protocol.model";
-import { log } from "@/utils/logger";
-import { OpportunityAction } from "@db/api";
-export class EncompassingMetadata {
-    async build(campaign) {
-        const { params, computeChainId, rewardToken } = campaign;
-        try {
-            const dataResponse = await fetch(params.dataUrl);
-            if (!dataResponse.ok)
-                throw new Error(`Response status: ${dataResponse.status}`);
-            const data = await dataResponse.json();
-            if (!protocolIdList.includes(data.mainProtocol)) {
-                log.warn(`unknown Protocol ID: ${data.mainProtocol}`);
-                data.mainProtocol = undefined;
-            }
-            return {
-                action: OpportunityAction.DROP,
-                name: data.opportunityName ?? `Distribution of ${params.symbolRewardToken}`,
-                tokens: [
-                    {
-                        chainId: computeChainId,
-                        address: rewardToken.address,
-                    },
-                ],
-                mainProtocol: data.mainProtocol ?? undefined,
-            };
-        }
-        catch (err) {
-            log.error("failed to fetch data from dataUrl", err);
-            return {
-                action: OpportunityAction.DROP,
-                name: `Distribution of ${params.symbolRewardToken}`,
-                tokens: [
-                    {
-                        chainId: computeChainId,
-                        address: rewardToken.address,
-                    },
-                ],
-                mainProtocol: undefined,
-            };
-        }
-    }
-}

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

@@ -1,64 +0,0 @@
-import { Erc20DynamicData } from "@/engine/deprecated/dynamicData/implementations/Erc20";
-import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
-import { log } from "@/utils/logger";
-import { Campaign as CampaignType } from "@sdk";
-import { getAddress } from "viem";
-import { ProtocolService } from "../../../modules/v4/protocol/protocol.service";
-import { detectSubType } from "./subTypes/detect";
-import { erc20SubTypeMetadataBuilderFactory } from "./subTypes/factories";
-export class Erc20Metadata {
-    async build(campaign, opportunityIdentifier) {
-        const { params, computeChainId, campaignId, rewardToken, distributionChainId, type } = campaign;
-        const [subType] = await detectSubType(computeChainId, [
-            OpportunityConvertorService.convertV4CampaignToV3(CampaignType[type], campaign, opportunityIdentifier),
-        ]);
-        log.info(`building metadata for subtype ${subType}`);
-        const builder = erc20SubTypeMetadataBuilderFactory(subType);
-        if (!!builder) {
-            return builder.build(campaign, opportunityIdentifier);
-        }
-        // @deprecated
-        let action = "HOLD";
-        let name = `Hold ${params.symbolTargetToken}`;
-        let mainProtocolId = undefined;
-        const depositUrl = params?.url;
-        let tokens = [{ chainId: computeChainId, address: params.targetToken }];
-        try {
-            const [dynamicData] = await new Erc20DynamicData().build(computeChainId, [
-                {
-                    campaignId,
-                    rewardToken: rewardToken.address,
-                    amount: "1",
-                    chainId: distributionChainId,
-                    computeChainId,
-                    campaignParameters: params,
-                },
-            ]);
-            tokens = dynamicData?.typeInfo?.tokensDisplay?.map((token) => ({
-                chainId: computeChainId,
-                address: token.address,
-            }));
-            action = dynamicData?.typeInfo?.action ?? action;
-            name = dynamicData?.typeInfo?.cardName;
-            mainProtocolId = dynamicData?.typeInfo?.protocol?.toLowerCase().replace(" ", "");
-            const protocol = !!mainProtocolId ? await ProtocolService.findUnique(mainProtocolId) : undefined;
-            if (!!protocol) {
-                mainProtocolId = protocol?.id;
-            }
-        }
-        catch {
-            log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
-        }
-        if (mainProtocolId === "unknown") {
-            mainProtocolId = undefined;
-        }
-        return {
-            action,
-            name,
-            tokens,
-            mainProtocol: mainProtocolId,
-            depositUrl,
-            explorerAddress: getAddress(params.targetToken),
-        };
-    }
-}

package/dist/src/engine/implementations/Erc20/subTypes/detect.js

@@ -1,170 +0,0 @@
-import { getTypeFromFactoryAddress } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/factoryFinder";
-import { getTypeFromAddressChain } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/hardcoded";
-import { getTypeFromOwnerAddress } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/ownerFinder";
-import { getTypeFromTreasuryAddress } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/treasuryFinder";
-import { processNamingConditionsInOrder } from "@/engine/deprecated/erc20SubTypeProcessors/subtypesRound1";
-import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
-import { decodeReturnValue } from "@/utils/decodeCalls";
-import { log } from "@/utils/logger";
-import { BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, IonPoolInterface, LayerBankERC20Interface, MetamorphoInterface, } from "@sdk";
-/**
- * @notice Compute the subtypes of the campaigns
- * @warning
- * @dev This function should return an array of length campaigns.length
- */
-export const detectSubType = async (chainId, campaigns) => {
-    // 1. Do a generic multicall per campaign to see which functions are supported
-    const detectionCalls = await ChainInteractionService(chainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
-        const { targetToken } = campaign.campaignParameters;
-        return [
-            {
-                callData: FactoryInterface.encodeFunctionData("factory"),
-                target: targetToken,
-                key: `${campaign.campaignId}_factory`,
-                decoder: (data) => FactoryInterface.decodeFunctionResult("factory", data)[0],
-            },
-            {
-                callData: MetamorphoInterface.encodeFunctionData("MORPHO"),
-                target: targetToken,
-                key: `${campaign.campaignId}_metamorpho`,
-                decoder: (data) => MetamorphoInterface.decodeFunctionResult("MORPHO", data)[0],
-            },
-            {
-                callData: ERC20Interface.encodeFunctionData("name"),
-                target: targetToken,
-                key: `${campaign.campaignId}_name`,
-                decoder: (data) => ERC20Interface.decodeFunctionResult("name", data)[0],
-            },
-            {
-                callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
-                target: targetToken,
-                key: `${campaign.campaignId}_getPoolId`,
-                decoder: (data) => BalancerPoolInterface.decodeFunctionResult("getPoolId", data)[0],
-            },
-            {
-                callData: EnzymeInterface.encodeFunctionData("getCreator"),
-                target: targetToken,
-                key: `${campaign.campaignId}_getCreator`,
-                decoder: (data) => EnzymeInterface.decodeFunctionResult("getCreator", data)[0],
-            },
-            {
-                callData: LayerBankERC20Interface.encodeFunctionData("owner"),
-                target: targetToken,
-                key: `${campaign.campaignId}_owner`,
-                decoder: (data) => LayerBankERC20Interface.decodeFunctionResult("owner", data)[0],
-            },
-            {
-                callData: BalancerV3StablePoolInterface.encodeFunctionData("getVault"),
-                target: targetToken,
-                key: `${campaign.campaignId}_getVault`,
-                decoder: (data) => BalancerV3StablePoolInterface.decodeFunctionResult("getVault", data)[0],
-            },
-            {
-                callData: IonPoolInterface.encodeFunctionData("treasury"),
-                target: targetToken,
-                key: `${campaign.campaignId}_treasury`,
-                decoder: (data) => IonPoolInterface.decodeFunctionResult("treasury", data)[0],
-            },
-            {
-                callData: "0x038f6f61", // Factory call for Pinto protocol
-                target: targetToken,
-                key: `${campaign.campaignId}_pinto`,
-                decoder: (data) => FactoryInterface.decodeFunctionResult("factory", data)[0],
-            },
-        ];
-    }));
-    for (const key of Object.keys(detectionCalls)) {
-        log.local(`detection call ${key}: ${detectionCalls[key]}`);
-    }
-    // 2. Decode result from the multicalls and using try catch, try to interprete the result
-    const res = [];
-    for (const campaign of campaigns) {
-        const { targetToken } = campaign.campaignParameters;
-        const factory = detectionCalls[`${campaign.campaignId}_factory`];
-        const metamorpho = detectionCalls[`${campaign.campaignId}_metamorpho`];
-        const name = detectionCalls[`${campaign.campaignId}_name`];
-        const poolId = detectionCalls[`${campaign.campaignId}_getPoolId`];
-        const vault = detectionCalls[`${campaign.campaignId}_getVault`];
-        const creator = detectionCalls[`${campaign.campaignId}_getCreator`];
-        const owner = detectionCalls[`${campaign.campaignId}_owner`];
-        const treasury = detectionCalls[`${campaign.campaignId}_treasury`];
-        const pintoFactory = detectionCalls[`${campaign.campaignId}_pinto`];
-        // Get erc20SubType from factory address
-        if (!!factory || !!creator || !!pintoFactory) {
-            try {
-                const type = getTypeFromFactoryAddress((factory ?? creator ?? pintoFactory));
-                if (type !== Erc20SubType.unknown) {
-                    res.push(type);
-                    continue;
-                }
-            }
-            catch { }
-        }
-        // Get erc20SubType from treasury address
-        if (!!treasury) {
-            try {
-                const type = getTypeFromTreasuryAddress(treasury);
-                if (type !== Erc20SubType.unknown) {
-                    res.push(type);
-                    continue;
-                }
-            }
-            catch { }
-        }
-        // Get erc20SubType from owner address
-        if (!!owner) {
-            try {
-                const type = getTypeFromOwnerAddress(owner);
-                if (type !== Erc20SubType.unknown) {
-                    res.push(type);
-                    continue;
-                }
-            }
-            catch { }
-        }
-        // Get erc20SubType from address
-        try {
-            const type = getTypeFromAddressChain(chainId, targetToken);
-            if (type !== Erc20SubType.unknown) {
-                res.push(type);
-                continue;
-            }
-        }
-        catch { }
-        // Get erc20SubType for morpho
-        if (!!metamorpho) {
-            try {
-                decodeReturnValue(metamorpho, "MORPHO");
-                res.push(Erc20SubType.metamorpho);
-                continue;
-            }
-            catch { }
-        }
-        // Starting from this point, assume the name is working
-        try {
-            // Get erc20SubType for balancer
-            if (!!poolId) {
-                res.push(Erc20SubType.balancerPool);
-                continue;
-            }
-            if (!!vault) {
-                res.push(Erc20SubType.balancerPool);
-                continue;
-            }
-            // Get erc20SubType by parsing information from the erc20 name
-            if (!!name) {
-                const typeInfoFromName = processNamingConditionsInOrder(name, targetToken, campaign);
-                if (!!typeInfoFromName) {
-                    res.push(typeInfoFromName.type);
-                    continue;
-                }
-            }
-        }
-        catch { }
-        // Default
-        res.push(Erc20SubType.unknown);
-    }
-    if (res.length !== campaigns.length)
-        throw new Error("computeSubTypes: res.length !== campaigns.length");
-    return res;
-};

package/dist/src/engine/implementations/Erc20/subTypes/factories.js

@@ -1,69 +0,0 @@
-import { Erc20SubType } from ".";
-import { AaveMetadata } from "./implementations/aave/metadata";
-import { AaveTVLBuilder } from "./implementations/aave/tvl";
-import { EulerMetadata } from "./implementations/euler/metadata";
-import { EulerTVLBuilder } from "./implementations/euler/tvl";
-import { GearboxMetadata } from "./implementations/gearbox/metadata";
-import { GearboxTVLBuilder } from "./implementations/gearbox/tvl";
-import { HypurrFiIsolatedMarketMetadata } from "./implementations/hypurrfiIsolatedMarket/metadata";
-import { HypurrFiIsolatedMarketTVLBuilder } from "./implementations/hypurrfiIsolatedMarket/tvl";
-import { LendleMetadata } from "./implementations/lendleVaults/metadata";
-import { LendleTVLBuilder } from "./implementations/lendleVaults/tvl";
-import { PinoMetadata } from "./implementations/pino/metadata";
-import { PinoTVLBuilder } from "./implementations/pino/tvl";
-import { TermMaxMetadata } from "./implementations/termmax/metadata";
-import { TermMaxTVLBuilder } from "./implementations/termmax/tvl";
-import { UniswapV2Metadata } from "./implementations/uniswapV2/metadata";
-import { UniswapV2TVLBuilder } from "./implementations/uniswapV2/tvl";
-/**
- * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
- *
- * @dev Casts are made to enforce type safety
- * @dev A type error must be thrown if a new erc20Subtype is added and the corresponding builder is not implemented
- */
-const tvlMap = {
-    [Erc20SubType.gearbox]: new GearboxTVLBuilder(),
-    [Erc20SubType.superlend_borrowing]: new AaveTVLBuilder(),
-    [Erc20SubType.superlend_lending]: new AaveTVLBuilder(),
-    [Erc20SubType.euler_borrow]: new EulerTVLBuilder(),
-    [Erc20SubType.euler_lend]: new EulerTVLBuilder(),
-    [Erc20SubType.lendle_vaults]: new LendleTVLBuilder(),
-    [Erc20SubType.termmax]: new TermMaxTVLBuilder(),
-    [Erc20SubType.dlend_lending]: new AaveTVLBuilder(),
-    [Erc20SubType.dlend_borrowing]: new AaveTVLBuilder(),
-    [Erc20SubType.pinto]: new PinoTVLBuilder(),
-    [Erc20SubType.katana]: new UniswapV2TVLBuilder(),
-    [Erc20SubType.hypurrfi_isolated_market]: new HypurrFiIsolatedMarketTVLBuilder(),
-};
-export const erc20SubTypeTVLBuilderFactory = (erc20Subtype) => {
-    if (!tvlMap[erc20Subtype]) {
-        return null;
-    }
-    return tvlMap[erc20Subtype];
-};
-/**
- * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
- *
- * @dev Casts are made to enforce type safety
- * @dev A type error must be thrown if a new erc20Subtype is added and the corresponding builder is not implemented
- */
-const metadataMap = {
-    [Erc20SubType.gearbox]: new GearboxMetadata(),
-    [Erc20SubType.superlend_borrowing]: new AaveMetadata("superlend", "Superlend", (underlyingToken) => `https://markets.superlend.xyz/reserve-overview/?underlyingAsset=${underlyingToken}`),
-    [Erc20SubType.superlend_lending]: new AaveMetadata("superlend", "Superlend", (underlyingToken) => `https://markets.superlend.xyz/reserve-overview/?underlyingAsset=${underlyingToken}`),
-    [Erc20SubType.euler_borrow]: new EulerMetadata(),
-    [Erc20SubType.euler_lend]: new EulerMetadata(),
-    [Erc20SubType.lendle_vaults]: new LendleMetadata(),
-    [Erc20SubType.termmax]: new TermMaxMetadata(),
-    [Erc20SubType.dlend_lending]: new AaveMetadata("dlend", "dTrinity dLend", (underlyingToken) => `https://app.dtrinity.org/dlend/reserve-overview/?underlyingAsset=${underlyingToken}`),
-    [Erc20SubType.dlend_borrowing]: new AaveMetadata("dlend", "dTrinity dLend", (underlyingToken) => `https://app.dtrinity.org/dlend/reserve-overview/?underlyingAsset=${underlyingToken}`),
-    [Erc20SubType.pinto]: new PinoMetadata(),
-    [Erc20SubType.katana]: new UniswapV2Metadata("katana", "Katana"),
-    [Erc20SubType.hypurrfi_isolated_market]: new HypurrFiIsolatedMarketMetadata("hypurrfi", "HypurrFi", (underlyingToken) => `https://app.hypurr.fi/markets/isolated/999/${underlyingToken}`),
-};
-export const erc20SubTypeMetadataBuilderFactory = (erc20Subtype) => {
-    if (!metadataMap[erc20Subtype]) {
-        return null;
-    }
-    return metadataMap[erc20Subtype];
-};

package/dist/src/engine/implementations/Erc20/subTypes/implementations/aave/metadata.js

@@ -1,46 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { OpportunityAction } from "@db/api";
-import { Aave__factory, ChainInteractionService, TokenInteractionService } from "@sdk";
-export class AaveMetadata {
-    /**
-     *  @notice Protocol entity ID - must be defined in the corresponding file and created in DB
-     */
-    mainProtocol;
-    /**
-     *  @notice Protocol name - used to create the opportunity name
-     */
-    protocolName;
-    /**
-     *  @notice Function to generate the deposit URL for the opportunity
-     */
-    depositUrl;
-    constructor(mainProtocol, protocolName, depositUrl) {
-        this.mainProtocol = mainProtocol;
-        this.protocolName = protocolName;
-        this.depositUrl = depositUrl;
-    }
-    async build(campaign, _opportunityIdentifier) {
-        const { params, computeChainId } = campaign;
-        const { targetToken } = params;
-        const targetTokenInfo = await TokenService.fetchOnChain({
-            chainId: computeChainId,
-            address: targetToken,
-        });
-        const underlyingToken = await Aave__factory.connect(targetToken, ChainInteractionService(computeChainId).provider()).UNDERLYING_ASSET_ADDRESS();
-        const underlyingTokenSymbol = await TokenInteractionService(computeChainId).symbol(underlyingToken);
-        const action = targetTokenInfo?.name?.toLowerCase().includes("debt")
-            ? OpportunityAction.BORROW
-            : OpportunityAction.LEND;
-        return {
-            action,
-            mainProtocol: this.mainProtocol,
-            name: `${action === OpportunityAction.BORROW ? "Borrow" : "Supply"} ${underlyingTokenSymbol} on ${this.protocolName}`,
-            tokens: [
-                { chainId: computeChainId, address: targetToken },
-                { chainId: computeChainId, address: underlyingToken },
-            ],
-            depositUrl: this.depositUrl(underlyingToken),
-            explorerAddress: params.targetToken,
-        };
-    }
-}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/aave/tvl.js

@@ -1,51 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { TvlType } from "@db/api";
-import { AaveInterface, ChainInteractionService, ERC20Interface, bigIntToNumber, } from "@sdk";
-export class AaveTVLBuilder {
-    async build(computeChainId, campaigns) {
-        const tvls = [];
-        const firstRound = await ChainInteractionService(computeChainId).fetchAndDecodeObject(campaigns.flatMap(campaign => {
-            const { campaignId, campaignParameters } = campaign;
-            const { targetToken } = campaignParameters;
-            return [
-                {
-                    callData: AaveInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
-                    target: targetToken,
-                    key: `${campaignId}_underlyingToken`,
-                    decoder: (data) => AaveInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", data)[0],
-                },
-                {
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: targetToken,
-                    key: `${campaignId}_totalSupply`,
-                    decoder: (data) => BigInt(ERC20Interface.decodeFunctionResult("totalSupply", data)[0].toString()),
-                },
-            ];
-        }));
-        for (const campaign of campaigns) {
-            const { campaignId } = campaign;
-            const underlyingTokenAddress = firstRound[`${campaignId}_underlyingToken`];
-            const totalSupply = firstRound[`${campaignId}_totalSupply`];
-            // We don't fetch token data everytime, we use the database and the associated service
-            const underlyingToken = await TokenService.findUniqueFillOrThrow({
-                chainId: computeChainId,
-                address: underlyingTokenAddress,
-            });
-            if (!underlyingToken.decimals || !underlyingToken.price) {
-                throw new Error(`Missing decimals or price for token ${underlyingToken.address}`);
-            }
-            tvls.push({
-                campaign,
-                tvl: bigIntToNumber(totalSupply, underlyingToken.decimals) * underlyingToken.price,
-                tvlBreakdown: [
-                    {
-                        identifier: underlyingToken.id,
-                        type: TvlType.TOKEN,
-                        value: bigIntToNumber(totalSupply, underlyingToken.decimals),
-                    },
-                ],
-            });
-        }
-        return tvls;
-    }
-}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/euler/metadata.js

@@ -1,35 +0,0 @@
-import { fetchEulerVaultName } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/eulerVaultNames";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { sanitizeChainName } from "@/utils/sanitizeChain";
-import { OpportunityAction } from "@db/api";
-import { ChainInteractionService, EulerSubCampaignType, Euler__factory } from "@sdk";
-export class EulerMetadata {
-    async build(campaign, _opportunityIdentifier) {
-        const { params, computeChainId, subType } = campaign;
-        let { targetToken, addressAsset: underlyingToken, symbolCollateral, evkAddress } = params;
-        if (!underlyingToken)
-            underlyingToken = await Euler__factory.connect(targetToken, ChainInteractionService(computeChainId).provider()).asset();
-        const underlyingTokenInfo = await TokenService.findUniqueFillOrThrow({
-            chainId: computeChainId,
-            address: underlyingToken,
-        });
-        let vaultName = await fetchEulerVaultName(underlyingToken, computeChainId);
-        if (!vaultName)
-            vaultName = await fetchEulerVaultName(evkAddress, computeChainId);
-        const action = subType === EulerSubCampaignType.BORROW_FROM_COLLATERAL || subType === EulerSubCampaignType.BORROW
-            ? OpportunityAction.BORROW
-            : OpportunityAction.LEND;
-        const name = `${action === OpportunityAction.LEND ? `Supply ${underlyingTokenInfo.symbol} on` : "Borrow from"}${vaultName ? ` ${vaultName}` : ""} vault ${subType === EulerSubCampaignType.BORROW_FROM_COLLATERAL ? `using ${symbolCollateral}` : ""}`;
-        return {
-            action,
-            mainProtocol: "euler",
-            name,
-            tokens: [
-                { chainId: computeChainId, address: targetToken },
-                { chainId: computeChainId, address: underlyingToken },
-            ],
-            depositUrl: `https://app.euler.finance/vault/${evkAddress}?network=${sanitizeChainName(computeChainId)}`,
-            explorerAddress: params.targetToken,
-        };
-    }
-}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/euler/tvl.js

@@ -1,59 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { TvlType } from "@db/api";
-import { BN2Number, ChainInteractionService, EulerEVKInterface, EulerSubCampaignType, bigIntToNumber, } from "@sdk";
-export class EulerTVLBuilder {
-    async build(computeChainId, campaigns) {
-        const tvls = [];
-        const calls = [];
-        for (const campaign of campaigns) {
-            const { campaignParameters, campaignId } = campaign;
-            const { evkAddress, subCampaignType } = campaignParameters;
-            if (subCampaignType === EulerSubCampaignType.LEND) {
-                calls.push({
-                    callData: EulerEVKInterface.encodeFunctionData("totalAssets"),
-                    target: evkAddress,
-                    key: `totalUnderlying_${campaignId}`,
-                    decoder: (data) => BigInt(EulerEVKInterface.decodeFunctionResult("totalAssets", data)[0].toString()),
-                });
-            }
-            else {
-                calls.push({
-                    callData: EulerEVKInterface.encodeFunctionData("totalBorrows"),
-                    target: evkAddress,
-                    key: `totalUnderlying_${campaignId}`,
-                    decoder: (data) => BigInt(EulerEVKInterface.decodeFunctionResult("totalBorrows", data)[0].toString()),
-                });
-            }
-        }
-        const result = await ChainInteractionService(computeChainId).fetchAndDecodeObject(calls);
-        for (const [_, campaign] of campaigns.entries()) {
-            const { campaignId } = campaign;
-            const totalAssets = result[`totalUnderlying_${campaignId}`];
-            const underlylingTokenAddress = campaign.campaignParameters.addressAsset;
-            const underlyingToken = await TokenService.findUniqueFillOrThrow({
-                chainId: computeChainId,
-                address: underlylingTokenAddress,
-            });
-            if (!underlyingToken.decimals || !underlyingToken.price) {
-                throw new Error(`Missing decimals or price for token ${underlylingTokenAddress}`);
-            }
-            let tvl = bigIntToNumber(totalAssets, underlyingToken.decimals) * underlyingToken.price;
-            // If TVL is zero, set to 0.01
-            if (tvl === 0) {
-                tvl = 0.01;
-            }
-            tvls.push({
-                campaign,
-                tvl,
-                tvlBreakdown: [
-                    {
-                        identifier: underlyingToken.id,
-                        type: TvlType.TOKEN,
-                        value: BN2Number(totalAssets, underlyingToken.decimals),
-                    },
-                ],
-            });
-        }
-        return tvls;
-    }
-}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/gearbox/metadata.js

@@ -1,21 +0,0 @@
-import { OpportunityAction } from "@db/api";
-import { ChainInteractionService, GearBoxVault__factory, TokenInteractionService } from "@sdk";
-export class GearboxMetadata {
-    async build(campaign, _opportunityIdentifier) {
-        const { params, computeChainId } = campaign;
-        const { targetToken } = params;
-        const underlyingToken = await GearBoxVault__factory.connect(targetToken, ChainInteractionService(computeChainId).provider()).underlyingToken();
-        const underlyingTokenSymbol = await TokenInteractionService(computeChainId).symbol(underlyingToken);
-        return {
-            action: OpportunityAction.LEND,
-            mainProtocol: "gearbox",
-            name: `Gearbox ${underlyingTokenSymbol} Deposit`,
-            tokens: [
-                { chainId: computeChainId, address: targetToken },
-                { chainId: computeChainId, address: underlyingToken },
-            ],
-            depositUrl: `https://app.gearbox.fi/pools/${params.targetToken}`,
-            explorerAddress: params.targetToken,
-        };
-    }
-}