@merkl/api 0.20.101 → 0.20.103

package/dist/src/engine/erc20SubTypeProcessors/helpers/ownerFinder.js

@@ -1,13 +1,13 @@
-import { tokenType } from "./tokenType";
+import { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 const ownerAddresses = {
-    "0xbF7E49483881C76487b0989CD7d9A8239B20CA41": tokenType.curve_2,
-    "0x42a856dbEBB97AbC1269EAB32f3bb40C15102819": tokenType.satlayer,
-    "0x4C911bf7A008C497719CBEb1a376f1cEc9e2c1d6": tokenType.hanji_liquidity_vault_token,
-    "0x6e9d701fB6478Ed5972a37886C2BA6C82a4cBb4C": tokenType.gamma, // Gamma Bob owner
+    "0xbF7E49483881C76487b0989CD7d9A8239B20CA41": Erc20SubType.curve_2,
+    "0x42a856dbEBB97AbC1269EAB32f3bb40C15102819": Erc20SubType.satlayer,
+    "0x4C911bf7A008C497719CBEb1a376f1cEc9e2c1d6": Erc20SubType.hanji_liquidity_vault_token,
+    "0x6e9d701fB6478Ed5972a37886C2BA6C82a4cBb4C": Erc20SubType.gamma, // Gamma Bob owner
 };
 export function getTypeFromOwnerAddress(address) {
     if (ownerAddresses[address]) {
         return ownerAddresses[address];
     }
-    return tokenType.unknown;
+    return Erc20SubType.unknown;
 }

package/dist/src/engine/erc20SubTypeProcessors/implementations/AaveProcessor.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 dataRawAave;
     call: string;
@@ -25,6 +25,6 @@ export declare class AaveProcessor extends GenericProcessor<callKeysAave, dataRa
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawAave, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAave>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawAave, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAave>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawAnglesLiquid;
     call: string;
@@ -25,11 +25,11 @@ export declare class AnglesLiquidProcessor extends GenericProcessor<callKeysAngl
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAnglesLiquid>;
-    computeRound1(type: tokenType, typeInfo: dataRawAnglesLiquid): tokenTypeStruct;
-    computeRound2(index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, calls: string[]): tokenTypeStruct;
-    computeRound3(index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, calls: string[]): tokenTypeStruct;
-    computeRound4(index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
-    computeRound5(index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawAnglesLiquid, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAnglesLiquid>;
+    computeRound1(type: Erc20SubType, typeInfo: dataRawAnglesLiquid): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound2(index: number, type: Erc20SubType, typeInfo: dataRawAnglesLiquid, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawAnglesLiquid, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawAnglesLiquid, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound5(index: number, type: Erc20SubType, typeInfo: dataRawAnglesLiquid, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<import("../tokenTypeStruct").tokenTypeStruct>;
 }
 export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/AssetProcessor.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 dataRawAsset;
     call: string;
@@ -30,6 +30,6 @@ export declare class AssetProcessor extends GenericProcessor<callKeysAsset, data
         round4: callType[];
     };
     processingRound2(typeInfo: dataRawAsset): void;
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawAsset, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAsset>;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawAsset, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAsset>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { generateCardName } from "@/utils/generateCardName";
 import { BN2Number } from "@sdk";
+import { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
 export class AssetProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -25,7 +25,7 @@ export class AssetProcessor extends GenericProcessor {
     async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         let exchangeRate = BN2Number(typeInfo.exchangeRate);
-        if (type === tokenType.moonwell || type === tokenType.venus) {
+        if (type === Erc20SubType.moonwell || type === Erc20SubType.venus) {
             exchangeRate =
                 exchangeRate /
                     10 ** (Number(typeInfo.decimalsUnderlyingToken) - campaign.campaignParameters.decimalsTargetToken);

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

@@ -1,8 +1,8 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawAura;
     call: string;
@@ -64,7 +64,44 @@ export declare class AuraProcessor extends GenericProcessor<callKeysAura, dataRa
         round4: callType[];
     };
     processingRound4(typeInfo: dataRawAura): void;
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAura>;
-    computeRound4(index: number, type: tokenType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAura>;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): {
+        type: Erc20SubType;
+        calls: CallDto[];
+        typeInfo: {
+            type: Erc20SubType;
+            protocol: string;
+            tokenAddress: string;
+            blacklistedSupply: string;
+            totalSupply: string;
+            whitelistedSupply: string;
+            lockNFT: string;
+            eip712DomainName: string;
+            stakingName: string;
+            stakingSymbol: string;
+            isStaking: string;
+            balancerPool: string;
+            vault: string;
+            auraOperator: string;
+            poolId: string;
+            totalSupplyBalancerPool: string;
+            gaugeContract: string;
+            auraStaker: string;
+            totalSupplyGauge: string;
+            pid: string;
+            gaugeBalance: string;
+            auraBalance: string;
+            vaultBalance: string;
+            poolTokensRaw: Array<string[] | BigNumber[]>;
+            poolTokens: Array<{
+                token: string;
+                balance: string;
+                amountInPool: number;
+                symbol: string;
+                decimals: number;
+                price: number;
+            }>;
+        };
+    };
 }
 export {};

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

@@ -1,8 +1,8 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBG;
     call: string;
@@ -50,7 +50,36 @@ export declare class BEXRewardGaugeProcessor extends GenericProcessor<callKeysBG
     };
     processingRound2(typeInfo: dataRawBG): void;
     processingRound4(typeInfo: dataRawBG): void;
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
-    computeRound4(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): {
+        type: Erc20SubType;
+        calls: CallDto[];
+        typeInfo: {
+            type: Erc20SubType;
+            protocol: string;
+            tokenAddress: string;
+            blacklistedSupply: string;
+            totalSupply: string;
+            whitelistedSupply: string;
+            lockNFT: string;
+            eip712DomainName: string;
+            stakingName: string;
+            stakingSymbol: string;
+            isStaking: string;
+            gyroscopeToken: string;
+            balanceUnderlyingPoolTokens: string;
+            totalSupplyUnderlyingPoolTokens: string;
+            poolId: string;
+            vault: string;
+            vaultBalance: string;
+            poolHolder: string;
+            poolTokensRaw: Array<string[] | BigNumber[]>;
+            poolTokens: Array<{
+                token: string;
+                balance: string;
+            }>;
+            poolHolderBalance: string;
+        };
+    };
 }
 export {};

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

@@ -58,11 +58,11 @@ export class BEXRewardGaugeProcessor extends GenericProcessor {
             tokensDisplay.push({ symbol: symbol, address: poolToken.token });
         }
         let adjustedPoolTotalSupply = BN2Number(typeInfo.totalSupplyUnderlyingPoolTokens, 18);
-        // if (type === tokenType.beratrax_vault) {
+        // if (type === Erc20SubType.beratrax_vault) {
         //   // Weird edge case where a lot of the supply is in a weird contract
         //   adjustedPoolTotalSupply -= BN2Number(typeInfo.poolHolderBalance, 18);
         // }
-        // if (type === tokenType.beraborrow_gauge) {
+        // if (type === Erc20SubType.beraborrow_gauge) {
         // Remove tokens in the vault from the total supply
         adjustedPoolTotalSupply -= BN2Number(typeInfo.vaultBalance, 18);
         let percentageOfSupplyUnderlyingPoolTokens = 1;

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

@@ -1,8 +1,8 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBG;
     call: string;
@@ -43,7 +43,33 @@ export declare class BalancerGaugeProcessor extends GenericProcessor<callKeysBG,
         round4: callType[];
     };
     processingRound4(typeInfo: dataRawBG): void;
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
-    computeRound4(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): {
+        type: Erc20SubType;
+        calls: CallDto[];
+        typeInfo: {
+            type: Erc20SubType;
+            protocol: string;
+            tokenAddress: string;
+            blacklistedSupply: string;
+            totalSupply: string;
+            whitelistedSupply: string;
+            lockNFT: string;
+            eip712DomainName: string;
+            stakingName: string;
+            stakingSymbol: string;
+            isStaking: string;
+            gyroscopeToken: string;
+            balanceUnderlyingPoolTokens: string;
+            totalSupplyUnderlyingPoolTokens: string;
+            poolId: string;
+            vault: string;
+            poolTokensRaw: Array<string[] | BigNumber[]>;
+            poolTokens: Array<{
+                token: string;
+                balance: string;
+            }>;
+        };
+    };
 }
 export {};

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

@@ -1,8 +1,8 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { BigNumber } from "ethers";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBP;
     call: string;
@@ -53,8 +53,36 @@ export declare class BalancerPoolProcessor extends GenericProcessor<callKeysBP,
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBP>;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBP>;
     processingRound4(typeInfo: dataRawBP): void;
-    computeRound4(index: number, type: tokenType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): {
+        type: Erc20SubType;
+        calls: CallDto[];
+        typeInfo: {
+            type: Erc20SubType;
+            protocol: string;
+            tokenAddress: string;
+            blacklistedSupply: string;
+            totalSupply: string;
+            whitelistedSupply: string;
+            lockNFT: string;
+            eip712DomainName: string;
+            stakingName: string;
+            stakingSymbol: string;
+            isStaking: string;
+            poolId: string;
+            vault: string;
+            vaultBalance: string;
+            poolTokensRaw: Array<string[] | BigNumber[]>;
+            poolTokens: Array<{
+                token: string;
+                balance: string;
+                amountInPool: number;
+                symbol: string;
+                decimals: number;
+                price: number;
+            }>;
+        };
+    };
 }
 export {};

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

@@ -1,8 +1,8 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBalancerV3;
     call: string;
@@ -38,7 +38,7 @@ export declare class BalancerV3PoolProcessor extends GenericProcessor<callKeysBa
         round4: callType[];
     };
     processingRound2(typeInfo: dataRawBalancerV3): void;
-    computeRound3(index: number, type: tokenType, typeInfo: dataRawBalancerV3, calls: string[]): tokenTypeStruct;
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBalancerV3, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBalancerV3>;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawBalancerV3, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawBalancerV3, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBalancerV3>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type 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 dataRawBeefy;
     call: string;
@@ -43,6 +43,6 @@ export declare class BeefyProcessor extends GenericProcessor<callKeysBeefy, data
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBeefy, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBeefy>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawBeefy, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBeefy>;
 }
 export {};

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

@@ -1,8 +1,8 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters, type UniswapV4PoolKey } from "@sdk";
 import type { PoolStateStructOutput } from "libs/sdk/src/generated/BunniV2Hub";
+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 dataRawBunniV2;
     call: string;
@@ -40,6 +40,6 @@ export declare class BunniV2Processor extends GenericProcessor<callKeysBunniV2,
         round4: callType[];
     };
     processingRound2(typeInfo: dataRawBunniV2): void;
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBunniV2, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBunniV2>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawBunniV2, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBunniV2>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type 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 dataRawCompound;
     call: string;
@@ -39,6 +39,6 @@ export declare class CompoundProcessor extends GenericProcessor<callKeysCompound
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawCompound, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCompound>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawCompound, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCompound>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type 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 dataRawERC4626;
     call: string;
@@ -29,6 +29,6 @@ export declare class ERC4626Processor extends GenericProcessor<callKeysERC4626,
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawERC4626, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeERC4626>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawERC4626, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeERC4626>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawEnzyme;
     call: string;
@@ -33,8 +33,8 @@ export declare class EnzymeProcessor extends GenericProcessor<callKeysEnzyme, da
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawEnzyme, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEnzyme>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawEnzyme, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEnzyme>;
     processingRound2(typeInfo: dataRawEnzyme): void;
-    computeRound3(index: number, type: tokenType, typeInfo: dataRawEnzyme, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawEnzyme, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
 }
 export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/EqualizerGaugeProcessor.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 dataRawEqualizerGauge;
     call: string;
@@ -23,6 +23,6 @@ export declare class EqualizerGaugeProcessor extends GenericProcessor<callKeysEq
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawEqualizerGauge, _calls: string[], campaign: CampaignParameters<Campaign.ERC20>, _pricer: Pricer): Promise<dataTypeEqualizerGauge>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawEqualizerGauge, _calls: string[], campaign: CampaignParameters<Campaign.ERC20>, _pricer: Pricer): Promise<dataTypeEqualizerGauge>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type 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 dataRawEuler;
     call: string;
@@ -31,6 +31,6 @@ export declare class EulerBorrowProcessor extends GenericProcessor<callKeysEuler
         round4: callType[];
     };
     processingRound2(typeInfo: dataRawEuler, campaign: CampaignParameters<Campaign.EULER>): void;
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawEuler, _calls: string[], campaign: CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawEuler, _calls: string[], campaign: CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type 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 dataRawEuler;
     call: string;
@@ -31,6 +31,6 @@ export declare class EulerLendProcessor extends GenericProcessor<callKeysEuler,
         round4: callType[];
     };
     processingRound2(typeInfo: dataRawEuler, campaign: CampaignParameters<Campaign.EULER>): void;
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawEuler, calls: string[], campaign: CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawEuler, calls: string[], campaign: CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type 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 dataRawFluid;
     call: string;
@@ -33,7 +33,7 @@ export declare class FluidProcessor extends GenericProcessor<callKeysFluid, data
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawFluid, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFluid>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawFluid, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFluid>;
     processingRound3(typeInfo: dataRawFluid): void;
 }
 export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/FraxProcessor.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 dataRawFrax;
     call: string;
@@ -28,6 +28,6 @@ export declare class FraxProcessor extends GenericProcessor<callKeysFrax, dataRa
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawFrax, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFrax>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawFrax, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFrax>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { generateCardName } from "@/utils/generateCardName";
 import { BN2Number } from "@sdk";
+import { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
 export class FraxProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -21,7 +21,7 @@ export class FraxProcessor extends GenericProcessor {
         const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 1;
         let priceTargetToken = 0;
         let tvl = 0;
-        if (type === tokenType.silostaking) {
+        if (type === Erc20SubType.silostaking) {
             priceTargetToken = priceUnderlying;
             tvl = priceTargetToken * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
         }

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type 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 dataRawGamma;
     call: string;
@@ -25,6 +25,6 @@ export declare class GammaALMProcessor extends GenericProcessor<callKeysGamma, d
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawGamma, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeGamma>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawGamma, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeGamma>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Erc20SubType } from "../../campaignTVL/implementations/Erc20/Erc20SubType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawGamma;
     call: string;
@@ -33,11 +33,11 @@ export declare class GammaProcessor extends GenericProcessor<callKeysGamma, data
         round4: callType[];
     };
     processingRound2(typeInfo: dataRawGamma): void;
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawGamma, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGamma>;
-    computeRound1(type: tokenType, typeInfo: dataRawGamma): tokenTypeStruct;
-    computeRound2(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[]): tokenTypeStruct;
-    computeRound3(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[]): tokenTypeStruct;
-    computeRound4(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
-    computeRound5(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawGamma, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGamma>;
+    computeRound1(type: Erc20SubType, typeInfo: dataRawGamma): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound2(index: number, type: Erc20SubType, typeInfo: dataRawGamma, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawGamma, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound5(index: number, type: Erc20SubType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<import("../tokenTypeStruct").tokenTypeStruct>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type 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 dataRawGearbox;
     call: string;
@@ -39,6 +39,6 @@ export declare class GearboxProcessor extends GenericProcessor<callKeysGearbox,
         round4: callType[];
     };
     processingRound2(typeInfo: dataRawGearbox): Promise<void>;
-    processingRound5(_index: number, type: tokenType, typeInfo: dataRawGearbox, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGearbox>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawGearbox, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGearbox>;
 }
 export {};