@merkl/api 0.20.101 → 0.20.103

package/dist/src/utils/encodeCalls.js

@@ -1,4 +1,4 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { Erc20SubType } from "@/engine/campaignTVL/implementations/Erc20/Erc20SubType";
 import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerV3StablePoolInterface, BalancerVaultInterface, BeefyInterface, BunniV2HubInterface, BunniV2TokenInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, HourglassERC20TBTInterface, HourglassVedaLockDepositorV2Interface, IonicInterface, LPManagerHelperInterface, LPManagerInterface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxDatastoreInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, UniswapV3PoolInterface, VePufferInterface, ZFStableLPINterface, } from "@sdk";
 export function createCall(target, key, type, metaData) {
     switch (key) {
@@ -22,14 +22,14 @@ export function createCall(target, key, type, metaData) {
             return { allowFailure: true, callData: FraxlendInterface.encodeFunctionData("pricePerShare"), target };
         case "lp_price":
             switch (type) {
-                case tokenType.curve:
-                case tokenType.curve_gauge:
+                case Erc20SubType.curve:
+                case Erc20SubType.curve_gauge:
                     return { allowFailure: true, callData: CurveInterface.encodeFunctionData("lp_price"), target };
-                case tokenType.curve_2:
-                case tokenType.maha:
+                case Erc20SubType.curve_2:
+                case Erc20SubType.maha:
                     return { allowFailure: true, callData: CurveInterface.encodeFunctionData("get_virtual_price"), target };
                 default:
-                    throw new Error(`Need tokenType for this key ${key}`);
+                    throw new Error(`Need Erc20SubType for this key ${key}`);
             }
         case "coin0":
             return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [0]), target };
@@ -53,8 +53,8 @@ export function createCall(target, key, type, metaData) {
             return { allowFailure: true, callData: AuraInterface.encodeFunctionData("pid"), target };
         case "lp_token":
             switch (type) {
-                case tokenType.beraborrow_gauge:
-                case tokenType.beratrax_vault:
+                case Erc20SubType.beraborrow_gauge:
+                case Erc20SubType.beratrax_vault:
                     return { allowFailure: true, callData: ERC4626Interface.encodeFunctionData("asset"), target };
                 default:
                     return { allowFailure: true, callData: BalancerGaugeInterface.encodeFunctionData("lp_token"), target };
@@ -65,18 +65,18 @@ export function createCall(target, key, type, metaData) {
             return { allowFailure: true, callData: EulerInterface.encodeFunctionData("eVault"), target };
         case "exchangeRate":
             switch (type) {
-                case tokenType.pendle:
+                case Erc20SubType.pendle:
                     return { allowFailure: true, callData: PendleInterface.encodeFunctionData("exchangeRate"), target };
-                case tokenType.ionic:
+                case Erc20SubType.ionic:
                     return { allowFailure: true, callData: IonicInterface.encodeFunctionData("exchangeRateCurrent"), target };
-                case tokenType.moonwell:
-                case tokenType.venus:
-                case tokenType.reactor_fusion:
+                case Erc20SubType.moonwell:
+                case Erc20SubType.venus:
+                case Erc20SubType.reactor_fusion:
                     return { allowFailure: true, callData: MoonwellInterface.encodeFunctionData("exchangeRateStored"), target };
-                case tokenType.layerbank:
+                case Erc20SubType.layerbank:
                     return { allowFailure: true, callData: LayerBankInterface.encodeFunctionData("exchangeRate"), target };
                 default:
-                    throw new Error(`Need tokenType for this key ${key}`);
+                    throw new Error(`Need Erc20SubType for this key ${key}`);
             }
         case "shortToken": {
             return {
@@ -100,87 +100,87 @@ export function createCall(target, key, type, metaData) {
             };
         case "underlying":
             switch (type) {
-                case tokenType.pendle:
-                case tokenType.pendleYT:
+                case Erc20SubType.pendle:
+                case Erc20SubType.pendleYT:
                     return { allowFailure: true, callData: PendleInterface.encodeFunctionData("yieldToken"), target };
-                case tokenType.metamorpho:
+                case Erc20SubType.metamorpho:
                     return { allowFailure: true, callData: MetamorphoInterface.encodeFunctionData("asset"), target };
-                case tokenType.fluid:
+                case Erc20SubType.fluid:
                     return { allowFailure: true, callData: FluidInterface.encodeFunctionData("asset"), target };
-                case tokenType.euler_borrow:
-                case tokenType.maha:
-                case tokenType.euler_lend:
+                case Erc20SubType.euler_borrow:
+                case Erc20SubType.maha:
+                case Erc20SubType.euler_lend:
                     return {
                         allowFailure: true,
                         callData: EulerInterface.encodeFunctionData("asset"),
                         target,
                     };
-                case tokenType.curve_gauge:
+                case Erc20SubType.curve_gauge:
                     return { allowFailure: true, callData: BalancerGaugeInterface.encodeFunctionData("lp_token"), target };
-                case tokenType.fraxlend:
-                case tokenType.sturdy_aggregator:
-                case tokenType.sturdy_silo:
+                case Erc20SubType.fraxlend:
+                case Erc20SubType.sturdy_aggregator:
+                case Erc20SubType.sturdy_silo:
                     return { allowFailure: true, callData: FraxlendInterface.encodeFunctionData("asset"), target };
-                case tokenType.gearbox:
+                case Erc20SubType.gearbox:
                     return {
                         allowFailure: true,
                         callData: GearboxVaultInterface.encodeFunctionData("underlyingToken"),
                         target,
                     };
-                case tokenType.aura:
+                case Erc20SubType.aura:
                     return { allowFailure: true, callData: AuraInterface.encodeFunctionData("asset"), target };
-                case tokenType.ionic:
-                case tokenType.venus:
-                case tokenType.reactor_fusion:
+                case Erc20SubType.ionic:
+                case Erc20SubType.venus:
+                case Erc20SubType.reactor_fusion:
                     return { allowFailure: true, callData: IonicInterface.encodeFunctionData("underlying"), target };
-                case tokenType.layerbank:
+                case Erc20SubType.layerbank:
                     return { allowFailure: true, callData: LayerBankInterface.encodeFunctionData("underlying"), target };
-                case tokenType.moonwell:
+                case Erc20SubType.moonwell:
                     return { allowFailure: true, callData: MoonwellInterface.encodeFunctionData("underlying"), target };
-                case tokenType.radiant_lend:
-                case tokenType.radiant_borrow:
-                case tokenType.lendle_lending:
-                case tokenType.lendle_borrowing:
+                case Erc20SubType.radiant_lend:
+                case Erc20SubType.radiant_borrow:
+                case Erc20SubType.lendle_lending:
+                case Erc20SubType.lendle_borrowing:
                     return {
                         allowFailure: true,
                         callData: RadiantInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
                         target,
                     };
-                case tokenType.holdstation:
+                case Erc20SubType.holdstation:
                     return {
                         allowFailure: true,
                         callData: DefutureVaultInterface.encodeFunctionData("asset"),
                         target,
                     };
-                case tokenType.aave_lending:
-                case tokenType.sake_lending:
-                case tokenType.sake_borrowing:
-                case tokenType.aave_borrowing:
-                case tokenType.ironclad_lending:
-                case tokenType.ironclad_borrowing:
-                case tokenType.zerolend_lending:
-                case tokenType.zerolend_borrowing:
-                case tokenType.avalon_lending:
-                case tokenType.avalon_borrowing:
-                case tokenType.superlend_lending:
-                case tokenType.superlend_borrowing:
-                case tokenType.takotako_lending:
-                case tokenType.takotako_borrowing:
-                case tokenType.yei_borrowing:
-                case tokenType.yei_lending:
-                case tokenType.vicuna_borrowing:
-                case tokenType.vicuna_lending:
-                case tokenType.xlend_lending:
-                case tokenType.xlend_borrowing:
+                case Erc20SubType.aave_lending:
+                case Erc20SubType.sake_lending:
+                case Erc20SubType.sake_borrowing:
+                case Erc20SubType.aave_borrowing:
+                case Erc20SubType.ironclad_lending:
+                case Erc20SubType.ironclad_borrowing:
+                case Erc20SubType.zerolend_lending:
+                case Erc20SubType.zerolend_borrowing:
+                case Erc20SubType.avalon_lending:
+                case Erc20SubType.avalon_borrowing:
+                case Erc20SubType.superlend_lending:
+                case Erc20SubType.superlend_borrowing:
+                case Erc20SubType.takotako_lending:
+                case Erc20SubType.takotako_borrowing:
+                case Erc20SubType.yei_borrowing:
+                case Erc20SubType.yei_lending:
+                case Erc20SubType.vicuna_borrowing:
+                case Erc20SubType.vicuna_lending:
+                case Erc20SubType.xlend_lending:
+                case Erc20SubType.xlend_borrowing:
                     return { allowFailure: true, callData: AaveInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"), target };
-                case tokenType.hourglass:
+                case Erc20SubType.hourglass:
                     return {
                         allowFailure: true,
                         callData: HourglassVedaLockDepositorV2Interface.encodeFunctionData("getUnderlying"),
                         target,
                     };
                 default:
-                    throw new Error(`Need tokenType for this key ${key}, or unknown type ${type}`);
+                    throw new Error(`Need Erc20SubType for this key ${key}, or unknown type ${type}`);
             }
         case "calcNetShareValue":
             return {
@@ -222,8 +222,8 @@ export function createCall(target, key, type, metaData) {
             };
         case "totalSupply":
             switch (type) {
-                case tokenType.lendle_lending:
-                case tokenType.lendle_borrowing:
+                case Erc20SubType.lendle_lending:
+                case Erc20SubType.lendle_borrowing:
                     return {
                         allowFailure: true,
                         callData: LendleInterface.encodeFunctionData("scaledTotalSupply"),
@@ -282,49 +282,49 @@ export function createCall(target, key, type, metaData) {
             };
         case "totalAssets":
             switch (type) {
-                case tokenType.anglesLiquid:
-                case tokenType.cian:
-                case tokenType.rfx_slv:
-                case tokenType.metamorpho:
-                case tokenType.beratrax_vault:
-                case tokenType.beraborrow_gauge:
+                case Erc20SubType.anglesLiquid:
+                case Erc20SubType.cian:
+                case Erc20SubType.rfx_slv:
+                case Erc20SubType.metamorpho:
+                case Erc20SubType.beratrax_vault:
+                case Erc20SubType.beraborrow_gauge:
                     return {
                         allowFailure: true,
                         callData: ERC4626Interface.encodeFunctionData("totalAssets"),
                         target,
                     };
-                case tokenType.concrete:
+                case Erc20SubType.concrete:
                     return {
                         allowFailure: true,
                         callData: ERC4626Interface.encodeFunctionData("totalAssets"),
                         target,
                     };
-                case tokenType.euler_borrow:
+                case Erc20SubType.euler_borrow:
                     return {
                         allowFailure: true,
                         callData: EulerInterface.encodeFunctionData("totalBorrows"),
                         target,
                     };
-                case tokenType.euler_lend:
+                case Erc20SubType.euler_lend:
                     return {
                         allowFailure: true,
                         callData: EulerInterface.encodeFunctionData("totalAssets"),
                         target,
                     };
-                case tokenType.gearbox:
+                case Erc20SubType.gearbox:
                     return {
                         allowFailure: true,
                         callData: GearboxVaultInterface.encodeFunctionData("totalAssets"),
                         target,
                     };
-                case tokenType.compound:
+                case Erc20SubType.compound:
                     return {
                         allowFailure: true,
                         callData: CompoundInterface.encodeFunctionData("totalBorrow"),
                         target: target,
                     };
                 default:
-                    throw new Error(`Need tokenType for this key ${key}, or unknown type ${type}`);
+                    throw new Error(`Need Erc20SubType for this key ${key}, or unknown type ${type}`);
             }
         case "readTokens0":
             return {
@@ -346,7 +346,7 @@ export function createCall(target, key, type, metaData) {
             };
         case "minter":
             switch (type) {
-                case tokenType.spectra_lpt:
+                case Erc20SubType.spectra_lpt:
                     return {
                         allowFailure: true,
                         callData: CurveLPTokenInterface.encodeFunctionData("minter"),
@@ -367,7 +367,7 @@ export function createCall(target, key, type, metaData) {
             };
         case "getTokenAddresses":
             switch (type) {
-                case tokenType.tempestStaking: {
+                case Erc20SubType.tempestStaking: {
                     return {
                         allowFailure: true,
                         callData: RswEthStrategyInterface.encodeFunctionData("getTokenAddresses"),
@@ -383,7 +383,7 @@ export function createCall(target, key, type, metaData) {
             }
         case "getPositions":
             switch (type) {
-                case tokenType.tempestStaking: {
+                case Erc20SubType.tempestStaking: {
                     return {
                         allowFailure: true,
                         callData: RswEthStrategyInterface.encodeFunctionData("getPositions"),

package/dist/src/utils/generateCardName.d.ts

@@ -1,6 +1,6 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { Erc20SubType } from "@/engine/campaignTVL/implementations/Erc20/Erc20SubType";
 import type { Campaign, CampaignParameters } from "@sdk";
 export declare const stakingContractToStakingSymbol: {
     [key: string]: string;
 };
-export declare function generateCardName(type: tokenType, typeInfo: any, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, symbols?: string[], displayName?: string): string;
+export declare function generateCardName(type: Erc20SubType, typeInfo: any, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, symbols?: string[], displayName?: string): string;

package/dist/src/utils/generateCardName.js

@@ -1,4 +1,4 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { Erc20SubType } from "@/engine/campaignTVL/implementations/Erc20/Erc20SubType";
 import { capitalize } from "lodash";
 export const stakingContractToStakingSymbol = {
     "0x18eeD20f71BEf84B605253C89A7576E3634134C0": "CyberStaking",
@@ -24,167 +24,167 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
         return `${typeInfo.lockNFT !== undefined ? "Lock" : "Stake"} ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.stakingSymbol}`;
     }
     switch (type) {
-        case tokenType.uniswapv2:
-        case tokenType.poolside:
-        case tokenType.velodrome:
-        case tokenType.aerodrome:
-        case tokenType.dragonswap:
-        case tokenType.akron:
-        case tokenType.koi:
-        case tokenType.baseswap:
-        case tokenType.fenix:
-        case tokenType.zkswap:
-        case tokenType.ra:
-        case tokenType.syncswap:
-        case tokenType.pancakeswap:
-        case tokenType.traderJoe:
-        case tokenType.katana:
+        case Erc20SubType.uniswapv2:
+        case Erc20SubType.poolside:
+        case Erc20SubType.velodrome:
+        case Erc20SubType.aerodrome:
+        case Erc20SubType.dragonswap:
+        case Erc20SubType.akron:
+        case Erc20SubType.koi:
+        case Erc20SubType.baseswap:
+        case Erc20SubType.fenix:
+        case Erc20SubType.zkswap:
+        case Erc20SubType.ra:
+        case Erc20SubType.syncswap:
+        case Erc20SubType.pancakeswap:
+        case Erc20SubType.traderJoe:
+        case Erc20SubType.katana:
             return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
-        case tokenType.pendleYT:
+        case Erc20SubType.pendleYT:
             return `Hold ${capitalize(typeInfo.protocol)} ${typeInfo.name}`;
-        case tokenType.pendle:
+        case Erc20SubType.pendle:
             return `Provide ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.balancerGauge:
+        case Erc20SubType.balancerGauge:
             return `${capitalize(typeInfo.protocol)} ${symbols.join("-")}`;
-        case tokenType.beraborrow_gauge:
-        case tokenType.beratrax_vault:
+        case Erc20SubType.beraborrow_gauge:
+        case Erc20SubType.beratrax_vault:
             return `Deposit ${symbols.join("-")} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.balancerPool: {
+        case Erc20SubType.balancerPool: {
             return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${symbols.join("-")}`;
         }
-        case tokenType.balancerV3: {
+        case Erc20SubType.balancerV3: {
             return `Provide liquidity to ${capitalize(typeInfo.protocol)} Boosted ${symbols.join("-")}`;
         }
-        case tokenType.aura:
+        case Erc20SubType.aura:
             return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${symbols.join("-")}`;
-        case tokenType.gearbox:
+        case Erc20SubType.gearbox:
             return `${capitalize(typeInfo.protocol)} ${typeInfo.symbolUnderlyingToken} Deposit`;
-        case tokenType.compound:
+        case Erc20SubType.compound:
             return `Lend ${typeInfo.symbolBaseToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.radiant_lend: {
+        case Erc20SubType.radiant_lend: {
             let cardToken = typeInfo.symbolUnderlyingToken;
             if (campaign.campaignParameters.symbolTargetToken.startsWith("r")) {
                 cardToken = campaign.campaignParameters.symbolTargetToken.substring(1);
             }
             return `Lend ${cardToken} on ${capitalize(typeInfo.protocol)}`;
         }
-        case tokenType.rfx:
+        case Erc20SubType.rfx:
             return `Supply ${typeInfo.symbolShortToken}-${typeInfo.symbolLongToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.radiant_borrow:
-        case tokenType.aave_borrowing:
-        case tokenType.sake_borrowing:
-        case tokenType.vicuna_borrowing:
-        case tokenType.yei_borrowing:
-        case tokenType.ironclad_borrowing:
-        case tokenType.zerolend_borrowing:
-        case tokenType.avalon_borrowing:
-        case tokenType.superlend_borrowing:
-        case tokenType.takotako_borrowing:
-        case tokenType.lendle_borrowing:
-        case tokenType.euler_borrow:
+        case Erc20SubType.radiant_borrow:
+        case Erc20SubType.aave_borrowing:
+        case Erc20SubType.sake_borrowing:
+        case Erc20SubType.vicuna_borrowing:
+        case Erc20SubType.yei_borrowing:
+        case Erc20SubType.ironclad_borrowing:
+        case Erc20SubType.zerolend_borrowing:
+        case Erc20SubType.avalon_borrowing:
+        case Erc20SubType.superlend_borrowing:
+        case Erc20SubType.takotako_borrowing:
+        case Erc20SubType.lendle_borrowing:
+        case Erc20SubType.euler_borrow:
             return `Borrow ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.ionic:
-        case tokenType.layerbank:
-        case tokenType.moonwell:
-        case tokenType.splice:
-        case tokenType.aave_lending:
-        case tokenType.vicuna_lending:
-        case tokenType.sake_lending:
-        case tokenType.yei_lending:
-        case tokenType.ironclad_lending:
-        case tokenType.zerolend_lending:
-        case tokenType.avalon_lending:
-        case tokenType.takotako_lending:
-        case tokenType.superlend_lending:
-        case tokenType.lendle_lending:
-        case tokenType.fraxlend:
-        case tokenType.venus:
-        case tokenType.reactor_fusion:
-        case tokenType.euler_lend:
-        case tokenType.fluid:
+        case Erc20SubType.ionic:
+        case Erc20SubType.layerbank:
+        case Erc20SubType.moonwell:
+        case Erc20SubType.splice:
+        case Erc20SubType.aave_lending:
+        case Erc20SubType.vicuna_lending:
+        case Erc20SubType.sake_lending:
+        case Erc20SubType.yei_lending:
+        case Erc20SubType.ironclad_lending:
+        case Erc20SubType.zerolend_lending:
+        case Erc20SubType.avalon_lending:
+        case Erc20SubType.takotako_lending:
+        case Erc20SubType.superlend_lending:
+        case Erc20SubType.lendle_lending:
+        case Erc20SubType.fraxlend:
+        case Erc20SubType.venus:
+        case Erc20SubType.reactor_fusion:
+        case Erc20SubType.euler_lend:
+        case Erc20SubType.fluid:
             return `Lend ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.xlend_lending:
+        case Erc20SubType.xlend_lending:
             return `Lend ${typeInfo.symbolUnderlyingToken} on Extrafi XLend`;
-        case tokenType.xlend_borrowing:
+        case Erc20SubType.xlend_borrowing:
             return `Borrow ${typeInfo.symbolUnderlyingToken} on Extrafi XLend`;
-        case tokenType.metamorpho:
+        case Erc20SubType.metamorpho:
             return `Supply to ${typeInfo.name} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.sturdy_aggregator:
+        case Erc20SubType.sturdy_aggregator:
             return `Supply ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)} ${typeInfo.name}`;
-        case tokenType.sturdy_silo:
+        case Erc20SubType.sturdy_silo:
             return `Supply ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)} ${typeInfo.symbolCollateral} Silo`;
-        case tokenType.curve:
-        case tokenType.curve_2:
+        case Erc20SubType.curve:
+        case Erc20SubType.curve_2:
             return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${Object.values(typeInfo.poolTokens).join("-")}`;
-        case tokenType.enzyme:
+        case Erc20SubType.enzyme:
             return `Supply to the ${typeInfo.name} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.filament:
+        case Erc20SubType.filament:
             return `Earn Yield on ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.silostaking:
+        case Erc20SubType.silostaking:
             return `Stake ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.beefy:
+        case Erc20SubType.beefy:
             return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
-        case tokenType.toros:
+        case Erc20SubType.toros:
             return `${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.ironcladStaking:
+        case Erc20SubType.ironcladStaking:
             return `Stake ${campaign.campaignParameters.symbolTargetToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.woofi:
+        case Erc20SubType.woofi:
             return `Supercharge ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.maverickBoostedPosition:
+        case Erc20SubType.maverickBoostedPosition:
             return `Maverick Boosted Position ${campaign.campaignParameters.symbolTargetToken}`;
-        case tokenType.zkSwapThreePool:
+        case Erc20SubType.zkSwapThreePool:
             return `Provide liquidity to ${capitalize(typeInfo.protocol)} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2}`;
-        case tokenType.maha:
+        case Erc20SubType.maha:
             return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} LP on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.curve_gauge:
+        case Erc20SubType.curve_gauge:
             if (!!typeInfo.symbolToken2) {
                 return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2} LP on ${capitalize(typeInfo.protocol)}`;
             }
             return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} LP on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.tempest:
-        case tokenType.tempestStaking:
+        case Erc20SubType.tempest:
+        case Erc20SubType.tempestStaking:
             return `Deposit into ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} vault on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.holdstation:
+        case Erc20SubType.holdstation:
             return `Hold vault token ${campaign.campaignParameters.symbolTargetToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.cpmmGamma:
+        case Erc20SubType.cpmmGamma:
             return `Provide ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.crosscurve:
+        case Erc20SubType.crosscurve:
             if (typeInfo.name.toLowerCase() === "eywa/usdt") {
                 return `Curve ${typeInfo.name}`;
             }
             return `${typeInfo.name}`;
-        case tokenType.curveNPool:
+        case Erc20SubType.curveNPool:
             return `Curve ${typeInfo.name}`;
-        case tokenType.vicuna: {
+        case Erc20SubType.vicuna: {
             const parsedName = typeInfo.name.split(" ");
             parsedName.shift();
             const parsedNameForCard = parsedName.join(" ");
             return `Deposit liquidity on ${parsedNameForCard.replace("BALANCER", "Beets")} vault on Vicuna`;
         }
-        case tokenType.satlayer:
+        case Erc20SubType.satlayer:
             return `Restake ${typeInfo.symbolUnderlyingToken} on ${capitalize(typeInfo.protocol)}`;
-        case tokenType.veda:
+        case Erc20SubType.veda:
             return `Deposit into ${typeInfo.name.replace("Ether.Fi", "Veda")}`;
-        case tokenType.concrete:
-        case tokenType.cian:
+        case Erc20SubType.concrete:
+        case Erc20SubType.cian:
             return `Deposit ${typeInfo.symbolAsset} into ${typeInfo.name.replace("Ether.Fi", "Veda")}`;
-        case tokenType.rfx_slv:
+        case Erc20SubType.rfx_slv:
             return `Deposit ${typeInfo.symbolAsset} into ${typeInfo.name}`;
-        case tokenType.equalizer_gauge:
+        case Erc20SubType.equalizer_gauge:
             return `${displayName}`;
-        case tokenType.anglesLiquid:
+        case Erc20SubType.anglesLiquid:
             return `Deposit into ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) Vault`;
-        case tokenType.spectra_lpt:
+        case Erc20SubType.spectra_lpt:
             return `Provide liquidity on Spectra to ${typeInfo.name}`;
-        case tokenType.spectra_yt:
+        case Erc20SubType.spectra_yt:
             return `Hold Spectra ${typeInfo.name}`;
-        case tokenType.hourglass:
+        case Erc20SubType.hourglass:
             return `Deposit ${typeInfo.symbolUnderlyingToken} into Hourglass`;
-        case tokenType.hanji_liquidity_vault_token:
+        case Erc20SubType.hanji_liquidity_vault_token:
             return "Provide Liquidity on Hanji Vault";
-        case tokenType.bunniV2:
+        case Erc20SubType.bunniV2:
             return `Provide Liquidity on Bunni V2 ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
-        case tokenType.gamma:
+        case Erc20SubType.gamma:
             return `Provide liquidity to Gamma ${capitalize(typeInfo.protocol)} ${campaign.campaignParameters.symbolTargetToken} vault`;
         default:
             // OVERRIDE