@merkl/api 0.21.47 → 1.0.3

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

@@ -1,91 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number, computeUniswapV4PoolId } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class BunniV2Processor extends GenericProcessor {
-    rounds = {
-        round1: [
-            {
-                key: "hub",
-                call: "hub",
-                target: "tokenAddress",
-            },
-            {
-                key: "poolKey",
-                call: "poolKey",
-                target: "tokenAddress",
-            },
-            {
-                key: "token0",
-                call: "token0",
-                target: "tokenAddress",
-            },
-            {
-                key: "token1",
-                call: "token1",
-                target: "tokenAddress",
-            },
-        ],
-        round2: [
-            {
-                key: "poolState",
-                call: "poolState",
-                target: "hub",
-                metaData: "poolId",
-            },
-        ],
-        round3: [
-            {
-                key: "decimalsToken0",
-                call: "decimals",
-                target: "token0",
-            },
-            {
-                key: "symbolToken0",
-                call: "symbol",
-                target: "token0",
-            },
-            {
-                key: "decimalsToken1",
-                call: "decimals",
-                target: "token1",
-            },
-            {
-                key: "symbolToken1",
-                call: "symbol",
-                target: "token1",
-            },
-        ],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    processingRound2(typeInfo) {
-        typeInfo.poolId = computeUniswapV4PoolId(typeInfo.poolKey);
-    }
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const decimalsToken0 = Number(typeInfo.decimalsToken0);
-        const decimalsToken1 = Number(typeInfo.decimalsToken1);
-        const amount0 = BN2Number(typeInfo.poolState.rawBalance0, decimalsToken0) +
-            BN2Number(typeInfo.poolState.reserve0, decimalsToken0);
-        const amount1 = BN2Number(typeInfo.poolState.rawBalance1, decimalsToken0) +
-            BN2Number(typeInfo.poolState.reserve1, decimalsToken1);
-        const token0PRice = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
-        const token1Price = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
-        const tvl = token0PRice * amount0 + token1Price * amount1;
-        const priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            balance0: amount0.toString(),
-            balance1: amount1.toString(),
-            blacklistedSupply,
-            cardName: generateCardName(type, typeInfo, campaign),
-            priceTargetToken: priceTargetToken,
-            totalSupply,
-            tvl,
-            whitelistedSupplyTargetToken,
-            tokensDisplay: [
-                { symbol: typeInfo.symbolToken0, address: typeInfo.token0 },
-                { symbol: typeInfo.symbolToken1, address: typeInfo.token1 },
-            ],
-        };
-    }
-}

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

@@ -1,37 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class CompoundProcessor extends GenericProcessor {
-    rounds = {
-        round1: [{ key: "baseToken", call: "baseToken", target: "tokenAddress" }],
-        round2: [
-            { key: "totalBorrow", call: "totalAssets", target: "tokenAddress" },
-            { key: "balanceBaseToken", call: "balanceOf", target: "baseToken", metaData: "tokenAddress" },
-            { key: "symbolBaseToken", call: "symbol", target: "baseToken" },
-            { key: "decimalsBaseToken", call: "decimals", target: "baseToken" },
-        ],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    // override computeRound1(): void {}
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const totalBorrow = BN2Number(typeInfo.totalBorrow, Number(typeInfo.decimalsBaseToken));
-        const balanceBaseToken = BN2Number(typeInfo.balanceBaseToken, Number(typeInfo.decimalsBaseToken));
-        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolBaseToken })) ?? 0;
-        const tvl = baseTokenPrice * (totalBorrow + balanceBaseToken);
-        const priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            totalSupply,
-            tvl: tvl,
-            whitelistedSupplyTargetToken,
-            totalBorrow,
-            blacklistedSupply,
-            balanceBaseToken,
-            priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: typeInfo.symbolBaseToken, address: typeInfo.baseToken }],
-        };
-    }
-}

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

@@ -1,37 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class ERC4626Processor extends GenericProcessor {
-    rounds = {
-        round1: [{ key: "asset", call: "asset", target: "tokenAddress" }],
-        round2: [
-            { key: "decimalsAsset", call: "decimals", target: "asset" },
-            { key: "symbolAsset", call: "symbol", target: "asset" },
-        ],
-        round3: [],
-        round4: [
-            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
-            { key: "totalAssets", call: "totalAssets", target: "tokenAddress" },
-        ],
-    };
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const priceAsset = (await pricer.get({
-            symbol: typeInfo.symbolAsset,
-        })) ?? 0;
-        const decimalsAsset = Number.parseInt(typeInfo.decimalsAsset);
-        const amountAsset = BN2Number(typeInfo.totalAssets, decimalsAsset);
-        const tvl = priceAsset * amountAsset;
-        const priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            totalSupply,
-            tvl,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: typeInfo.symbolAsset, address: typeInfo.asset }],
-        };
-    }
-}

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

@@ -1,52 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class EnzymeProcessor extends GenericProcessor {
-    rounds = {
-        round1: [
-            { key: "exchangeRateRaw", call: "calcNetShareValue", target: "fundValueCalculator", metaData: "tokenAddress" },
-        ],
-        round2: [{ key: "symbolUnderlyingToken", call: "symbol", target: "underlying" }],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
-        const exchangeRate = BN2Number(typeInfo.exchangeRate, 18);
-        const priceTargetToken = priceUnderlying * exchangeRate;
-        const tvl = priceTargetToken * totalSupply;
-        return {
-            ...typeInfo,
-            tvl,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            priceTargetToken,
-            totalSupply,
-            exchangeRate,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
-        };
-    }
-    processingRound2(typeInfo) {
-        typeInfo.underlying = typeInfo.exchangeRateRaw[0];
-        typeInfo.exchangeRate = typeInfo.exchangeRateRaw[1];
-    }
-    computeRound3(index, type, typeInfo, calls) {
-        // This is to enforce type checking
-        try {
-            return super.computeRound3(index, type, typeInfo, calls);
-        }
-        catch (e) {
-            // usually if this fails its because of native ETH
-            return {
-                type: type,
-                calls: [],
-                typeInfo: {
-                    ...typeInfo,
-                    symbolUnderlyingToken: "ETH",
-                },
-            };
-        }
-    }
-}

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

@@ -1,54 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import axios from "axios";
-import { GenericProcessor } from "../GenericProcessor";
-const findObjectByFarm = (dict, farmAddress) => {
-    for (const key in dict) {
-        if (dict[key].config && dict[key].config.farm === farmAddress) {
-            return dict[key];
-        }
-    }
-    return null;
-};
-export class EqualizerGaugeProcessor extends GenericProcessor {
-    rounds = {
-        round1: [],
-        round2: [],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    async processingRound5(_index, type, typeInfo, _calls, campaign, _pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const EXTERNAL_EQUALIZER_ENDPOINT = "https://eqapi-sonic-prod-ltanm.ondigitalocean.app/sonic/v4/gauges/";
-        const data = (await axios(EXTERNAL_EQUALIZER_ENDPOINT)).data.data;
-        let tvl = 0;
-        let displayName = "Stake into Equalizer Gauge";
-        try {
-            if (!!data[typeInfo.tokenAddress]) {
-                tvl = data[typeInfo.tokenAddress].token0.reserveUsd + data[typeInfo.tokenAddress].token1.reserveUsd;
-                displayName = `Stake into ${data[typeInfo.tokenAddress].pair.displayName} Equalizer Gauge`;
-            }
-            else {
-                const EXTERNAL_EQUALIZER_CL_ENDPOINT = "https://eqapi-sonic-prod-ltanm.ondigitalocean.app/sonic/v4/clsets";
-                const data = (await axios(EXTERNAL_EQUALIZER_CL_ENDPOINT)).data.data;
-                const pool = findObjectByFarm(data, typeInfo.tokenAddress);
-                if (!!pool) {
-                    tvl = pool.integration.equalizerPair.tvlUsd;
-                    displayName = `Stake into ${pool.name} Equalizer Gauge`;
-                }
-            }
-        }
-        catch (e) { }
-        const priceTargetToken = tvl / totalSupply;
-        //const displayName = `Stake into ${data[typeInfo.tokenAddress].pair.displayName} Equalizer Gauge`;
-        return {
-            ...typeInfo,
-            totalSupply,
-            tvl,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign, [], displayName),
-            tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
-        };
-    }
-}

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

@@ -1,51 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number, EulerSubCampaignType } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-import { fetchEulerVaultName } from "../helpers/eulerVaultNames";
-export class EulerBorrowProcessor extends GenericProcessor {
-    rounds = {
-        round1: [],
-        round2: [],
-        round3: [],
-        round4: [
-            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
-            { key: "totalAssets", call: "totalAssets", target: "addressVault" },
-        ],
-    };
-    processingRound2(typeInfo, campaign) {
-        typeInfo.addressVault = campaign.campaignParameters.evkAddress;
-    }
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const symbolAsset = campaign.campaignParameters.symbolAsset;
-        const decimalsAsset = Number(campaign.campaignParameters.decimalsAsset);
-        const priceAsset = (await pricer.get({ symbol: symbolAsset })) ?? 1;
-        const totalBorrows = BN2Number(typeInfo.totalAssets, decimalsAsset);
-        typeInfo.symbolUnderlyingToken = symbolAsset;
-        let cardName = generateCardName(type, typeInfo, campaign);
-        const vaultName = await fetchEulerVaultName(campaign.campaignParameters.evkAddress, campaign.chainId);
-        if (!!vaultName) {
-            cardName = `Borrow from ${vaultName} vault`;
-        }
-        if (campaign.campaignSubType === EulerSubCampaignType.BORROW_FROM_COLLATERAL) {
-            cardName = `${cardName} using ${campaign.campaignParameters.symbolCollateral}`;
-        }
-        const tvl = priceAsset * totalBorrows;
-        const priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            asset: campaign.campaignParameters.addressAsset,
-            addressVault: typeInfo.addressVault,
-            blacklistedSupply,
-            cardName: cardName,
-            decimalsAsset,
-            priceTargetToken,
-            symbolAsset,
-            totalBorrows: typeInfo.totalAssets.toString(),
-            totalSupply,
-            tvl,
-            whitelistedSupplyTargetToken,
-            tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
-        };
-    }
-}

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

@@ -1,58 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { generateCardName } from "@/utils/generateCardName";
-import { log } from "@/utils/logger";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-import { fetchEulerVaultName } from "../helpers/eulerVaultNames";
-export class EulerLendProcessor extends GenericProcessor {
-    rounds = {
-        round1: [],
-        round2: [],
-        round3: [],
-        round4: [
-            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
-            { key: "totalAssets", call: "totalAssets", target: "tokenAddress" },
-        ],
-    };
-    processingRound2(typeInfo, campaign) {
-        typeInfo.addressVault = campaign.campaignParameters.evkAddress;
-    }
-    async processingRound5(_index, type, typeInfo, _calls, campaign) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const chainId = campaign.computeChainId;
-        const underlyingAsset = campaign.campaignParameters.addressAsset;
-        const underlyingToken = await TokenService.findUniqueFillOrThrow({
-            chainId,
-            address: underlyingAsset,
-        });
-        let decimalsAsset = Number(campaign.campaignParameters.decimalsAsset) ?? 18;
-        if (Number.isNaN(decimalsAsset)) {
-            log.warn(`decimalsAsset is NaN for ${underlyingToken.symbol} on campaign ${campaign.campaignId}`);
-            decimalsAsset = 18;
-        }
-        const totalAssets = BN2Number(typeInfo.totalAssets, decimalsAsset);
-        typeInfo.symbolUnderlyingToken = underlyingToken.symbol;
-        let cardName = generateCardName(type, typeInfo, campaign);
-        const vaultName = await fetchEulerVaultName(typeInfo.tokenAddress, campaign.chainId);
-        if (!!vaultName) {
-            cardName = `Supply ${underlyingToken.symbol} on ${vaultName} vault`;
-        }
-        const tvl = (underlyingToken.price ?? 1) * totalAssets;
-        const priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            asset: campaign.campaignParameters.addressAsset,
-            addressVault: typeInfo.addressVault,
-            blacklistedSupply,
-            cardName: cardName,
-            decimalsAsset,
-            priceTargetToken,
-            symbolAsset: underlyingToken.symbol,
-            totalAssets: typeInfo.totalAssets.toString(),
-            totalSupply,
-            tvl,
-            whitelistedSupplyTargetToken,
-            tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
-        };
-    }
-}

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

@@ -1,37 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { BigNumber } from "ethers";
-import { GenericProcessor } from "../GenericProcessor";
-export class FluidProcessor extends GenericProcessor {
-    rounds = {
-        round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
-        round2: [
-            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
-            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlying" },
-        ],
-        round3: [{ key: "toAssets", call: "convertToAssets", target: "tokenAddress", metaData: "amount" }],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    // override computeRound1(): void {}
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
-        const exchangeRate = BN2Number(typeInfo.toAssets, Number(typeInfo.decimalsUnderlyingToken));
-        const priceTargetToken = priceUnderlying * exchangeRate;
-        const tvl = priceTargetToken * totalSupply;
-        return {
-            ...typeInfo,
-            tvl,
-            exchangeRate,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            totalSupply,
-            priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
-        };
-    }
-    processingRound3(typeInfo) {
-        typeInfo.amount = BigNumber.from(10).pow(typeInfo.decimalsUnderlyingToken).toString();
-    }
-}

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

@@ -1,42 +0,0 @@
-import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class FraxProcessor extends GenericProcessor {
-    rounds = {
-        round1: [
-            { key: "underlying", call: "underlying", target: "tokenAddress" },
-            { key: "sharePrice", call: "pricePerShare", target: "tokenAddress" },
-        ],
-        round2: [
-            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
-            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlying" },
-        ],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const sharePrice = BN2Number(typeInfo.sharePrice, 18);
-        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 1;
-        let priceTargetToken = 0;
-        let tvl = 0;
-        if (type === Erc20SubType.silostaking) {
-            priceTargetToken = priceUnderlying;
-            tvl = priceTargetToken * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
-        }
-        tvl = sharePrice * totalSupply * priceUnderlying;
-        priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            totalSupply,
-            tvl,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            sharePrice,
-            priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
-        };
-    }
-}

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

@@ -1,52 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { withTimeout } from "@sdk";
-import axios from "axios";
-import { GenericProcessor } from "../GenericProcessor";
-async function getVaultInfo(targetVaultAddress, chainId) {
-    let data = [];
-    try {
-        data = await withTimeout((async () => {
-            data = (await axios.get(`https://api.gamma.xyz/frontend/hypervisors/allDataSummary?chain=${chainId}`))
-                .data;
-            return data;
-        })(), 5000);
-    }
-    catch (e) {
-        return null;
-    }
-    for (const item of data) {
-        if (item.address.toLowerCase() === targetVaultAddress.toLowerCase()) {
-            return {
-                tvl: Number(item.tvlUSD),
-                protocol: item.protocol,
-            };
-        }
-    }
-    return null;
-}
-export class GammaALMProcessor extends GenericProcessor {
-    rounds = {
-        round1: [],
-        round2: [],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    async processingRound5(_index, type, typeInfo, _calls, campaign, _pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const vaultInfo = await getVaultInfo(campaign.campaignParameters.targetToken, campaign.computeChainId);
-        const tvl = !!vaultInfo ? vaultInfo.tvl : 0;
-        const protocol = !!vaultInfo ? vaultInfo.protocol : "";
-        const priceTargetToken = tvl / totalSupply;
-        typeInfo.underlyingProtocol = protocol;
-        return {
-            ...typeInfo,
-            totalSupply,
-            tvl,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
-        };
-    }
-}

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

@@ -1,67 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class GammaProcessor extends GenericProcessor {
-    rounds = {
-        round1: [
-            { key: "tokensRaw", call: "tokensRaw", target: "tokenAddress" },
-            { key: "tokenBalances", call: "tokenBalances", target: "tokenAddress" },
-        ],
-        round2: [
-            { key: "symbolToken0", call: "symbol", target: "token0" },
-            { key: "symbolToken1", call: "symbol", target: "token1" },
-            { key: "decimalsToken0", call: "decimals", target: "token0" },
-            { key: "decimalsToken1", call: "decimals", target: "token1" },
-        ],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    processingRound2(typeInfo) {
-        typeInfo.token0 = typeInfo.tokensRaw[0];
-        typeInfo.token1 = typeInfo.tokensRaw[1];
-        typeInfo.balanceToken0 = typeInfo.tokenBalances[0];
-        typeInfo.balanceToken1 = typeInfo.tokenBalances[1];
-    }
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const decimalsToken0 = Number(typeInfo.decimalsToken0);
-        const decimalsToken1 = Number(typeInfo.decimalsToken1);
-        const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
-        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
-        const balanceToken0 = BN2Number(typeInfo.balanceToken0, decimalsToken0);
-        const balanceToken1 = BN2Number(typeInfo.balanceToken1, decimalsToken1);
-        let tvl = 0;
-        if (priceToken0 !== 0 && priceToken1 !== 0) {
-            tvl = priceToken0 * balanceToken0 + priceToken1 * balanceToken1;
-        }
-        const priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            priceTargetToken,
-            totalSupply,
-            whitelistedSupplyTargetToken,
-            blacklistedSupply,
-            tvl,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [
-                { symbol: typeInfo.symbolToken0, address: typeInfo.token0 },
-                { symbol: typeInfo.symbolToken1, address: typeInfo.token1 },
-            ],
-        };
-    }
-    computeRound1(type, typeInfo) {
-        return super.computeRound1(type, typeInfo);
-    }
-    computeRound2(index, type, typeInfo, calls) {
-        return super.computeRound2(index, type, typeInfo, calls);
-    }
-    computeRound3(index, type, typeInfo, calls) {
-        return super.computeRound3(index, type, typeInfo, calls);
-    }
-    computeRound4(index, type, typeInfo, calls, campaign) {
-        return super.computeRound4(index, type, typeInfo, calls, campaign);
-    }
-    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
-        return super.computeRound5(index, type, typeInfo, calls, campaign, pricer);
-    }
-}

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

@@ -1,58 +0,0 @@
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { GenericProcessor } from "../GenericProcessor";
-export class GearboxProcessor extends GenericProcessor {
-    rounds = {
-        round1: [{ key: "stakingToken", call: "stakingToken", target: "tokenAddress", optional: true }],
-        round2: [
-            { key: "balanceStakingToken", call: "balanceOf", target: "stakingToken", metaData: "tokenAddress" },
-            { key: "totalSupplyStakingToken", call: "totalSupply", target: "stakingToken" },
-            { key: "decimalsStakingToken", call: "decimals", target: "stakingToken" },
-            { key: "underlyingToken", call: "underlying", target: "stakingToken" },
-            { key: "totalAssets", call: "totalAssets", target: "stakingToken" },
-        ],
-        round3: [
-            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlyingToken" },
-            { key: "symbolUnderlyingToken", call: "symbol", target: "underlyingToken" },
-        ],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    async processingRound2(typeInfo) {
-        typeInfo.stakingToken = typeInfo.stakingToken ?? typeInfo.tokenAddress;
-        typeInfo.isTrade = typeInfo.stakingToken === typeInfo.tokenAddress;
-    }
-    // override computeRound1(): void {}
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const totalAssets = BN2Number(typeInfo.totalAssets, Number(typeInfo.decimalsUnderlyingToken));
-        const underlyingTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
-        let tvl = 0;
-        let balanceStakingToken = 0;
-        let totalSupplyStakingToken = 0;
-        let percentageOfSupplyUnderlyingPoolTokens = 0;
-        if (!typeInfo.isTrade) {
-            balanceStakingToken = BN2Number(typeInfo.balanceStakingToken, Number(typeInfo.decimalsStakingToken));
-            totalSupplyStakingToken = BN2Number(typeInfo.totalSupplyStakingToken, Number(typeInfo.decimalsStakingToken));
-            percentageOfSupplyUnderlyingPoolTokens = balanceStakingToken / totalSupplyStakingToken;
-            tvl = underlyingTokenPrice * Number(totalAssets) * percentageOfSupplyUnderlyingPoolTokens;
-        }
-        else {
-            tvl = Number(totalAssets) * underlyingTokenPrice;
-        }
-        const priceTargetToken = tvl / totalSupply;
-        return {
-            ...typeInfo,
-            balanceStakingToken,
-            totalSupplyStakingToken,
-            whitelistedSupplyTargetToken,
-            percentageOfSupplyUnderlyingPoolTokens,
-            totalSupply,
-            totalAssets,
-            blacklistedSupply,
-            tvl: tvl,
-            priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlyingToken }],
-        };
-    }
-}