@merkl/api 0.10.129 → 0.10.130

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesPrices.js

@@ -0,0 +1,583 @@
+import { BN2Number, ERC20Interface } from "@sdk";
+import { utils } from "ethers";
+import { fetchEulerVaultName } from "./helpers/eulerVaultNames";
+import { getBlacklistedSupply, getWhitelistedSupply } from "./helpers/getBlacklistedSupply";
+import { fetchMetamorphoTvl } from "./helpers/metamorphoTvl";
+import { fetchSpliceInformation } from "./helpers/spliceTVL";
+import { tokenType } from "./helpers/tokenType";
+import { eulerInterface, torosInterface } from "./subtypesRound1";
+export async function getTokenPricesInfo(index, type, typeInfo, calls, campaign, pricer) {
+    if (type === tokenType.uniswapv2 ||
+        type === tokenType.poolside ||
+        type === tokenType.aerodrome ||
+        type === tokenType.velodrome ||
+        type === tokenType.dragonswap ||
+        type === tokenType.akron) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        let tvl = 0;
+        if (priceToken0 !== 0 && priceToken1 !== 0) {
+            tvl = priceToken0 * typeInfo.balanceToken0 + priceToken1 * typeInfo.balanceToken1;
+        }
+        const priceTargetToken = tvl / BN2Number(totalSupply, 18);
+        let cardName;
+        if (type === tokenType.uniswapv2) {
+            cardName = `${typeInfo.protocol} ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        }
+        else if (type === tokenType.poolside) {
+            cardName = `Poolside ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        }
+        else if (type === tokenType.aerodrome) {
+            cardName = `Aerodrome ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        }
+        else if (type === tokenType.akron) {
+            cardName = `Akron ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        }
+        else if (type === tokenType.dragonswap) {
+            cardName = `Dragonswap ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        }
+        else {
+            cardName = `Velodrome ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        }
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                priceTargetToken: priceTargetToken, // priceTargetToken is the price of the token in USD
+                totalSupply: BN2Number(totalSupply, 18),
+                tvl: tvl,
+                cardName: cardName,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.balancerGauge) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const poolTokensinfo = {};
+        let tvlUnderlyingPool = 0;
+        const symbols = [];
+        for (const poolToken of typeInfo.poolTokens) {
+            const symbol = ERC20Interface.decodeFunctionResult("symbol", calls[index++])[0];
+            const decimals = ERC20Interface.decodeFunctionResult("decimals", calls[index++])[0];
+            poolTokensinfo[poolToken.token] = {
+                symbol: symbol,
+                decimals: decimals,
+                amountInPool: BN2Number(poolToken.balance, decimals),
+                price: (await pricer.get({ symbol: symbol })) ?? 0,
+            };
+            tvlUnderlyingPool += poolTokensinfo[poolToken.token].price * poolTokensinfo[poolToken.token].amountInPool;
+            symbols.push(symbol);
+        }
+        const tvl = tvlUnderlyingPool * typeInfo.percentageOfSupplyUnderlyingPoolTokens;
+        const priceTargetToken = tvl / BN2Number(totalSupply, 18);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.balancerGauge,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, 18),
+                poolTokens: poolTokensinfo,
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: `Balancer Gauge ${symbols.join("/")}`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    // symbol is ECLP-USDC-USDT
+    if (type === tokenType.balancerPool) {
+        const totalSupplyBN = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const poolTokensinfo = {};
+        let tvl = 0;
+        const symbols = [];
+        for (const poolToken of typeInfo.poolTokens) {
+            const symbol = ERC20Interface.decodeFunctionResult("symbol", calls[index++])[0];
+            const decimals = ERC20Interface.decodeFunctionResult("decimals", calls[index++])[0];
+            poolTokensinfo[poolToken.token] = {
+                symbol: symbol,
+                decimals: decimals,
+                amountInPool: BN2Number(poolToken.balance, decimals),
+                price: (await pricer.get({ symbol: symbol })) ?? 0,
+            };
+            tvl += poolTokensinfo[poolToken.token].price * poolTokensinfo[poolToken.token].amountInPool;
+            symbols.push(symbol);
+        }
+        const vaultBalance = ERC20Interface.decodeFunctionResult("balanceOf", calls[index++])[0];
+        let blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        const totalSupply = BN2Number(totalSupplyBN.sub(vaultBalance), campaign.campaignParameters.decimalsTargetToken);
+        /** Override in case of vault pool */
+        const vaultIndex = campaign.campaignParameters.blacklist
+            ?.map(b => utils.getAddress(b))
+            ?.indexOf(utils.getAddress(typeInfo.vault)); // Check if the vault is blacklisted
+        if (vaultIndex !== -1) {
+            blacklistedSupply -= BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", calls[index + vaultIndex])[0], campaign.campaignParameters.decimalsTargetToken); // The vault balance was already removed from the total supply
+        }
+        const priceTargetToken = tvl / totalSupply;
+        let cardName = `Balancer Pool ${symbols.join("/")}`;
+        if (typeInfo.vault === "0xFB43069f6d0473B85686a85F4Ce4Fc1FD8F00875") {
+            cardName = `Jellyverse Pool ${symbols.join("/")}`;
+        }
+        return {
+            type: tokenType.balancerPool,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply,
+                poolTokens: poolTokensinfo,
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: cardName,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.aura) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const poolTokensinfo = {};
+        let poolTvl = 0;
+        const symbols = [];
+        for (const poolToken of typeInfo.poolTokens) {
+            const symbol = ERC20Interface.decodeFunctionResult("symbol", calls[index++])[0];
+            const decimals = ERC20Interface.decodeFunctionResult("decimals", calls[index++])[0];
+            poolTokensinfo[poolToken.token] = {
+                symbol: symbol,
+                decimals: decimals,
+                amountInPool: BN2Number(poolToken.balance, decimals),
+                price: (await pricer.get({ symbol: symbol })) ?? 0,
+            };
+            poolTvl += poolTokensinfo[poolToken.token].price * poolTokensinfo[poolToken.token].amountInPool;
+            symbols.push(symbol);
+        }
+        const percentageOfSupplyInAura = (typeInfo.auraBalance / typeInfo.totalSupplyGauge) * (typeInfo.gaugeBalance / typeInfo.totalSupplyBalancerPool);
+        const tvl = poolTvl * percentageOfSupplyInAura;
+        const priceTargetToken = tvl / BN2Number(totalSupply, 18);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.aura,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, 18),
+                poolTokens: poolTokensinfo,
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: `Aura ${symbols.join("/")}`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.gearbox) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const underlyingTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const tvl = underlyingTokenPrice * typeInfo.totalAssets * typeInfo.percentageOfSupplyUnderlyingPoolTokens;
+        const priceTargetToken = tvl / BN2Number(totalSupply, 18);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.gearbox,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, 18),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: `Gearbox ${typeInfo.symbolUnderlyingToken} Deposit`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.compound) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolBaseToken })) ?? 0;
+        const tvl = baseTokenPrice * (typeInfo.totalBorrow + typeInfo.balanceBaseToken);
+        const priceTargetToken = tvl / BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.compound,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: `Lend ${typeInfo.symbolBaseToken} on Compound`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.radiant_lend) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const tvl = typeInfo.priceTargetToken * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        let cardToken = typeInfo.symbolUnderlyingToken;
+        if (campaign.campaignParameters.symbolTargetToken.startsWith("r")) {
+            cardToken = campaign.campaignParameters.symbolTargetToken.substring(1);
+        }
+        let finalSymbol = typeInfo.symbolUnderlyingToken;
+        if (typeInfo.symbolUnderlyingToken.toLowerCase().includes("gm") && cardToken.toLowerCase().includes("gm")) {
+            // Remove gm from the card name
+            finalSymbol = cardToken.substring(2);
+        }
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.radiant_lend,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                cardName: `Lend ${cardToken} on Radiant`,
+                symbolUnderlyingToken: finalSymbol,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.radiant_borrow) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const tvl = typeInfo.priceTargetToken * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.radiant_borrow,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                cardName: `Borrow ${typeInfo.symbolUnderlyingToken} on Radiant`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.ionic || type === tokenType.layerbank) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const tvl = baseTokenPrice * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken) * typeInfo.exchangeRate;
+        const priceTargetToken = baseTokenPrice * typeInfo.exchangeRate;
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        let cardName;
+        if (type === tokenType.ionic) {
+            cardName = `Supply ${typeInfo.symbolUnderlyingToken} on Ionic`;
+        }
+        else {
+            cardName = `Supply ${typeInfo.symbolUnderlyingToken} on Layerbank`;
+        }
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: cardName,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.metamorpho) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        let tvl = 0;
+        try {
+            tvl = await fetchMetamorphoTvl(campaign.chainId, typeInfo.tokenAddress);
+        }
+        catch (e) { }
+        const priceTargetToken = tvl / BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.metamorpho,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: `Supply to ${typeInfo.name} on Morpho`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.moonwell) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        // Change exchange rate to implement the decimals differences
+        typeInfo.exchangeRate =
+            typeInfo.exchangeRate /
+                10 ** (typeInfo.decimalsUnderlyingToken - campaign.campaignParameters.decimalsTargetToken);
+        const tvl = baseTokenPrice * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken) * typeInfo.exchangeRate;
+        const priceTargetToken = baseTokenPrice * typeInfo.exchangeRate;
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.moonwell,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: `Supply ${typeInfo.symbolUnderlyingToken} on Moonwell`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.aave_lending || type === tokenType.aave_borrowing) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const tvl = baseTokenPrice * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const priceTargetToken = baseTokenPrice;
+        let cardName;
+        if (type === tokenType.aave_lending) {
+            cardName = `Supply ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        }
+        else {
+            cardName = `Borrow ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        }
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: cardName,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.fraxlend || type === tokenType.sturdy_aggregator || type === tokenType.sturdy_silo) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 1;
+        const tvl = typeInfo.sharePrice * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken) * priceUnderlying;
+        let cardName;
+        if (type === tokenType.fraxlend) {
+            cardName = `Supply ${typeInfo.symbolUnderlyingToken} on Fraxlend`;
+        }
+        else if (type === tokenType.sturdy_aggregator) {
+            cardName = `Supply ${typeInfo.symbolUnderlyingToken} on Sturdy ${typeInfo.name}`;
+        }
+        else {
+            cardName = `Supply ${typeInfo.symbolUnderlyingToken} on Sturdy ${typeInfo.symbolCollateral} Silo`;
+        }
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: tvl / BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                cardName: cardName,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.curve || type === tokenType.curve_2) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        if (type === tokenType.curve_2) {
+            const prices = [];
+            for (const symbol of Object.values(typeInfo.poolTokens)) {
+                const price = (await pricer.get({ symbol: symbol })) ?? 0;
+                prices.push(price);
+            }
+            let minPrice = Math.min(...prices);
+            if (!minPrice) {
+                minPrice = 1;
+            }
+            typeInfo.lp_price = typeInfo.lp_price * minPrice;
+        }
+        const tvl = typeInfo.lp_price * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: tokenType.curve,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: typeInfo.lp_price,
+                cardName: `Curve ${Object.values(typeInfo.poolTokens).join("/")}`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.splice) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const { symbolUnderlyingToken, priceTargetToken, tvl } = await fetchSpliceInformation(campaign.campaignParameters.targetToken);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                symbolUnderlyingToken: symbolUnderlyingToken,
+                priceTargetToken: priceTargetToken,
+                cardName: `Supply ${symbolUnderlyingToken} on Splice`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.toros) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const tokenPrice = torosInterface.decodeFunctionResult("tokenPrice", calls[index++])[0];
+        const priceTargetToken = BN2Number(tokenPrice, 18);
+        const tvl = priceTargetToken * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        let symbolUnderlyingToken = "unknow";
+        try {
+            symbolUnderlyingToken = typeInfo.name.match(/\b[A-Z]+\b/g)[0];
+        }
+        catch (e) { }
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                symbolUnderlyingToken: symbolUnderlyingToken,
+                priceTargetToken: priceTargetToken,
+                cardName: `${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) on Toros`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.fluid || type === tokenType.enzyme) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const priceTargetToken = priceUnderlying * typeInfo.exchangeRate;
+        const tvl = priceTargetToken * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        let cardName;
+        if (type === tokenType.fluid) {
+            if (typeInfo.protocol === "Filament") {
+                cardName = `Earn Yield on ${typeInfo.symbolUnderlyingToken} on Filament`;
+            }
+            else {
+                cardName = `Lend ${typeInfo.symbolUnderlyingToken} on Fluid`;
+            }
+        }
+        else {
+            cardName = `Supply to the ${typeInfo.name} on Enzyme`;
+        }
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: cardName,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.silostaking) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const priceUnderlying = (await pricer.get({ symbol: campaign.campaignParameters.symbolTargetToken })) ?? 0;
+        const priceTargetToken = priceUnderlying;
+        const tvl = priceTargetToken * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: `Stake ${typeInfo.symbolUnderlyingToken} on Silo Staking`,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.euler_borrow || type === tokenType.euler_lend) {
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        let totalAssetsOrBorrows = 0;
+        let cardName = "";
+        if (type === tokenType.euler_lend) {
+            totalAssetsOrBorrows = BN2Number(eulerInterface.decodeFunctionResult("totalAssets", calls[index++])[0], typeInfo.decimalsUnderlyingToken);
+            cardName = `Supply ${typeInfo.symbolUnderlyingToken} on Euler V2`;
+            const vaultName = await fetchEulerVaultName(typeInfo.tokenAddress, campaign.chainId);
+            if (!!vaultName) {
+                cardName = `Supply ${typeInfo.symbolUnderlyingToken} on ${vaultName} vault`;
+            }
+        }
+        else {
+            totalAssetsOrBorrows = BN2Number(eulerInterface.decodeFunctionResult("totalBorrows", calls[index++])[0], typeInfo.decimalsUnderlyingToken);
+            cardName = `Borrow ${typeInfo.symbolUnderlyingToken} on Euler V2`;
+            const vaultName = await fetchEulerVaultName(typeInfo.vault, campaign.chainId);
+            if (!!vaultName) {
+                cardName = `Borrow from ${vaultName} vault`;
+            }
+        }
+        const tvl = priceUnderlying * totalAssetsOrBorrows;
+        const priceTargetToken = tvl / BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
+                tvl: tvl,
+                priceTargetToken: priceTargetToken,
+                cardName: cardName,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    if (type === tokenType.beefy) {
+        const totalSupplyUnderlying = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+        const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        let tvl = 0;
+        if (priceToken0 !== 0 && priceToken1 !== 0) {
+            tvl = priceToken0 * typeInfo.balanceToken0 + priceToken1 * typeInfo.balanceToken1;
+        }
+        const priceTargetToken = (typeInfo.pricePerShare * tvl) / BN2Number(totalSupplyUnderlying);
+        const cardName = `Moo Velodrome V2 ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        const blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                priceTargetToken: priceTargetToken, // priceTargetToken is the price of the token in USD
+                totalSupply: BN2Number(totalSupply, 18),
+                cardName: cardName,
+                blacklistedSupply: blacklistedSupply,
+            },
+        };
+    }
+    // Unknown token
+    const totalSupply = ERC20Interface.decodeFunctionResult("totalSupply", calls[index++])[0];
+    const priceTargetToken = (await pricer.get({ symbol: campaign.campaignParameters.symbolTargetToken })) ?? 0;
+    const tvl = BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken) * priceTargetToken;
+    let blacklistedSupply = getBlacklistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+    if (campaign.campaignParameters.whitelist.length > 0) {
+        blacklistedSupply =
+            BN2Number(totalSupply, 18) -
+                getWhitelistedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, campaign.campaignParameters.whitelist, calls);
+    }
+    return {
+        type: tokenType.unknown,
+        calls: [],
+        typeInfo: {
+            ...typeInfo,
+            totalSupply: BN2Number(totalSupply, 18),
+            tvl: tvl,
+            priceTargetToken: priceTargetToken,
+            cardName: `Hold ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken})`,
+            blacklistedSupply: blacklistedSupply,
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesPricesRefactoFinal.js

@@ -0,0 +1,24 @@
+import { tokenType } from "./helpers/tokenType";
+import { processorMapping } from "./processor/processorMapping";
+export async function getTokenPricesInfo(index, type, typeInfo, calls, campaign, pricer) {
+    const ProcessorClass = processorMapping[type];
+    try {
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: tokenType.unknown,
+            calls: [],
+            typeInfo: {
+                totalSupply: 0,
+                blacklistedSupply: 0,
+                priceTargetToken: 0,
+            },
+        };
+    }
+}