@merkl/api 0.20.63 → 0.20.65

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

@@ -1,7 +1,8 @@
 import type { Pricer } from "@/utils/pricer";
-import { type CallDto, type Campaign, type CampaignParameters } from "@sdk";
+import { type CallDto, type CampaignParameters } from "@sdk";
 import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
-import { type tokenType, type tokenTypeStruct } from "./helpers/tokenType";
+import { type tokenType } from "./constants";
+import type { tokenTypeStruct } from "./interface";
 export declare enum Round {
     one = "round1",
     two = "round2",
@@ -9,14 +10,13 @@ export declare enum Round {
     four = "round4"
 }
 export type callType = {
-    key: any;
-    call: any;
-    target: any;
-    metaData?: any;
+    key: string;
+    call: string;
+    target: string;
+    callArgs?: string;
     optional?: boolean;
 };
 export type mandatoryCallKeys = {
-    type: tokenType;
     protocol: string;
     tokenAddress: string;
     blacklistedSupply: string;
@@ -28,11 +28,8 @@ export type stakingKeys = {
     eip712DomainName: string;
     stakingName: string;
     stakingSymbol: string;
-    isStaking: string;
-};
-export type callKeys = mandatoryCallKeys & {
-    [key: string]: string;
 };
+export type callKeys = mandatoryCallKeys & Record<string, string>;
 export type dataRaw = {
     protocol: string;
     tokenAddress: string;
@@ -42,7 +39,6 @@ export type dataRaw = {
 } & stakingKeys;
 export type dataType = {
     protocol: string;
-    type: tokenType;
     tokenAddress: string;
     totalSupply: number;
     blacklistedSupply: number;
@@ -63,6 +59,11 @@ export type dataType = {
  * @params Output - Final output of the processor
  */
 export declare class GenericProcessor<Input extends callKeys, DataRaw extends dataRaw, Output extends dataType> {
+    debug: boolean;
+    type: tokenType;
+    isStaking: boolean;
+    campaign: CampaignParameters<ERC20SupportedCampaignType>;
+    constructor(type: tokenType, campaign: CampaignParameters<ERC20SupportedCampaignType>, debug?: boolean);
     rounds: {
         round1: callType[];
         round2: callType[];
@@ -75,24 +76,23 @@ export declare class GenericProcessor<Input extends callKeys, DataRaw extends da
         round3: callType[];
         round4: callType[];
     };
-    debug: boolean;
     processingRound1(_typeInfo: DataRaw): void;
     processingRound2(_typeInfo: DataRaw, _campaign?: CampaignParameters<ERC20SupportedCampaignType>): void;
     processingRound3(_typeInfo: DataRaw): void;
     processingRound4(_typeInfo: DataRaw): void;
-    handleWhiteListBlacklistRound5(typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): {
+    handleWhiteListBlacklistRound5(typeInfo: DataRaw, campaign: CampaignParameters<ERC20SupportedCampaignType>): {
         whitelistedSupplyTargetToken: any;
         totalSupply: any;
         blacklistedSupply: any;
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: DataRaw, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<Output>;
-    computeRound1(type: tokenType, typeInfo: DataRaw): tokenTypeStruct;
+    processingRound5(_index: number, type: tokenType, typeInfo: DataRaw, _calls: string[], campaign: CampaignParameters<ERC20SupportedCampaignType>, pricer: Pricer): Promise<Output>;
+    computeRound1(typeInfo: DataRaw): tokenTypeStruct;
     computeRound2(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign?: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;
     computeRound3(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
     computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;
     computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<ERC20SupportedCampaignType>, pricer: Pricer): Promise<tokenTypeStruct>;
-    generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
-    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
+    generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<ERC20SupportedCampaignType>): CallDto[];
+    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<ERC20SupportedCampaignType>): CallDto[];
     decodeListedSupply(index: number, list: string[], calls: string[]): string;
     decodeRound(round: callType[], index: number, calls: string[], type: tokenType, data: DataRaw): void;
     decodePreviousRound(round: Round, calls: string[], data: DataRaw, type: tokenType, index: number): void;

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

@@ -1,9 +1,9 @@
 import { decodeCall } from "@/utils/decodeCalls";
 import { createCall } from "@/utils/encodeCalls";
 import { generateCardName } from "@/utils/generateCardName";
-import { generateIcons } from "@/utils/generateIcons";
 import { BN2Number } from "@sdk";
-import { tokenTypeToProtocolAndAction } from "./helpers/tokenType";
+import { tokenTypeToProtocolAndAction } from "./constants";
+import { parseForStaking } from "./subtypesRound1";
 export var Round;
 (function (Round) {
     Round["one"] = "round1";
@@ -19,6 +19,16 @@ export var Round;
  * @params Output - Final output of the processor
  */
 export class GenericProcessor {
+    debug; // Wheter to log have additional logs
+    type; // Type of the ERC20 we're processing
+    isStaking; // Whether this campaign is in fact targeting a staking contract of the target ERC20
+    campaign; // Campaign parameters
+    constructor(type, campaign, debug = false) {
+        this.debug = debug;
+        this.type = type;
+        this.campaign = campaign;
+        this.isStaking = parseForStaking(campaign).isStaking;
+    }
     rounds = {
         round1: [],
         round2: [],
@@ -36,7 +46,6 @@ export class GenericProcessor {
         round3: [],
         round4: [],
     };
-    debug = false;
     processingRound1(_typeInfo) { }
     processingRound2(_typeInfo, _campaign) { }
     processingRound3(_typeInfo) { }
@@ -69,38 +78,38 @@ export class GenericProcessor {
             priceTargetToken,
             tvl,
             blacklistedSupply,
-            cardName: generateCardName(type, typeInfo, campaign),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
             tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
         };
     }
-    computeRound1(type, typeInfo) {
-        typeInfo = { type, ...tokenTypeToProtocolAndAction[type], ...typeInfo };
+    computeRound1(typeInfo) {
+        typeInfo = { type: this.type, ...tokenTypeToProtocolAndAction[this.type], ...typeInfo };
         this.processingRound1(typeInfo);
-        let calls = this.encodeNextRound(Round.one, type, typeInfo);
-        if (typeInfo.isStaking === "true") {
-            calls = calls.concat(this.encodeStakingNextRound(Round.one, type, typeInfo));
+        let calls = this.encodeNextRound(Round.one, this.type, typeInfo);
+        if (this.isStaking) {
+            calls = calls.concat(this.encodeStakingNextRound(Round.one, this.type, typeInfo));
         }
         if (this.debug) {
             console.log("Round 1", {
-                type: type,
+                type: this.type,
                 calls,
                 typeInfo,
             });
         }
         return {
-            type: type,
+            type: this.type,
             calls,
             typeInfo,
         };
     }
     computeRound2(index, type, typeInfo, calls, campaign) {
         this.decodePreviousRound(Round.one, calls, typeInfo, type, index);
-        if (typeInfo.isStaking === "true") {
+        if (this.isStaking) {
             this.decodePreviousStakingRound(Round.one, calls, typeInfo, type, index + this.rounds.round1.length);
         }
         this.processingRound2(typeInfo, campaign);
         let nextCalls = this.encodeNextRound(Round.two, type, typeInfo);
-        if (typeInfo.isStaking === "true") {
+        if (this.isStaking) {
             nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.two, type, typeInfo));
         }
         if (this.debug) {
@@ -118,12 +127,12 @@ export class GenericProcessor {
     }
     computeRound3(index, type, typeInfo, calls) {
         this.decodePreviousRound(Round.two, calls, typeInfo, type, index);
-        if (typeInfo.isStaking === "true") {
+        if (this.isStaking) {
             this.decodePreviousStakingRound(Round.two, calls, typeInfo, type, index + this.rounds.round2.length);
         }
         this.processingRound3(typeInfo);
         let nextCalls = this.encodeNextRound(Round.three, type, typeInfo);
-        if (typeInfo.isStaking === "true") {
+        if (this.isStaking) {
             nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.three, type, typeInfo));
         }
         if (this.debug) {
@@ -143,12 +152,12 @@ export class GenericProcessor {
         const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
         const whitelistedLiquidityCalls = this.generateWhitelistCall(type, typeInfo, campaign);
         this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
-        if (typeInfo.isStaking === "true") {
+        if (this.isStaking) {
             this.decodePreviousStakingRound(Round.three, calls, typeInfo, type, index + this.rounds.round3.length);
         }
         this.processingRound4(typeInfo);
         let nextCalls = this.encodeNextRound(Round.four, type, typeInfo);
-        if (typeInfo.isStaking === "true") {
+        if (this.isStaking) {
             nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.four, type, typeInfo));
         }
         if (this.debug) {
@@ -172,7 +181,7 @@ export class GenericProcessor {
         typeInfo.blacklistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.blacklist, calls);
         index = index + campaign.campaignParameters.blacklist.length;
         this.decodePreviousRound(Round.four, calls, typeInfo, type, index);
-        if (typeInfo.isStaking === "true") {
+        if (this.isStaking) {
             this.decodePreviousStakingRound(Round.four, calls, typeInfo, type, index + this.rounds.round4.length);
         }
         const outputInfo = (await this.processingRound5(index, type, typeInfo, calls, campaign, pricer));
@@ -180,19 +189,13 @@ export class GenericProcessor {
             console.log("Round 5", {
                 type: type,
                 calls: [],
-                typeInfo: {
-                    ...outputInfo,
-                    icons: generateIcons(type, typeInfo, campaign),
-                },
+                typeInfo: outputInfo,
             });
         }
         return {
             type: type,
             calls: [],
-            typeInfo: {
-                ...outputInfo,
-                icons: generateIcons(type, typeInfo, campaign),
-            },
+            typeInfo: outputInfo,
         };
     }
     generateWhitelistCall(type, typeInfo, campaign) {
@@ -274,12 +277,12 @@ export class GenericProcessor {
     }
     encodeRound(round, callInfo, type) {
         return round
-            .map(({ call, target, metaData, optional }) => {
-            if (optional && !callInfo[target]) {
+            .map(({ call, target, callArgs, optional }) => {
+            if (!optional && !callInfo[target]) {
                 return [];
             }
-            if (metaData) {
-                return createCall(callInfo[target], call, type, callInfo[metaData]);
+            if (callArgs) {
+                return createCall(callInfo[target], call, type, callInfo[callArgs]);
             }
             return createCall(callInfo[target], call, type);
         })

package/dist/src/engine/erc20SubTypeProcessors/{helpers/tokenType.d.ts → constants.d.ts}

@@ -1,6 +1,5 @@
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
 import { OpportunityAction } from "@db/api";
-import type { CallDto } from "@sdk";
 export declare enum tokenType {
     aura = "aura",
     anglesLiquid = "anglesLiquid",
@@ -103,8 +102,3 @@ export declare const tokenTypeToProtocolAndAction: Record<tokenType, {
     protocol: ProtocolId | undefined;
     action: OpportunityAction;
 }>;
-export type tokenTypeStruct = {
-    type: tokenType;
-    calls: CallDto[];
-    typeInfo: any;
-};

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

@@ -0,0 +1,6 @@
+import type { CampaignParameters } from "@sdk";
+import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
+import { GenericProcessor } from "./GenericProcessor";
+import type { callKeys, dataRaw, dataType } from "./GenericProcessor";
+import { tokenType } from "./constants";
+export declare const erc20ProcessorFactory: (type: tokenType, campaign: CampaignParameters<ERC20SupportedCampaignType>, debug?: boolean) => GenericProcessor<callKeys, dataRaw, dataType>;

package/dist/src/engine/erc20SubTypeProcessors/{implementations/processorMapping.js → factory.js}

@@ -1,51 +1,51 @@
-import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
-import { AaveProcessor } from "./AaveProcessor";
-import { AnglesLiquidProcessor } from "./AnglesLiquid";
-import { AssetProcessor } from "./AssetProcessor";
-import { AuraProcessor } from "./AuraProcessor";
-import { BEXRewardGaugeProcessor } from "./BEXRewardGaugeProcessor";
-import { BalancerGaugeProcessor } from "./BalancerGaugeProcessor";
-import { BalancerPoolProcessor } from "./BalancerPoolProcessor";
-import { BalancerV3PoolProcessor } from "./BalancerV3PoolProcessor";
-import { BeefyProcessor } from "./BeefyProcessor";
-import { BunniV2Processor } from "./BunniV2Processor";
-import { CompoundProcessor } from "./CompoundProcessor";
-import { ERC4626Processor } from "./ERC4626Processor";
-import { EnzymeProcessor } from "./EnzymeProcessor";
-import { EqualizerGaugeProcessor } from "./EqualizerGaugeProcessor";
-import { EulerBorrowProcessor } from "./EulerBorrowProcessor";
-import { EulerLendProcessor } from "./EulerLendProcessor";
-import { FluidProcessor } from "./FluidProcessor";
-import { FraxProcessor } from "./FraxProcessor";
-import { GammaProcessor } from "./GammaProcessor";
-import { GearboxProcessor } from "./GearboxProcessor";
-import { HanjiVaultProcessor } from "./HanjiVaultProcessor";
-import { HoldStationProcessor } from "./HoldStationProcessor";
-import { HourglassProcessor } from "./HourglassProcessor";
-import { MaverickBPProcessor } from "./MaverickBPProcessor";
-import { MetamorphoProcessor } from "./MetamorphoProcessor";
-import { NoLinkVaultProcessor } from "./NoLinkVaultProcessor";
-import { PendleProcessor } from "./PendleProcessor";
-import { PendleYTProcessor } from "./PendleYTProcessor";
-import { RadiantProcessor } from "./RadiantProcessor";
-import { RfxProcessor } from "./RfxProcessor";
-import { SatlayerProcessor } from "./Satlayer";
-import { SpectraProcessor } from "./SpectraProcessor";
-import { SpectraYTProcessor } from "./SpectraYTProcessor";
-import { SpliceProcessor } from "./SpliceProcessor";
-import { SturdySiloProcessor } from "./SturdySiloProcessor";
-import { TempestVaultProcessor } from "./TempestVaultProcessor";
-import { TorosProcessor } from "./TorosProcessor";
-import { UniswapProcessor } from "./UniswapProcessor";
-import { VicunaProcessor } from "./VicunaProcessor";
-import { WoofiProcessor } from "./WoofiProcessor";
-import { ZkSwapThreePoolProcessor } from "./ZkSwapThreePoolProcessor";
-import { CurveNPoolProcessor } from "./curveNPoolProcessor";
-import { CurveProcessor } from "./curveProcessor";
-import { StakedCurveProcessor } from "./stakedCurveProcessor";
-import { xU308Processor } from "./xU308Processor";
-export const processorMapping = {
+import { GenericProcessor } from "./GenericProcessor";
+import { tokenType } from "./constants";
+import { AaveProcessor } from "./implementations/AaveProcessor";
+import { AnglesLiquidProcessor } from "./implementations/AnglesLiquid";
+import { AssetProcessor } from "./implementations/AssetProcessor";
+import { AuraProcessor } from "./implementations/AuraProcessor";
+import { BEXRewardGaugeProcessor } from "./implementations/BEXRewardGaugeProcessor";
+import { BalancerGaugeProcessor } from "./implementations/BalancerGaugeProcessor";
+import { BalancerPoolProcessor } from "./implementations/BalancerPoolProcessor";
+import { BalancerV3PoolProcessor } from "./implementations/BalancerV3PoolProcessor";
+import { BeefyProcessor } from "./implementations/BeefyProcessor";
+import { BunniV2Processor } from "./implementations/BunniV2Processor";
+import { CompoundProcessor } from "./implementations/CompoundProcessor";
+import { ERC4626Processor } from "./implementations/ERC4626Processor";
+import { EnzymeProcessor } from "./implementations/EnzymeProcessor";
+import { EqualizerGaugeProcessor } from "./implementations/EqualizerGaugeProcessor";
+import { EulerBorrowProcessor } from "./implementations/EulerBorrowProcessor";
+import { EulerLendProcessor } from "./implementations/EulerLendProcessor";
+import { FluidProcessor } from "./implementations/FluidProcessor";
+import { FraxProcessor } from "./implementations/FraxProcessor";
+import { GammaProcessor } from "./implementations/GammaProcessor";
+import { GearboxProcessor } from "./implementations/GearboxProcessor";
+import { HanjiVaultProcessor } from "./implementations/HanjiVaultProcessor";
+import { HoldStationProcessor } from "./implementations/HoldStationProcessor";
+import { HourglassProcessor } from "./implementations/HourglassProcessor";
+import { MaverickBPProcessor } from "./implementations/MaverickBPProcessor";
+import { MetamorphoProcessor } from "./implementations/MetamorphoProcessor";
+import { NoLinkVaultProcessor } from "./implementations/NoLinkVaultProcessor";
+import { PendleProcessor } from "./implementations/PendleProcessor";
+import { PendleYTProcessor } from "./implementations/PendleYTProcessor";
+import { RadiantProcessor } from "./implementations/RadiantProcessor";
+import { RfxProcessor } from "./implementations/RfxProcessor";
+import { SatlayerProcessor } from "./implementations/Satlayer";
+import { SpectraProcessor } from "./implementations/SpectraProcessor";
+import { SpectraYTProcessor } from "./implementations/SpectraYTProcessor";
+import { SpliceProcessor } from "./implementations/SpliceProcessor";
+import { SturdySiloProcessor } from "./implementations/SturdySiloProcessor";
+import { TempestVaultProcessor } from "./implementations/TempestVaultProcessor";
+import { TorosProcessor } from "./implementations/TorosProcessor";
+import { UniswapProcessor } from "./implementations/UniswapProcessor";
+import { VicunaProcessor } from "./implementations/VicunaProcessor";
+import { WoofiProcessor } from "./implementations/WoofiProcessor";
+import { ZkSwapThreePoolProcessor } from "./implementations/ZkSwapThreePoolProcessor";
+import { CurveNPoolProcessor } from "./implementations/curveNPoolProcessor";
+import { CurveProcessor } from "./implementations/curveProcessor";
+import { StakedCurveProcessor } from "./implementations/stakedCurveProcessor";
+import { xU308Processor } from "./implementations/xU308Processor";
+const map = {
     [tokenType.uniswapv2]: UniswapProcessor,
     [tokenType.balancerGauge]: BalancerGaugeProcessor,
     [tokenType.balancerPool]: BalancerPoolProcessor,
@@ -143,3 +143,4 @@ export const processorMapping = {
     [tokenType.xlend_lending]: AaveProcessor,
     [tokenType.curve_gauge]: StakedCurveProcessor,
 };
+export const erc20ProcessorFactory = (type, campaign, debug = false) => new map[type](type, campaign, debug);

package/dist/src/engine/erc20SubTypeProcessors/helpers/factoryFinder.d.ts

@@ -1,4 +1,4 @@
-import { tokenType } from "./tokenType";
+import { tokenType } from "../constants";
 export declare function getTypeFromFactoryAddress(address: string): tokenType;
 export declare const enzymeFundValueCalculatorRouterMapping: {
     [address: string]: string;

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

@@ -1,4 +1,4 @@
-import { tokenType } from "./tokenType";
+import { tokenType } from "../constants";
 const factoryAddresses = {
     "0x420DD381b31aEf6683db6B902084cB0FFECe40Da": tokenType.aerodrome, // Aerodrome Base Factory
     "0x31832f2a97Fd20664D76Cc421207669b55CE4BC0": tokenType.velodrome, // Velodrome Mode Factory

package/dist/src/engine/erc20SubTypeProcessors/helpers/hardcoded.d.ts

@@ -1,3 +1,3 @@
 import { ChainId } from "@sdk";
-import { tokenType } from "./tokenType";
+import { tokenType } from "../constants";
 export declare function getTypeFromAddressChain(chain: ChainId, token: string): tokenType;

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

@@ -1,5 +1,5 @@
 import { ChainId } from "@sdk";
-import { tokenType } from "./tokenType";
+import { tokenType } from "../constants";
 const chainAddressToType = {
     [ChainId.CORN]: {
         "0xab3291b73a1087265e126e330cede0cfd4b8a693": tokenType.curveNPool,

package/dist/src/engine/erc20SubTypeProcessors/helpers/ownerFinder.d.ts

@@ -1,2 +1,2 @@
-import { tokenType } from "./tokenType";
+import { tokenType } from "../constants";
 export declare function getTypeFromOwnerAddress(address: string): tokenType;

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

@@ -1,4 +1,4 @@
-import { tokenType } from "./tokenType";
+import { tokenType } from "../constants";
 const ownerAddresses = {
     "0xbF7E49483881C76487b0989CD7d9A8239B20CA41": tokenType.curve_2,
     "0x42a856dbEBB97AbC1269EAB32f3bb40C15102819": tokenType.satlayer,

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

@@ -1,12 +1,11 @@
 import type { Pricer } from "@/utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType } from "../helpers/tokenType";
+import type { tokenType } from "../constants";
 type callType = {
     key: keyof dataRawAave;
     call: string;
     target: keyof callKeysAave;
-    metaData?: keyof callKeysAave;
 };
 export type callKeysAave = mandatoryCallKeys & {
     underlying: string;

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

@@ -7,7 +7,6 @@ export class AaveProcessor extends GenericProcessor {
         round3: [],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
-    // // override computeRound1(): void {}
     async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const priceTargetToken = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
@@ -17,7 +16,7 @@ export class AaveProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             tvl: tvl,
             priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
             blacklistedSupply,
             totalSupply,
             tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],

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

@@ -1,12 +1,12 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import type { tokenType } from "../constants";
+import type { tokenTypeStruct } from "../interface";
 type callType = {
     key: keyof dataRawAnglesLiquid;
     call: string;
     target: keyof callKeysAnglesLiquid;
-    metaData?: keyof callKeysAnglesLiquid;
 };
 type callKeysAnglesLiquid = mandatoryCallKeys & {
     poolToken: string;
@@ -26,7 +26,6 @@ export declare class AnglesLiquidProcessor extends GenericProcessor<callKeysAngl
         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;

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

@@ -12,7 +12,6 @@ export class AnglesLiquidProcessor extends GenericProcessor {
             { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
         ],
     };
-    // override computeRound1(): void {}
     async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const priceUnderlying = (await pricer.get({ symbol: "S" })) ?? 0;
@@ -29,13 +28,10 @@ export class AnglesLiquidProcessor extends GenericProcessor {
             symbolUnderlyingToken,
             totalAssets: typeInfo.totalAssets,
             poolToken: typeInfo.poolToken,
-            cardName: generateCardName(type, typeInfo, campaign),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
             tokensDisplay: [{ symbol: symbolUnderlyingToken, address: typeInfo.poolToken }],
         };
     }
-    computeRound1(type, typeInfo) {
-        return super.computeRound1(type, typeInfo);
-    }
     computeRound2(index, type, typeInfo, calls) {
         return super.computeRound2(index, type, typeInfo, calls);
     }

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

@@ -1,12 +1,11 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
+import { tokenType } from "../constants";
 type callType = {
     key: keyof dataRawAsset;
     call: string;
     target: keyof callKeysAsset;
-    metaData?: keyof callKeysAsset;
     optional?: boolean;
 };
 type callKeysAsset = mandatoryCallKeys & {

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

@@ -1,7 +1,7 @@
 import { generateCardName } from "@/utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../helpers/tokenType";
+import { tokenType } from "../constants";
 export class AssetProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -41,7 +41,7 @@ export class AssetProcessor extends GenericProcessor {
             exchangeRate,
             whitelistedSupplyTargetToken,
             blacklistedSupply,
-            cardName: generateCardName(type, typeInfo, campaign),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
             tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
         };
     }

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

@@ -2,12 +2,13 @@ import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import type { tokenType } from "../constants";
+import type { tokenTypeStruct } from "../interface";
 type callType = {
     key: keyof dataRawAura;
     call: string;
     target: keyof callKeysAura;
-    metaData?: keyof callKeysAura;
+    callArgs?: keyof callKeysAura;
 };
 type callKeysAura = mandatoryCallKeys & {
     balancerPool: string;

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

@@ -15,19 +15,18 @@ export class AuraProcessor extends GenericProcessor {
             { key: "poolId", call: "getPoolId", target: "balancerPool" },
             { key: "vault", call: "getVault", target: "balancerPool" },
             { key: "totalSupplyBalancerPool", call: "totalSupply", target: "balancerPool" },
-            { key: "gaugeContract", call: "poolInfo", target: "auraOperator", metaData: "pid" },
+            { key: "gaugeContract", call: "poolInfo", target: "auraOperator", callArgs: "pid" },
             { key: "auraStaker", call: "staker", target: "auraOperator" },
         ],
         round3: [
-            { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
-            { key: "gaugeBalance", call: "balanceOf", target: "balancerPool", metaData: "gaugeContract" },
-            { key: "auraBalance", call: "balanceOf", target: "gaugeContract", metaData: "auraStaker" },
-            { key: "vaultBalance", call: "balanceOf", target: "balancerPool", metaData: "vault" },
+            { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", callArgs: "poolId" },
+            { key: "gaugeBalance", call: "balanceOf", target: "balancerPool", callArgs: "gaugeContract" },
+            { key: "auraBalance", call: "balanceOf", target: "gaugeContract", callArgs: "auraStaker" },
+            { key: "vaultBalance", call: "balanceOf", target: "balancerPool", callArgs: "vault" },
             { key: "totalSupplyGauge", call: "totalSupply", target: "gaugeContract" },
         ],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
-    // override computeRound1(): void {}
     processingRound4(typeInfo) {
         const tokens = typeInfo.poolTokensRaw[0];
         const balances = typeInfo.poolTokensRaw[1];
@@ -88,7 +87,7 @@ export class AuraProcessor extends GenericProcessor {
             blacklistedSupply,
             tvl: tvl,
             priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, typeInfo, campaign, symbols),
+            cardName: generateCardName(type, this.isStaking, typeInfo, campaign, symbols),
             tokensDisplay,
         };
     }

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

@@ -2,12 +2,13 @@ import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import type { tokenType } from "../constants";
+import type { tokenTypeStruct } from "../interface";
 type callType = {
     key: keyof dataRawBG;
     call: string;
     target: keyof callKeysBG;
-    metaData?: keyof callKeysBG;
+    callArgs?: keyof callKeysBG;
 };
 type callKeysBG = mandatoryCallKeys & {
     gyroscopeToken: string;