@merkl/api 0.20.101 → 0.20.103

package/dist/src/engine/erc20SubTypeProcessors/implementations/processorMapping.js

@@ -1,5 +1,5 @@
+import { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
 import { AaveProcessor } from "./AaveProcessor";
 import { AnglesLiquidProcessor } from "./AnglesLiquid";
 import { AssetProcessor } from "./AssetProcessor";
@@ -47,103 +47,103 @@ import { CurveProcessor } from "./curveProcessor";
 import { StakedCurveProcessor } from "./stakedCurveProcessor";
 import { xU308Processor } from "./xU308Processor";
 export const processorMapping = {
-    [tokenType.uniswapv2]: UniswapProcessor,
-    [tokenType.balancerGauge]: BalancerGaugeProcessor,
-    [tokenType.balancerPool]: BalancerPoolProcessor,
-    [tokenType.syncswap]: UniswapProcessor,
-    [tokenType.ra]: UniswapProcessor,
-    [tokenType.yei_borrowing]: AaveProcessor,
-    [tokenType.yei_lending]: AaveProcessor,
-    [tokenType.zerolend_borrowing]: AaveProcessor,
-    [tokenType.zerolend_lending]: AaveProcessor,
-    [tokenType.ironclad_lending]: AaveProcessor,
-    [tokenType.ironclad_borrowing]: AaveProcessor,
-    [tokenType.poolside]: UniswapProcessor,
-    [tokenType.gearbox]: GearboxProcessor,
-    [tokenType.compound]: CompoundProcessor,
-    [tokenType.radiant_borrow]: RadiantProcessor,
-    [tokenType.radiant_lend]: RadiantProcessor,
-    [tokenType.ionic]: AssetProcessor,
-    [tokenType.metamorpho]: MetamorphoProcessor,
-    [tokenType.aerodrome]: UniswapProcessor,
-    [tokenType.velodrome]: UniswapProcessor,
-    [tokenType.moonwell]: AssetProcessor,
-    [tokenType.aave_lending]: AaveProcessor,
-    [tokenType.aave_borrowing]: AaveProcessor,
-    [tokenType.fraxlend]: FraxProcessor,
-    [tokenType.curve]: CurveProcessor,
-    [tokenType.sturdy_aggregator]: FraxProcessor,
-    [tokenType.koi]: UniswapProcessor,
-    [tokenType.baseswap]: UniswapProcessor,
-    [tokenType.layerbank]: AssetProcessor,
-    [tokenType.zkswap]: UniswapProcessor,
-    [tokenType.akron]: UniswapProcessor,
-    [tokenType.aura]: AuraProcessor,
-    [tokenType.dragonswap]: UniswapProcessor,
-    [tokenType.sturdy_silo]: SturdySiloProcessor,
-    [tokenType.silostaking]: FraxProcessor,
-    [tokenType.fluid]: FluidProcessor,
-    [tokenType.filament]: FluidProcessor,
-    [tokenType.enzyme]: EnzymeProcessor,
-    [tokenType.curve_2]: CurveProcessor,
-    [tokenType.crosscurve]: CurveNPoolProcessor,
-    [tokenType.fenix]: UniswapProcessor,
-    [tokenType.euler_lend]: EulerLendProcessor,
-    [tokenType.euler_borrow]: EulerBorrowProcessor,
-    [tokenType.beefy]: BeefyProcessor,
-    [tokenType.unknown]: GenericProcessor,
-    [tokenType.toros]: TorosProcessor,
-    [tokenType.splice]: SpliceProcessor,
-    [tokenType.pendle]: PendleProcessor,
-    [tokenType.ironcladStaking]: GenericProcessor,
-    [tokenType.rfx]: RfxProcessor,
-    [tokenType.woofi]: WoofiProcessor,
-    [tokenType.maverickBoostedPosition]: MaverickBPProcessor,
-    [tokenType.zkSwapThreePool]: ZkSwapThreePoolProcessor,
-    [tokenType.maha]: StakedCurveProcessor,
-    [tokenType.tempest]: TempestVaultProcessor,
-    [tokenType.pendleYT]: PendleYTProcessor,
-    [tokenType.pancakeswap]: UniswapProcessor,
-    [tokenType.tempestStaking]: TempestVaultProcessor,
-    [tokenType.holdstation]: HoldStationProcessor,
-    [tokenType.noLinkVault]: NoLinkVaultProcessor,
-    [tokenType.cpmmGamma]: GammaProcessor,
-    [tokenType.venus]: AssetProcessor,
-    [tokenType.reactor_fusion]: AssetProcessor,
-    [tokenType.vicuna]: VicunaProcessor,
-    [tokenType.traderJoe]: UniswapProcessor,
-    [tokenType.curveNPool]: CurveNPoolProcessor,
-    [tokenType.avalon_lending]: AaveProcessor,
-    [tokenType.avalon_borrowing]: AaveProcessor,
-    [tokenType.satlayer]: SatlayerProcessor,
-    [tokenType.veda]: NoLinkVaultProcessor,
-    [tokenType.superlend_lending]: AaveProcessor,
-    [tokenType.superlend_borrowing]: AaveProcessor,
-    [tokenType.cian]: ERC4626Processor,
-    [tokenType.concrete]: ERC4626Processor,
-    [tokenType.lendle_borrowing]: AaveProcessor,
-    [tokenType.lendle_lending]: AaveProcessor,
-    [tokenType.takotako_lending]: AaveProcessor,
-    [tokenType.takotako_borrowing]: AaveProcessor,
-    [tokenType.equalizer_gauge]: EqualizerGaugeProcessor,
-    [tokenType.vicuna_borrowing]: AaveProcessor,
-    [tokenType.vicuna_lending]: AaveProcessor,
-    [tokenType.anglesLiquid]: AnglesLiquidProcessor,
-    [tokenType.spectra_lpt]: SpectraProcessor,
-    [tokenType.spectra_yt]: SpectraYTProcessor,
-    [tokenType.rfx_slv]: ERC4626Processor,
-    [tokenType.hourglass]: HourglassProcessor,
-    [tokenType.katana]: UniswapProcessor,
-    [tokenType.balancerV3]: BalancerV3PoolProcessor,
-    [tokenType.hanji_liquidity_vault_token]: HanjiVaultProcessor,
-    [tokenType.xU308]: xU308Processor,
-    [tokenType.bunniV2]: BunniV2Processor,
-    [tokenType.beraborrow_gauge]: BEXRewardGaugeProcessor,
-    [tokenType.beratrax_vault]: BEXRewardGaugeProcessor,
-    [tokenType.xlend_borrowing]: AaveProcessor,
-    [tokenType.xlend_lending]: AaveProcessor,
-    [tokenType.curve_gauge]: StakedCurveProcessor,
-    [tokenType.sake_borrowing]: AaveProcessor,
-    [tokenType.sake_lending]: AaveProcessor,
-    [tokenType.gamma]: GammaALMProcessor,
+    [Erc20SubType.uniswapv2]: UniswapProcessor,
+    [Erc20SubType.balancerGauge]: BalancerGaugeProcessor,
+    [Erc20SubType.balancerPool]: BalancerPoolProcessor,
+    [Erc20SubType.syncswap]: UniswapProcessor,
+    [Erc20SubType.ra]: UniswapProcessor,
+    [Erc20SubType.yei_borrowing]: AaveProcessor,
+    [Erc20SubType.yei_lending]: AaveProcessor,
+    [Erc20SubType.zerolend_borrowing]: AaveProcessor,
+    [Erc20SubType.zerolend_lending]: AaveProcessor,
+    [Erc20SubType.ironclad_lending]: AaveProcessor,
+    [Erc20SubType.ironclad_borrowing]: AaveProcessor,
+    [Erc20SubType.poolside]: UniswapProcessor,
+    [Erc20SubType.gearbox]: GearboxProcessor,
+    [Erc20SubType.compound]: CompoundProcessor,
+    [Erc20SubType.radiant_borrow]: RadiantProcessor,
+    [Erc20SubType.radiant_lend]: RadiantProcessor,
+    [Erc20SubType.ionic]: AssetProcessor,
+    [Erc20SubType.metamorpho]: MetamorphoProcessor,
+    [Erc20SubType.aerodrome]: UniswapProcessor,
+    [Erc20SubType.velodrome]: UniswapProcessor,
+    [Erc20SubType.moonwell]: AssetProcessor,
+    [Erc20SubType.aave_lending]: AaveProcessor,
+    [Erc20SubType.aave_borrowing]: AaveProcessor,
+    [Erc20SubType.fraxlend]: FraxProcessor,
+    [Erc20SubType.curve]: CurveProcessor,
+    [Erc20SubType.sturdy_aggregator]: FraxProcessor,
+    [Erc20SubType.koi]: UniswapProcessor,
+    [Erc20SubType.baseswap]: UniswapProcessor,
+    [Erc20SubType.layerbank]: AssetProcessor,
+    [Erc20SubType.zkswap]: UniswapProcessor,
+    [Erc20SubType.akron]: UniswapProcessor,
+    [Erc20SubType.aura]: AuraProcessor,
+    [Erc20SubType.dragonswap]: UniswapProcessor,
+    [Erc20SubType.sturdy_silo]: SturdySiloProcessor,
+    [Erc20SubType.silostaking]: FraxProcessor,
+    [Erc20SubType.fluid]: FluidProcessor,
+    [Erc20SubType.filament]: FluidProcessor,
+    [Erc20SubType.enzyme]: EnzymeProcessor,
+    [Erc20SubType.curve_2]: CurveProcessor,
+    [Erc20SubType.crosscurve]: CurveNPoolProcessor,
+    [Erc20SubType.fenix]: UniswapProcessor,
+    [Erc20SubType.euler_lend]: EulerLendProcessor,
+    [Erc20SubType.euler_borrow]: EulerBorrowProcessor,
+    [Erc20SubType.beefy]: BeefyProcessor,
+    [Erc20SubType.unknown]: GenericProcessor,
+    [Erc20SubType.toros]: TorosProcessor,
+    [Erc20SubType.splice]: SpliceProcessor,
+    [Erc20SubType.pendle]: PendleProcessor,
+    [Erc20SubType.ironcladStaking]: GenericProcessor,
+    [Erc20SubType.rfx]: RfxProcessor,
+    [Erc20SubType.woofi]: WoofiProcessor,
+    [Erc20SubType.maverickBoostedPosition]: MaverickBPProcessor,
+    [Erc20SubType.zkSwapThreePool]: ZkSwapThreePoolProcessor,
+    [Erc20SubType.maha]: StakedCurveProcessor,
+    [Erc20SubType.tempest]: TempestVaultProcessor,
+    [Erc20SubType.pendleYT]: PendleYTProcessor,
+    [Erc20SubType.pancakeswap]: UniswapProcessor,
+    [Erc20SubType.tempestStaking]: TempestVaultProcessor,
+    [Erc20SubType.holdstation]: HoldStationProcessor,
+    [Erc20SubType.noLinkVault]: NoLinkVaultProcessor,
+    [Erc20SubType.cpmmGamma]: GammaProcessor,
+    [Erc20SubType.venus]: AssetProcessor,
+    [Erc20SubType.reactor_fusion]: AssetProcessor,
+    [Erc20SubType.vicuna]: VicunaProcessor,
+    [Erc20SubType.traderJoe]: UniswapProcessor,
+    [Erc20SubType.curveNPool]: CurveNPoolProcessor,
+    [Erc20SubType.avalon_lending]: AaveProcessor,
+    [Erc20SubType.avalon_borrowing]: AaveProcessor,
+    [Erc20SubType.satlayer]: SatlayerProcessor,
+    [Erc20SubType.veda]: NoLinkVaultProcessor,
+    [Erc20SubType.superlend_lending]: AaveProcessor,
+    [Erc20SubType.superlend_borrowing]: AaveProcessor,
+    [Erc20SubType.cian]: ERC4626Processor,
+    [Erc20SubType.concrete]: ERC4626Processor,
+    [Erc20SubType.lendle_borrowing]: AaveProcessor,
+    [Erc20SubType.lendle_lending]: AaveProcessor,
+    [Erc20SubType.takotako_lending]: AaveProcessor,
+    [Erc20SubType.takotako_borrowing]: AaveProcessor,
+    [Erc20SubType.equalizer_gauge]: EqualizerGaugeProcessor,
+    [Erc20SubType.vicuna_borrowing]: AaveProcessor,
+    [Erc20SubType.vicuna_lending]: AaveProcessor,
+    [Erc20SubType.anglesLiquid]: AnglesLiquidProcessor,
+    [Erc20SubType.spectra_lpt]: SpectraProcessor,
+    [Erc20SubType.spectra_yt]: SpectraYTProcessor,
+    [Erc20SubType.rfx_slv]: ERC4626Processor,
+    [Erc20SubType.hourglass]: HourglassProcessor,
+    [Erc20SubType.katana]: UniswapProcessor,
+    [Erc20SubType.balancerV3]: BalancerV3PoolProcessor,
+    [Erc20SubType.hanji_liquidity_vault_token]: HanjiVaultProcessor,
+    [Erc20SubType.xU308]: xU308Processor,
+    [Erc20SubType.bunniV2]: BunniV2Processor,
+    [Erc20SubType.beraborrow_gauge]: BEXRewardGaugeProcessor,
+    [Erc20SubType.beratrax_vault]: BEXRewardGaugeProcessor,
+    [Erc20SubType.xlend_borrowing]: AaveProcessor,
+    [Erc20SubType.xlend_lending]: AaveProcessor,
+    [Erc20SubType.curve_gauge]: StakedCurveProcessor,
+    [Erc20SubType.sake_borrowing]: AaveProcessor,
+    [Erc20SubType.sake_lending]: AaveProcessor,
+    [Erc20SubType.gamma]: GammaALMProcessor,
 };

package/dist/src/engine/erc20SubTypeProcessors/implementations/stakedCurveProcessor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawStakedCurve;
     call: string;
@@ -49,6 +49,6 @@ export declare class StakedCurveProcessor extends GenericProcessor<callKeysStake
         round4: callType[];
     };
     processingRound3(typeInfo: dataRawStakedCurve): void;
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawStakedCurve, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeStakedCurve>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawStakedCurve, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeStakedCurve>;
 }
 export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/stakedCurveProcessor.js

@@ -1,8 +1,8 @@
 import { generateCardName } from "@/utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { BigNumber } from "ethers";
+import { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
 export class StakedCurveProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
@@ -54,7 +54,7 @@ export class StakedCurveProcessor extends GenericProcessor {
                 { symbol: typeInfo.symbolToken1, address: typeInfo.token1 },
             ];
         }
-        if (type === tokenType.curve_2) {
+        if (type === Erc20SubType.curve_2) {
             const prices = [];
             for (const symbol of Object.values(typeInfo.poolTokens)) {
                 const price = (await pricer.get({ symbol: symbol })) ?? 0;

package/dist/src/engine/erc20SubTypeProcessors/implementations/xU308Processor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawxU308;
     call: string;
@@ -33,6 +33,6 @@ export declare class xU308Processor extends GenericProcessor<callKeysxU308, data
         round4: callType[];
     };
     processingRound2(typeInfo: dataRawxU308): void;
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawxU308, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypexU308>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawxU308, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypexU308>;
 }
 export {};

package/dist/src/engine/erc20SubTypeProcessors/subtypesPrices.d.ts

@@ -1,4 +1,5 @@
 import type { Pricer } from "@/utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
-import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenPricesInfo(index: number, type: tokenType, typeInfo: any, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+import { Erc20SubType } from "../campaignTVL/implementations/Erc20/Erc20SubType";
+import type { tokenTypeStruct } from "./tokenTypeStruct";
+export declare function getTokenPricesInfo(index: number, type: Erc20SubType, typeInfo: any, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;

package/dist/src/engine/erc20SubTypeProcessors/subtypesPrices.js

@@ -1,5 +1,5 @@
 import { TokenService } from "@/modules/v4/token/token.service";
-import { tokenType } from "./helpers/tokenType";
+import { Erc20SubType } from "../campaignTVL/implementations/Erc20/Erc20SubType";
 import { processorMapping } from "./implementations/processorMapping";
 export async function getTokenPricesInfo(index, type, typeInfo, calls, campaign, pricer) {
     const ProcessorClass = processorMapping[type];
@@ -13,7 +13,7 @@ export async function getTokenPricesInfo(index, type, typeInfo, calls, campaign,
     catch (error) {
         console.error(error);
         return {
-            type: tokenType.unknown,
+            type: Erc20SubType.unknown,
             calls: [],
             typeInfo: {
                 totalSupply: 0,

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound1.d.ts

@@ -1,3 +1,4 @@
 import type { Campaign, CampaignParameters, ResultDto } from "@sdk";
-import { type tokenTypeStruct } from "./helpers/tokenType";
+import type { tokenTypeStruct } from "./tokenTypeStruct";
+export declare function processNamingConditionsInOrder(name: string, targetToken: string, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct | undefined;
 export declare function getTokenTypeRound1(calls: ResultDto[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound1.js

@@ -1,169 +1,169 @@
 import { decodeCall, decodeReturnValue } from "@/utils/decodeCalls";
+import { Erc20SubType } from "../campaignTVL/implementations/Erc20/Erc20SubType";
 import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
 import { getTypeFromAddressChain } from "./helpers/hardcoded";
 import { getTypeFromOwnerAddress } from "./helpers/ownerFinder";
-import { tokenType } from "./helpers/tokenType";
 import { processorMapping } from "./implementations/processorMapping";
 function satisfiesNameConditions(name, type) {
     const lowerCaseName = name.toLowerCase();
     switch (type) {
-        case tokenType.hourglass:
+        case Erc20SubType.hourglass:
             return lowerCaseName.startsWith("ct-hourglass");
-        case tokenType.fraxlend:
+        case Erc20SubType.fraxlend:
             return lowerCaseName.includes("fraxlend interest bearing");
-        case tokenType.sturdy_aggregator:
+        case Erc20SubType.sturdy_aggregator:
             return lowerCaseName.includes("aggregator");
-        case tokenType.sturdy_silo:
+        case Erc20SubType.sturdy_silo:
             return lowerCaseName.includes("sturdy interest bearing");
-        case tokenType.aura:
+        case Erc20SubType.aura:
             return lowerCaseName.includes("aura deposit vault");
-        case tokenType.poolside:
+        case Erc20SubType.poolside:
             return lowerCaseName.includes("poolside");
-        case tokenType.anglesLiquid:
+        case Erc20SubType.anglesLiquid:
             return lowerCaseName.includes("angles liquid");
-        case tokenType.balancerGauge:
+        case Erc20SubType.balancerGauge:
             return (lowerCaseName.includes("balancer") &&
                 !lowerCaseName.includes("aura deposit vault") &&
                 !lowerCaseName.startsWith("vifi"));
-        case tokenType.beraborrow_gauge:
+        case Erc20SubType.beraborrow_gauge:
             return lowerCaseName.includes("beraborrow") && lowerCaseName.includes("bpt");
-        case tokenType.beratrax_vault:
+        case Erc20SubType.beratrax_vault:
             return lowerCaseName.startsWith("beratrax vault");
-        case tokenType.gearbox:
+        case Erc20SubType.gearbox:
             return lowerCaseName.includes("farming of") || lowerCaseName.startsWith("trade");
-        case tokenType.euler_borrow:
+        case Erc20SubType.euler_borrow:
             return lowerCaseName.startsWith("debt token of evk vault");
-        case tokenType.euler_lend:
+        case Erc20SubType.euler_lend:
             return lowerCaseName.includes("evk vault");
-        case tokenType.fluid:
+        case Erc20SubType.fluid:
             return lowerCaseName.startsWith("fluid");
-        case tokenType.filament:
+        case Erc20SubType.filament:
             return lowerCaseName.startsWith("filament");
-        case tokenType.radiant_lend:
+        case Erc20SubType.radiant_lend:
             return lowerCaseName.includes("radiant interest");
-        case tokenType.radiant_borrow:
+        case Erc20SubType.radiant_borrow:
             return lowerCaseName.includes("radiant variable debt");
-        case tokenType.ionic:
+        case Erc20SubType.ionic:
             return lowerCaseName.includes("ionic");
-        case tokenType.venus:
+        case Erc20SubType.venus:
             return lowerCaseName.startsWith("venus");
-        case tokenType.reactor_fusion:
+        case Erc20SubType.reactor_fusion:
             return lowerCaseName.startsWith("reactorfusion");
-        case tokenType.rfx:
+        case Erc20SubType.rfx:
             return lowerCaseName.includes("rfx");
-        case tokenType.rfx_slv:
+        case Erc20SubType.rfx_slv:
             return lowerCaseName.includes("rfx") && lowerCaseName.includes("shared liquidity vault");
-        case tokenType.layerbank:
+        case Erc20SubType.layerbank:
             return lowerCaseName.includes("layerbank");
-        case tokenType.moonwell:
+        case Erc20SubType.moonwell:
             return lowerCaseName.includes("moonwell");
-        case tokenType.curve_2:
+        case Erc20SubType.curve_2:
             return (lowerCaseName === "crvusd/frax" ||
                 lowerCaseName === "ezeth/wfrxeth" ||
                 lowerCaseName === "pufeth/wsteth" ||
                 lowerCaseName === "hai/lusd" ||
                 lowerCaseName === "weth/pufeth");
-        case tokenType.crosscurve:
+        case Erc20SubType.crosscurve:
             return lowerCaseName.startsWith("crosscurve") || lowerCaseName === "eywa/usdt";
-        case tokenType.curveNPool:
+        case Erc20SubType.curveNPool:
             return lowerCaseName === "zai/usdc" || lowerCaseName === "zai/szai";
-        case tokenType.silostaking:
+        case Erc20SubType.silostaking:
             return lowerCaseName === "isei";
-        case tokenType.beefy:
+        case Erc20SubType.beefy:
             return lowerCaseName.startsWith("moo velo");
-        case tokenType.uniswapv2:
+        case Erc20SubType.uniswapv2:
             return lowerCaseName.includes("uniswap") && lowerCaseName !== "uniswap";
-        case tokenType.fenix:
+        case Erc20SubType.fenix:
             return lowerCaseName.includes("stablev1 amm");
-        case tokenType.ra:
+        case Erc20SubType.ra:
             return lowerCaseName.includes("volatile pair -") || lowerCaseName.includes("correlated pair -");
-        case tokenType.syncswap:
+        case Erc20SubType.syncswap:
             return lowerCaseName.includes("syncswap");
-        case tokenType.aave_lending:
+        case Erc20SubType.aave_lending:
             return lowerCaseName.includes("aave");
-        case tokenType.aave_borrowing:
+        case Erc20SubType.aave_borrowing:
             return lowerCaseName.includes("aave") && lowerCaseName.includes("debt");
-        case tokenType.xlend_lending:
+        case Erc20SubType.xlend_lending:
             return ((lowerCaseName.startsWith("extrafi x") || lowerCaseName.startsWith("extrax")) && !lowerCaseName.includes("debt"));
-        case tokenType.xlend_borrowing:
+        case Erc20SubType.xlend_borrowing:
             return ((lowerCaseName.startsWith("extrafi x") || lowerCaseName.startsWith("extrax")) && lowerCaseName.includes("debt"));
-        case tokenType.curve_gauge:
+        case Erc20SubType.curve_gauge:
             return lowerCaseName.startsWith("curve.fi") && lowerCaseName.includes("gauge");
-        case tokenType.vicuna_lending:
+        case Erc20SubType.vicuna_lending:
             return lowerCaseName.startsWith("vicuna sonic") && !lowerCaseName.includes("debt");
-        case tokenType.vicuna_borrowing:
+        case Erc20SubType.vicuna_borrowing:
             return lowerCaseName.startsWith("vicuna sonic variable debt");
-        case tokenType.yei_borrowing:
+        case Erc20SubType.yei_borrowing:
             return ((lowerCaseName.startsWith("yei") || (lowerCaseName.includes("aave") && lowerCaseName.includes("yei"))) &&
                 lowerCaseName.includes("debt"));
-        case tokenType.ironclad_borrowing:
+        case Erc20SubType.ironclad_borrowing:
             return ((lowerCaseName.startsWith("ironclad") ||
                 (lowerCaseName.includes("aave") && lowerCaseName.includes("ironclad"))) &&
                 lowerCaseName.includes("debt") &&
                 name.toLowerCase() !== "ironclad token");
-        case tokenType.zerolend_borrowing:
+        case Erc20SubType.zerolend_borrowing:
             return lowerCaseName.includes("zerolend") && lowerCaseName.includes("debt");
-        case tokenType.yei_lending:
+        case Erc20SubType.yei_lending:
             return lowerCaseName.startsWith("yei") || (lowerCaseName.includes("aave") && lowerCaseName.includes("yei"));
-        case tokenType.ironclad_lending:
+        case Erc20SubType.ironclad_lending:
             return ((lowerCaseName.startsWith("ironclad") ||
                 (lowerCaseName.includes("aave") && lowerCaseName.includes("ironclad"))) &&
                 name.toLowerCase() !== "ironclad token");
-        case tokenType.zerolend_lending:
+        case Erc20SubType.zerolend_lending:
             return lowerCaseName.includes("zerolend");
-        case tokenType.compound:
+        case Erc20SubType.compound:
             return lowerCaseName.includes("compound");
-        case tokenType.ironcladStaking:
+        case Erc20SubType.ironcladStaking:
             return lowerCaseName === "ironclad token";
-        case tokenType.woofi:
+        case Erc20SubType.woofi:
             return lowerCaseName.includes("woofi");
-        case tokenType.maverickBoostedPosition:
+        case Erc20SubType.maverickBoostedPosition:
             return lowerCaseName.includes("maverick");
-        case tokenType.zkSwapThreePool:
+        case Erc20SubType.zkSwapThreePool:
             return lowerCaseName.includes("zf");
-        case tokenType.maha:
+        case Erc20SubType.maha:
             return lowerCaseName.includes("staked") && lowerCaseName.includes("maha");
-        case tokenType.tempest:
+        case Erc20SubType.tempest:
             return lowerCaseName.startsWith("ts");
-        case tokenType.tempestStaking:
+        case Erc20SubType.tempestStaking:
             return lowerCaseName.startsWith("tempest");
-        case tokenType.holdstation:
+        case Erc20SubType.holdstation:
             return lowerCaseName.startsWith("hs");
-        case tokenType.noLinkVault:
+        case Erc20SubType.noLinkVault:
             return lowerCaseName.startsWith("unifi");
-        case tokenType.vicuna:
+        case Erc20SubType.vicuna:
             return lowerCaseName.startsWith("vifi");
-        case tokenType.avalon_borrowing:
+        case Erc20SubType.avalon_borrowing:
             return lowerCaseName.includes("avalon") && lowerCaseName.includes("debt");
-        case tokenType.avalon_lending:
+        case Erc20SubType.avalon_lending:
             return lowerCaseName.includes("avalon");
-        case tokenType.superlend_borrowing:
+        case Erc20SubType.superlend_borrowing:
             return lowerCaseName.includes("superlend") && lowerCaseName.includes("debt");
-        case tokenType.superlend_lending:
+        case Erc20SubType.superlend_lending:
             return lowerCaseName.includes("superlend");
-        case tokenType.lendle_borrowing:
+        case Erc20SubType.lendle_borrowing:
             return lowerCaseName.includes("lendle") && lowerCaseName.includes("debt");
-        case tokenType.lendle_lending:
+        case Erc20SubType.lendle_lending:
             return lowerCaseName.includes("lendle");
-        case tokenType.takotako_borrowing:
+        case Erc20SubType.takotako_borrowing:
             return lowerCaseName.includes("takotako") && lowerCaseName.includes("debt");
-        case tokenType.takotako_lending:
+        case Erc20SubType.takotako_lending:
             return lowerCaseName.includes("takotako");
-        case tokenType.cian:
+        case Erc20SubType.cian:
             return lowerCaseName.includes("cian");
-        case tokenType.concrete:
+        case Erc20SubType.concrete:
             return lowerCaseName.includes("concrete");
-        case tokenType.equalizer_gauge:
+        case Erc20SubType.equalizer_gauge:
             return lowerCaseName.includes("equalizer");
-        case tokenType.spectra_lpt:
+        case Erc20SubType.spectra_lpt:
             return lowerCaseName.includes("spectra") && lowerCaseName.includes("curve");
-        case tokenType.spectra_yt:
+        case Erc20SubType.spectra_yt:
             return lowerCaseName.includes("yield") && lowerCaseName.includes("token");
-        case tokenType.bunniV2:
+        case Erc20SubType.bunniV2:
             return lowerCaseName.includes("bunni");
-        case tokenType.sake_lending:
+        case Erc20SubType.sake_lending:
             return lowerCaseName.includes("sake soneium");
-        case tokenType.sake_borrowing:
+        case Erc20SubType.sake_borrowing:
             return lowerCaseName.includes("sake soneium") && lowerCaseName.includes("debt");
         default:
             return false;
@@ -191,7 +191,9 @@ function processNamingConditions(type, name, targetToken, campaign) {
         return generateResult(type, name, targetToken, {}, campaign);
     }
 }
-function processNamingConditionsInOrder(types, name, targetToken, campaign) {
+export function processNamingConditionsInOrder(name, targetToken, campaign) {
+    // Order matters
+    const types = Object.values(Erc20SubType).filter(value => typeof value === "string");
     for (const type of types) {
         const result = processNamingConditions(type, name, targetToken, campaign);
         if (result)
@@ -203,7 +205,7 @@ function parseForFactory(calls, targetToken, campaign) {
         const factory = decodeReturnValue(calls.factory, "factory");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromFactoryAddress(factory);
-        if (type !== tokenType.unknown)
+        if (type !== Erc20SubType.unknown)
             return generateResult(type, name, targetToken, { factory }, campaign);
     }
     catch (e) {
@@ -216,7 +218,7 @@ function parseForOwner(calls, targetToken) {
         const owner = decodeReturnValue(calls.owner, "owner");
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromOwnerAddress(owner);
-        if (type !== tokenType.unknown)
+        if (type !== Erc20SubType.unknown)
             return generateResult(type, name, targetToken, { owner: owner });
     }
     catch (e) {
@@ -235,7 +237,7 @@ function parseForEnzyme(calls, targetToken) {
             fundValueCalculator,
             dispatcher,
         };
-        if (type === tokenType.enzyme) {
+        if (type === Erc20SubType.enzyme) {
             return generateResult(type, name, targetToken, typeInfo);
         }
     }
@@ -248,7 +250,7 @@ function parseForMetamorpho(calls, targetToken) {
     try {
         decodeReturnValue(calls.metamorpho, "MORPHO");
         const name = decodeReturnValue(calls.name, "name");
-        return generateResult(tokenType.metamorpho, name, targetToken, {});
+        return generateResult(Erc20SubType.metamorpho, name, targetToken, {});
     }
     catch (e) {
         // Not a metamorpho token
@@ -258,14 +260,14 @@ function parseForBalancer(calls, targetToken, name) {
     // Check for balancer pools
     try {
         decodeReturnValue(calls.poolId, "getPoolId");
-        return generateResult(tokenType.balancerPool, name, targetToken, {});
+        return generateResult(Erc20SubType.balancerPool, name, targetToken, {});
     }
     catch (e) {
         // Not a balancer pool
     }
     try {
         decodeReturnValue(calls.vault, "getVault");
-        return generateResult(tokenType.balancerV3, name, targetToken, {});
+        return generateResult(Erc20SubType.balancerV3, name, targetToken, {});
     }
     catch (e) {
         // Not a balancer v3 pool
@@ -276,7 +278,7 @@ function checkAgainstHardcoded(calls, chainId, targetToken) {
     try {
         const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromAddressChain(chainId, targetToken);
-        if (type !== tokenType.unknown)
+        if (type !== Erc20SubType.unknown)
             return generateResult(type, name, targetToken, {});
     }
     catch (e) {
@@ -332,15 +334,13 @@ export function getTokenTypeRound1(calls, targetToken, index, campaign) {
         name = decodeCall(returnValueOfCalls, index + 2, "name");
     }
     catch {
-        return generateResult(tokenType.unknown, "Unknown", targetToken, {}, campaign);
+        return generateResult(Erc20SubType.unknown, "Unknown", targetToken, {}, campaign);
     }
     result = parseForBalancer(returnValue, targetToken, name);
     if (result)
         return result;
-    // Order matters
-    const ordered_token_Type = Object.values(tokenType).filter(value => typeof value === "string");
-    result = processNamingConditionsInOrder(ordered_token_Type, name, targetToken, campaign);
+    result = processNamingConditionsInOrder(name, targetToken, campaign);
     if (result)
         return result;
-    return generateResult(tokenType.unknown, name, targetToken, {}, campaign);
+    return generateResult(Erc20SubType.unknown, name, targetToken, {}, campaign);
 }