@merkl/api 0.10.199 → 0.10.200

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

@@ -1,583 +1,24 @@
-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";
+import { processorMapping } from "./processor/processorMapping";
 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 ProcessorClass = processorMapping[type];
+    try {
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
         }
-        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,
-            },
-        };
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound5(index, type, typeInfo, calls, campaign, pricer);
     }
-    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);
+    catch (error) {
+        console.error(error);
         return {
-            type: tokenType.curve,
+            type: tokenType.unknown,
             calls: [],
             typeInfo: {
-                ...typeInfo,
-                totalSupply: BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken),
-                tvl: tvl,
-                priceTargetToken: typeInfo.lp_price,
-                cardName: `Curve ${Object.values(typeInfo.poolTokens).join("/")}`,
-                blacklistedSupply: blacklistedSupply,
+                totalSupply: 0,
+                blacklistedSupply: 0,
+                priceTargetToken: 0,
             },
         };
     }
-    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/subtypesRound1.d.ts

@@ -1,23 +1,4 @@
-import { Interface } from "@ethersproject/abi";
+import type { Campaign, CampaignParameters } from "@sdk";
 import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
 import { type tokenTypeStruct } from "./helpers/tokenType";
-export declare const factoryInterface: Interface;
-export declare const balancerGaugeInterface: Interface;
-export declare const OneInchStakingInterface: Interface;
-export declare const compoundInterface: Interface;
-export declare const radiantInterface: Interface;
-export declare const ionicInterface: Interface;
-export declare const layerBankInterface: Interface;
-export declare const metamorphoInterface: Interface;
-export declare const moonwellInterface: Interface;
-export declare const aaveInterface: Interface;
-export declare const fraxlendInterface: Interface;
-export declare const curveInterface: Interface;
-export declare const sturdyInterface: Interface;
-export declare const torosInterface: Interface;
-export declare const auraInterface: Interface;
-export declare const fluidInterface: Interface;
-export declare const enzymeInterface: Interface;
-export declare const eulerInterface: Interface;
-export declare const beefyInterface: Interface;
-export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number): tokenTypeStruct;
+export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;