@merkl/api 0.21.47 → 1.0.0

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/AssetProcessor.js

@@ -1,48 +0,0 @@
-import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class AssetProcessor extends GenericProcessor {
-    rounds = {
-        round1: [
-            { key: "underlying", call: "underlying", target: "tokenAddress" },
-            { key: "exchangeRate", call: "exchangeRate", target: "tokenAddress" },
-        ],
-        round2: [
-            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying", optional: true },
-            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlying", optional: true },
-        ],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    processingRound2(typeInfo) {
-        if (typeInfo.underlying === "0x0000000000000000000000000000000000000000") {
-            typeInfo.symbolUnderlyingToken = "ETH";
-            typeInfo.decimalsUnderlyingToken = "18";
-            this.rounds.round2 = [];
-        }
-    }
-    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        let exchangeRate = BN2Number(typeInfo.exchangeRate);
-        if (type === Erc20SubType.moonwell || type === Erc20SubType.venus) {
-            exchangeRate =
-                exchangeRate /
-                    10 ** (Number(typeInfo.decimalsUnderlyingToken) - campaign.campaignParameters.decimalsTargetToken);
-        }
-        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
-        const tvl = baseTokenPrice * whitelistedSupplyTargetToken * exchangeRate;
-        const priceTargetToken = baseTokenPrice * exchangeRate;
-        return {
-            ...typeInfo,
-            totalSupply,
-            tvl,
-            priceTargetToken,
-            exchangeRate,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
-        };
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/AuraProcessor.js

@@ -1,113 +0,0 @@
-import { decodeCall } from "@/utils/decodeCalls";
-import { createCall } from "@/utils/encodeCalls";
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { utils } from "ethers";
-import { GenericProcessor, Round } from "../GenericProcessor";
-export class AuraProcessor extends GenericProcessor {
-    rounds = {
-        round1: [
-            { key: "balancerPool", call: "underlying", target: "tokenAddress" },
-            { key: "auraOperator", call: "operator", target: "tokenAddress" },
-            { key: "pid", call: "pid", target: "tokenAddress" },
-        ],
-        round2: [
-            { key: "poolId", call: "getPoolId", target: "balancerPool" },
-            { key: "vault", call: "getVault", target: "balancerPool" },
-            { key: "totalSupplyBalancerPool", call: "totalSupply", target: "balancerPool" },
-            { key: "gaugeContract", call: "poolInfo", target: "auraOperator", metaData: "pid" },
-            { key: "auraStaker", call: "staker", target: "auraOperator" },
-        ],
-        round3: [
-            { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
-            { key: "gaugeBalance", call: "balanceOf", target: "balancerPool", metaData: "gaugeContract" },
-            { key: "auraBalance", call: "balanceOf", target: "gaugeContract", metaData: "auraStaker" },
-            { key: "vaultBalance", call: "balanceOf", target: "balancerPool", metaData: "vault" },
-            { key: "totalSupplyGauge", call: "totalSupply", target: "gaugeContract" },
-        ],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    // override computeRound1(): void {}
-    processingRound4(typeInfo) {
-        const tokens = typeInfo.poolTokensRaw[0];
-        const balances = typeInfo.poolTokensRaw[1];
-        let i = 0;
-        const poolTokens = [];
-        for (const token of tokens) {
-            if (token !== typeInfo.tokenAddress) {
-                poolTokens.push({
-                    token: token,
-                    balance: balances[i].toString(),
-                    amountInPool: 0,
-                    symbol: "",
-                    decimals: 0,
-                    price: 0,
-                });
-                i++;
-                typeInfo.poolTokens = poolTokens;
-            }
-        }
-    }
-    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
-        let { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const vaultBalance = BN2Number(typeInfo.vaultBalance, 18);
-        const vaultIndex = campaign.campaignParameters.blacklist
-            ?.map(b => utils.getAddress(b))
-            ?.indexOf(utils.getAddress(typeInfo.vault));
-        if (vaultIndex !== -1) {
-            blacklistedSupply -= BN2Number(decodeCall(calls, index + vaultIndex, "balanceOf"), campaign.campaignParameters.decimalsTargetToken); // The vault balance was already removed from the total supply
-        }
-        const totalSupplyBalancerPool = BN2Number(typeInfo.totalSupplyBalancerPool, 18) - vaultBalance;
-        const gaugeBalance = BN2Number(typeInfo.gaugeBalance, 18);
-        const auraBalance = BN2Number(typeInfo.auraBalance, 18);
-        const totalSupplyGauge = BN2Number(typeInfo.totalSupplyGauge, 18);
-        let poolTvl = 0;
-        const tokensDisplay = [];
-        const symbols = [];
-        let indexUpdated = index + this.rounds.round4.length;
-        for (const poolToken of typeInfo.poolTokens) {
-            poolToken.symbol = decodeCall(calls, indexUpdated++, "symbol");
-            poolToken.decimals = decodeCall(calls, indexUpdated++, "decimals");
-            poolToken.amountInPool = BN2Number(poolToken.balance, poolToken.decimals);
-            poolToken.price = (await pricer.get({ symbol: poolToken.symbol })) ?? 0;
-            poolTvl += poolToken.price * poolToken.amountInPool;
-            symbols.push(poolToken.symbol);
-            tokensDisplay.push({ symbol: poolToken.symbol, address: poolToken.token });
-        }
-        const percentageOfSupplyInAura = (auraBalance / totalSupplyGauge) * (gaugeBalance / totalSupplyBalancerPool);
-        const tvl = poolTvl * percentageOfSupplyInAura;
-        const priceTargetToken = tvl / totalSupplyBalancerPool;
-        return {
-            ...typeInfo,
-            totalSupplyBalancerPool,
-            gaugeBalance,
-            auraBalance,
-            totalSupplyGauge,
-            totalSupply,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            tvl: tvl,
-            priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign, symbols),
-            tokensDisplay,
-        };
-    }
-    computeRound4(index, type, typeInfo, calls, campaign) {
-        // This is to enforce type checking
-        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
-        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
-        this.processingRound4(typeInfo);
-        const poolCalls = this.encodeNextRound(Round.four, type, typeInfo);
-        for (const poolToken of typeInfo.poolTokens) {
-            poolCalls.push(createCall(poolToken.token, "symbol"));
-            poolCalls.push(createCall(poolToken.token, "decimals"));
-        }
-        return {
-            type: type,
-            calls: blacklistedLiquidityCalls.concat(poolCalls),
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/BEXRewardGaugeProcessor.js

@@ -1,111 +0,0 @@
-import { decodeCall } from "@/utils/decodeCalls";
-import { createCall } from "@/utils/encodeCalls";
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor, Round } from "../GenericProcessor";
-export class BEXRewardGaugeProcessor extends GenericProcessor {
-    rounds = {
-        round1: [{ key: "gyroscopeToken", call: "lp_token", target: "tokenAddress" }],
-        round2: [
-            { key: "balanceUnderlyingPoolTokens", call: "totalAssets", target: "tokenAddress" },
-            { key: "totalSupplyUnderlyingPoolTokens", call: "totalSupply", target: "gyroscopeToken" },
-            { key: "poolId", call: "getPoolId", target: "gyroscopeToken" },
-            { key: "vault", call: "getVault", target: "gyroscopeToken" },
-            { key: "poolHolderBalance", call: "balanceOf", target: "gyroscopeToken", metaData: "poolHolder" },
-        ],
-        round3: [
-            { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
-            { key: "vaultBalance", call: "balanceOf", target: "gyroscopeToken", metaData: "vault" },
-        ],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    // override computeRound1(): void {}
-    processingRound2(typeInfo) {
-        typeInfo.poolHolder = "0xC2BaA8443cDA8EBE51a640905A8E6bc4e1f9872c";
-    }
-    processingRound4(typeInfo) {
-        const tokens = typeInfo.poolTokensRaw[0];
-        const balances = typeInfo.poolTokensRaw[1];
-        let i = 0;
-        const poolTokens = [];
-        for (const token of tokens) {
-            poolTokens.push({
-                token: token,
-                balance: balances[i].toString(),
-            });
-            i++;
-            typeInfo.poolTokens = poolTokens;
-        }
-    }
-    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
-        const poolTokensinfo = {};
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        let tvlUnderlyingPool = 0;
-        const symbols = [];
-        let indexUpdated = index + this.rounds.round4.length;
-        const tokensDisplay = [];
-        for (const poolToken of typeInfo.poolTokens) {
-            const symbol = decodeCall(calls, indexUpdated++, "symbol");
-            const decimals = decodeCall(calls, indexUpdated++, "decimals");
-            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);
-            tokensDisplay.push({ symbol: symbol, address: poolToken.token });
-        }
-        let adjustedPoolTotalSupply = BN2Number(typeInfo.totalSupplyUnderlyingPoolTokens, 18);
-        // if (type === Erc20SubType.beratrax_vault) {
-        //   // Weird edge case where a lot of the supply is in a weird contract
-        //   adjustedPoolTotalSupply -= BN2Number(typeInfo.poolHolderBalance, 18);
-        // }
-        // if (type === Erc20SubType.beraborrow_gauge) {
-        // Remove tokens in the vault from the total supply
-        adjustedPoolTotalSupply -= BN2Number(typeInfo.vaultBalance, 18);
-        let percentageOfSupplyUnderlyingPoolTokens = 1;
-        if (adjustedPoolTotalSupply > 0) {
-            percentageOfSupplyUnderlyingPoolTokens =
-                BN2Number(typeInfo.balanceUnderlyingPoolTokens, 18) / adjustedPoolTotalSupply;
-        }
-        const tvl = tvlUnderlyingPool * percentageOfSupplyUnderlyingPoolTokens;
-        const priceTargetToken = tvl / totalSupply;
-        // If one of the symbols in the symbol list contains 2 of the other symbols of the list, remove it
-        // It's a weird edge case that happens with the BEX pools
-        const symbolToRemove = symbols.find(symbol => symbols.filter(s => symbol.includes(s)).length > 1);
-        if (symbolToRemove) {
-            symbols.splice(symbols.indexOf(symbolToRemove), 1);
-        }
-        return {
-            ...typeInfo,
-            totalSupply: totalSupply,
-            poolTokens: poolTokensinfo,
-            tvl: tvl,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign, symbols),
-            tokensDisplay,
-        };
-    }
-    computeRound4(index, type, typeInfo, calls, campaign) {
-        // This is to enforce type checking
-        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
-        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
-        this.processingRound4(typeInfo);
-        const poolCalls = [createCall(typeInfo.tokenAddress, "totalSupply")];
-        for (const poolToken of typeInfo.poolTokens) {
-            poolCalls.push(createCall(poolToken.token, "symbol"));
-            poolCalls.push(createCall(poolToken.token, "decimals"));
-        }
-        return {
-            type: type,
-            calls: blacklistedLiquidityCalls.concat(poolCalls),
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/BalancerGaugeProcessor.js

@@ -1,86 +0,0 @@
-import { decodeCall } from "@/utils/decodeCalls";
-import { createCall } from "@/utils/encodeCalls";
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor, Round } from "../GenericProcessor";
-export class BalancerGaugeProcessor extends GenericProcessor {
-    rounds = {
-        round1: [{ key: "gyroscopeToken", call: "lp_token", target: "tokenAddress" }],
-        round2: [
-            { key: "balanceUnderlyingPoolTokens", call: "balanceOf", target: "gyroscopeToken", metaData: "tokenAddress" },
-            { key: "totalSupplyUnderlyingPoolTokens", call: "totalSupply", target: "gyroscopeToken" },
-            { key: "poolId", call: "getPoolId", target: "gyroscopeToken" },
-            { key: "vault", call: "getVault", target: "gyroscopeToken" },
-        ],
-        round3: [{ key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" }],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    // override computeRound1(): void {}
-    processingRound4(typeInfo) {
-        const tokens = typeInfo.poolTokensRaw[0];
-        const balances = typeInfo.poolTokensRaw[1];
-        let i = 0;
-        const poolTokens = [];
-        for (const token of tokens) {
-            poolTokens.push({
-                token: token,
-                balance: balances[i].toString(),
-            });
-            i++;
-            typeInfo.poolTokens = poolTokens;
-        }
-    }
-    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
-        const poolTokensinfo = {};
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        let tvlUnderlyingPool = 0;
-        const symbols = [];
-        const tokensDisplay = [];
-        let indexUpdated = index + this.rounds.round4.length;
-        for (const poolToken of typeInfo.poolTokens) {
-            const symbol = decodeCall(calls, indexUpdated++, "symbol");
-            const decimals = decodeCall(calls, indexUpdated++, "decimals");
-            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);
-            tokensDisplay.push({ symbol: symbol, address: poolToken.token });
-        }
-        const percentageOfSupplyUnderlyingPoolTokens = BN2Number(typeInfo.balanceUnderlyingPoolTokens, 18) / BN2Number(typeInfo.totalSupplyUnderlyingPoolTokens, 18);
-        const tvl = tvlUnderlyingPool * percentageOfSupplyUnderlyingPoolTokens;
-        const priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            totalSupply: totalSupply,
-            poolTokens: poolTokensinfo,
-            tvl: tvl,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign, symbols),
-            tokensDisplay,
-        };
-    }
-    computeRound4(index, type, typeInfo, calls, campaign) {
-        // This is to enforce type checking
-        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
-        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
-        this.processingRound4(typeInfo);
-        const poolCalls = [createCall(typeInfo.tokenAddress, "totalSupply")];
-        for (const poolToken of typeInfo.poolTokens) {
-            poolCalls.push(createCall(poolToken.token, "symbol"));
-            poolCalls.push(createCall(poolToken.token, "decimals"));
-        }
-        return {
-            type: type,
-            calls: blacklistedLiquidityCalls.concat(poolCalls),
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/BalancerPoolProcessor.js

@@ -1,101 +0,0 @@
-import { decodeCall } from "@/utils/decodeCalls";
-import { createCall } from "@/utils/encodeCalls";
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number, ChainId } from "@sdk";
-import { BigNumber } from "ethers";
-import { utils } from "ethers";
-import { GenericProcessor, Round } from "../GenericProcessor";
-export class BalancerPoolProcessor extends GenericProcessor {
-    rounds = {
-        round1: [],
-        round2: [
-            { key: "poolId", call: "getPoolId", target: "tokenAddress" },
-            { key: "vault", call: "getVault", target: "tokenAddress" },
-        ],
-        round3: [{ key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" }],
-        round4: [
-            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
-            { key: "vaultBalance", call: "balanceOf", target: "tokenAddress", metaData: "vault" },
-        ],
-    };
-    // override computeRound1(): void {}
-    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
-        let { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const totalSupplyBN = BigNumber.from(typeInfo.totalSupply);
-        const vaultBalanceBN = BigNumber.from(typeInfo.vaultBalance);
-        const totalSupplyUpdated = BN2Number(totalSupplyBN.sub(vaultBalanceBN), campaign.campaignParameters.decimalsTargetToken);
-        const vaultBalance = BN2Number(vaultBalanceBN, campaign.campaignParameters.decimalsTargetToken);
-        let tvl = 0;
-        const symbols = [];
-        const tokensDisplay = [];
-        let indexUpdated = index + this.rounds.round4.length;
-        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(decodeCall(calls, index + vaultIndex, "balanceOf"), campaign.campaignParameters.decimalsTargetToken); // The vault balance was already removed from the total supply
-        }
-        for (const poolToken of typeInfo.poolTokens) {
-            poolToken.symbol = decodeCall(calls, indexUpdated++, "symbol");
-            poolToken.decimals = decodeCall(calls, indexUpdated++, "decimals");
-            poolToken.amountInPool = BN2Number(poolToken.balance, poolToken.decimals);
-            poolToken.price = (await pricer.get({ symbol: poolToken.symbol })) ?? 0;
-            tvl += poolToken.price * poolToken.amountInPool;
-            symbols.push(poolToken.symbol);
-            tokensDisplay.push({ symbol: poolToken.symbol, address: poolToken.token });
-        }
-        if (campaign.computeChainId === ChainId.SONIC) {
-            typeInfo.protocol = "Beets";
-        }
-        const priceTargetToken = tvl / totalSupplyUpdated;
-        return {
-            ...typeInfo,
-            totalSupply: totalSupplyUpdated,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            tvl: tvl,
-            priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign, symbols),
-            vaultBalance: vaultBalance,
-            tokensDisplay,
-        };
-    }
-    processingRound4(typeInfo) {
-        const tokens = typeInfo.poolTokensRaw[0];
-        const balances = typeInfo.poolTokensRaw[1];
-        let i = 0;
-        const poolTokens = [];
-        for (const token of tokens) {
-            if (token !== typeInfo.tokenAddress) {
-                poolTokens.push({
-                    token: token,
-                    balance: balances[i].toString(),
-                    amountInPool: 0,
-                    symbol: "",
-                    decimals: 0,
-                    price: 0,
-                });
-            }
-            i++;
-            typeInfo.poolTokens = poolTokens;
-        }
-    }
-    computeRound4(index, type, typeInfo, calls, campaign) {
-        // This is to enforce type checking
-        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
-        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
-        this.processingRound4(typeInfo);
-        const poolCalls = this.encodeNextRound(Round.four, type, typeInfo);
-        for (const poolToken of typeInfo.poolTokens) {
-            poolCalls.push(createCall(poolToken.token, "symbol"));
-            poolCalls.push(createCall(poolToken.token, "decimals"));
-        }
-        return {
-            type: type,
-            calls: blacklistedLiquidityCalls.concat(poolCalls),
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/BalancerV3PoolProcessor.js

@@ -1,81 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number, ChainId } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-const matchSingleNumber = (input) => {
-    const regex = /^\d+$/;
-    return regex.test(input);
-};
-export class BalancerV3PoolProcessor extends GenericProcessor {
-    rounds = {
-        round1: [
-            { key: "numberTokens", call: "getTokens", target: "tokenAddress" },
-            { key: "tokenInfo", call: "getTokenInfo", target: "tokenAddress" },
-        ],
-        round2: [],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    // override computeRound1(): void {}
-    processingRound2(typeInfo) {
-        typeInfo.numberTokens = Number(typeInfo.numberTokens);
-        for (let i = 0; i < typeInfo.numberTokens; i++) {
-            typeInfo[`token${i}`] = typeInfo.tokenInfo.tokens[i];
-            this.rounds.round2 = this.rounds.round2.concat([
-                { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
-                { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
-            ]);
-            typeInfo[`balanceToken${i}`] = typeInfo.tokenInfo.balancesRaw[i];
-        }
-    }
-    computeRound3(index, type, typeInfo, calls) {
-        for (let i = 0; i < typeInfo.numberTokens; i++) {
-            this.rounds.round2 = this.rounds.round2.concat([
-                { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
-                { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
-            ]);
-        }
-        return super.computeRound3(index, type, typeInfo, calls);
-    }
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        let tvl = 0;
-        const tokensDisplay = [];
-        for (let i = 0; i < typeInfo.numberTokens; i++) {
-            let symbol = typeInfo[`symbolToken${i}`];
-            const price = (await pricer.get({ symbol: symbol })) ?? 0;
-            symbol = symbol.replace("wmooSiloV2Sonic", "");
-            typeInfo[`symbolToken${i}`] = symbol.replace(" (wS Market)", "");
-            const decimals = Number(typeInfo[`decimalsToken${i}`]);
-            tokensDisplay.push({ symbol: symbol, address: typeInfo[`token${i}`] });
-            const amount = BN2Number(typeInfo[`balanceToken${i}`], decimals);
-            tvl += amount * price;
-        }
-        const priceTargetToken = tvl / totalSupply;
-        // Remove all keys that start with a number or balanceToken
-        for (const key in typeInfo) {
-            if (key.startsWith("balanceToken") ||
-                key.startsWith("decimalsToken") ||
-                matchSingleNumber(key) ||
-                key.startsWith("tokenInfo")) {
-                delete typeInfo[key];
-            }
-        }
-        const symbols = [];
-        for (let i = 0; i < typeInfo.numberTokens; i++) {
-            symbols.push(typeInfo[`symbolToken${i}`]);
-        }
-        if (campaign.computeChainId === ChainId.SONIC) {
-            typeInfo.protocol = "Beets";
-        }
-        return {
-            ...typeInfo,
-            totalSupply,
-            tvl,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign, symbols),
-            tokensDisplay,
-        };
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/BeefyProcessor.js

@@ -1,54 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class BeefyProcessor extends GenericProcessor {
-    rounds = {
-        round1: [
-            { key: "pricePerShare", call: "getPricePerFullShare", target: "tokenAddress" },
-            { key: "underlying", call: "want", target: "tokenAddress" },
-        ],
-        round2: [
-            { key: "token0", call: "token0", target: "underlying" },
-            { key: "token1", call: "token1", target: "underlying" },
-        ],
-        round3: [
-            { key: "symbolToken0", call: "symbol", target: "token0" },
-            { key: "symbolToken1", call: "symbol", target: "token1" },
-            { key: "decimalsToken0", call: "decimals", target: "token0" },
-            { key: "decimalsToken1", call: "decimals", target: "token1" },
-            { key: "balanceToken0", call: "balanceOf", target: "token0", metaData: "underlying" },
-            { key: "balanceToken1", call: "balanceOf", target: "token1", metaData: "underlying" },
-        ],
-        round4: [
-            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
-            { key: "totalSupplyUnderlying", call: "totalSupply", target: "underlying" },
-        ],
-    };
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        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 * BN2Number(typeInfo.balanceToken0, Number(typeInfo.decimalsToken0)) +
-                    priceToken1 * BN2Number(typeInfo.balanceToken1, Number(typeInfo.decimalsToken1));
-        }
-        const pricePerShare = BN2Number(typeInfo.pricePerShare);
-        const priceTargetToken = (pricePerShare * tvl) / BN2Number(typeInfo.totalSupplyUnderlying);
-        return {
-            ...typeInfo,
-            priceTargetToken,
-            totalSupply,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            cardName: generateCardName(type, typeInfo, campaign),
-            pricePerShare,
-            tvl,
-            tokensDisplay: [
-                { symbol: typeInfo.symbolToken0, address: typeInfo.token0 },
-                { symbol: typeInfo.symbolToken1, address: typeInfo.token1 },
-            ],
-        };
-    }
-}