@merkl/api 0.20.65 → 0.20.67

package/dist/src/engine/dynamicData/factory.js

@@ -58,5 +58,7 @@ const map = {
     [Campaign.ERC6909FIXAPR]: new DefaultDynamicData(), // TODO
     [Campaign.ERC1155]: new DefaultDynamicData(), // TODO
     [Campaign.ERC1155FIXAPR]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC721]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC721FIXAPR]: new DefaultDynamicData(), // TODO
 };
 export const dynamicDataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/dynamicData/implementations/Erc20.js

@@ -1,6 +1,9 @@
-import { tokenType } from "@/engine/erc20SubTypeProcessors/constants";
-import { erc20ProcessorFactory } from "@/engine/erc20SubTypeProcessors/factory";
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { getTokenPricesInfo } from "@/engine/erc20SubTypeProcessors/subtypesPrices";
 import { getTokenTypeRound1 } from "@/engine/erc20SubTypeProcessors/subtypesRound1";
+import { getTokenTypeRound2 } from "@/engine/erc20SubTypeProcessors/subtypesRound2";
+import { getTokenTypeRound3 } from "@/engine/erc20SubTypeProcessors/subtypesRound3";
+import { getTokenTypeRound4 } from "@/engine/erc20SubTypeProcessors/subtypesRound4";
 import { ComputedValueService } from "@/modules/v4/computedValue";
 import { TokenRepository } from "@/modules/v4/token/token.repository";
 import { TokenService } from "@/modules/v4/token/token.service";
@@ -13,13 +16,12 @@ export class Erc20DynamicData {
         const pricer = await Pricer.load();
         // Round 1: Get the high level type for each token (will need to be refined lated with more calls)
         const callsRounds1 = [];
-        const tokenTypeDataByCampaign = {};
+        const tokenTypesByCampaign = {};
         for (const campaign of campaigns) {
             const typeStruct = {
                 type: tokenType.unknown,
                 calls: [],
                 typeInfo: {},
-                processor: erc20ProcessorFactory(tokenType.unknown, campaign),
             };
             const targetToken = campaign.campaignParameters.targetToken;
             typeStruct.calls = [
@@ -60,114 +62,74 @@ export class Erc20DynamicData {
                 },
             ];
             callsRounds1.push(...typeStruct.calls);
-            tokenTypeDataByCampaign[campaign.campaignId] = typeStruct;
+            tokenTypesByCampaign[campaign.campaignId] = typeStruct;
         }
-        const resultRound1 = (await ChainInteractionService(chainId).fetchState(callsRounds1)).map(x => x.returnData);
+        const resultRound1 = await ChainInteractionService(chainId).fetchState(callsRounds1);
         // Round 2: Decode result from round 1 and get some additional info for the types before the final calls
         const callsRounds2 = [];
         let i = 0;
         for (const campaign of campaigns) {
-            const tokenTypeData = tokenTypeDataByCampaign[campaign.campaignId];
-            const callsForCampaign = tokenTypeData.calls.length;
-            const res = getTokenTypeRound1(resultRound1, i, campaign); // TODO use processor
-            tokenTypeData.calls = res.calls;
-            tokenTypeData.typeInfo = res.typeInfo;
-            tokenTypeData.processor = erc20ProcessorFactory(res.type, campaign);
+            const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+            tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
             i += callsForCampaign;
-            callsRounds2.push(...tokenTypeDataByCampaign[campaign.campaignId].calls);
+            callsRounds2.push(...tokenTypesByCampaign[campaign.campaignId].calls);
         }
-        const resultRound2 = (await ChainInteractionService(chainId).fetchState(callsRounds2)).map(x => x.returnData);
+        const resultRound2 = await ChainInteractionService(chainId).fetchState(callsRounds2);
         // Round 3: Decode result from round 2 and get some additional info for the types before the final calls
         const callsRounds3 = [];
         let j = 0;
         for (const campaign of campaigns) {
-            const { processor, typeInfo } = tokenTypeDataByCampaign[campaign.campaignId];
-            const tokenTypeData = tokenTypeDataByCampaign[campaign.campaignId];
-            const callsForCampaign = tokenTypeData.calls.length;
-            try {
-                const res = await processor.computeRound2(j, processor.type, typeInfo, resultRound2, campaign);
-                tokenTypeData.calls = res.calls;
-                tokenTypeData.typeInfo = res.typeInfo;
-            }
-            catch {
-                // In case something goes wrong, we set following calls to void an move on
-                tokenTypeData.calls = [];
-                tokenTypeData.typeInfo = typeInfo;
-            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+            tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound2(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultRound2, campaign);
             j += callsForCampaign;
-            callsRounds3.push(...tokenTypeDataByCampaign[campaign.campaignId].calls);
+            callsRounds3.push(...tokenTypesByCampaign[campaign.campaignId].calls);
         }
-        const resultRound3 = (await ChainInteractionService(chainId).fetchState(callsRounds3)).map(x => x.returnData);
+        const resultRound3 = await ChainInteractionService(chainId).fetchState(callsRounds3);
         // Final round before execute
-        let callsRounds4 = [];
+        let callsFinal = [];
         j = 0;
         for (const campaign of campaigns) {
-            const { processor, typeInfo } = tokenTypeDataByCampaign[campaign.campaignId];
-            const tokenTypeData = tokenTypeDataByCampaign[campaign.campaignId];
-            const callsForCampaign = tokenTypeData.calls.length;
-            try {
-                const res = await processor.computeRound3(j, processor.type, typeInfo, resultRound3);
-                tokenTypeData.calls = res.calls;
-                tokenTypeData.typeInfo = res.typeInfo;
-            }
-            catch {
-                // In case something goes wrong, we set following calls to void an move on
-                tokenTypeData.calls = [];
-                tokenTypeData.typeInfo = typeInfo;
-            }
+            const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+            tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound3(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultRound3);
             j += callsForCampaign;
-            callsRounds4 = callsRounds4.concat(tokenTypeDataByCampaign[campaign.campaignId].calls);
+            callsFinal = callsFinal.concat(tokenTypesByCampaign[campaign.campaignId].calls);
         }
         // Round 4: Get the final data
-        const resultRound4 = (await ChainInteractionService(chainId).fetchState(callsRounds4)).map(x => x.returnData);
+        const resultsFinal = await ChainInteractionService(chainId).fetchState(callsFinal);
         j = 0;
         let calls = [];
         for (const campaign of campaigns) {
-            const { processor, typeInfo } = tokenTypeDataByCampaign[campaign.campaignId];
-            const tokenTypeData = tokenTypeDataByCampaign[campaign.campaignId];
-            const callsForCampaign = tokenTypeData.calls.length;
-            try {
-                const res = await processor.computeRound4(j, processor.type, typeInfo, resultRound4, campaign);
-                tokenTypeData.calls = res.calls;
-                tokenTypeData.typeInfo = res.typeInfo;
-            }
-            catch {
-                // In case something goes wrong, we set following calls to void an move on
-                tokenTypeData.calls = [];
-                tokenTypeData.typeInfo = typeInfo;
-            }
+            const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+            tokenTypesByCampaign[campaign.campaignId] = getTokenTypeRound4(j, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, resultsFinal, campaign);
             j += callsForCampaign;
-            calls = calls.concat(tokenTypeDataByCampaign[campaign.campaignId].calls);
+            calls = calls.concat(tokenTypesByCampaign[campaign.campaignId].calls);
         }
-        const resultFinal = (await ChainInteractionService(chainId).fetchState(calls)).map(x => x.returnData);
+        const result = await ChainInteractionService(chainId).fetchState(calls);
         i = 0;
         const dynamicData = [];
         for (const campaign of campaigns) {
+            // const priceRewardToken =
+            //   (await pricer.get({
+            //     address: campaign.rewardToken,
+            //     chainId,
+            //     symbol: campaign.campaignParameters.symbolRewardToken,
+            //   })) ?? 0;
             const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
-            const { processor, typeInfo } = tokenTypeDataByCampaign[campaign.campaignId];
-            const tokenTypeData = tokenTypeDataByCampaign[campaign.campaignId];
-            const callsForCampaign = tokenTypeData.calls.length;
-            try {
-                const res = await processor.computeRound5(j, processor.type, typeInfo, resultFinal, campaign, pricer);
-                tokenTypeData.calls = res.calls;
-                tokenTypeData.typeInfo = res.typeInfo;
-            }
-            catch {
-                // In case something goes wrong, we set following calls to void an move on
-                tokenTypeData.calls = [];
-                tokenTypeData.typeInfo = typeInfo;
-            }
+            // Get the data from the final round and process it to get the price of the target token and some extra info
+            const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
+            tokenTypesByCampaign[campaign.campaignId] = await getTokenPricesInfo(i, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, result.map(r => r.returnData), campaign, pricer);
             try {
-                if (!!tokenTypeDataByCampaign[campaign.campaignId]?.typeInfo.priceTargetToken && getEnv() === "prod")
-                    await TokenRepository.updateAddressPrices(campaign.campaignParameters.targetToken, tokenTypeDataByCampaign[campaign.campaignId]?.typeInfo.priceTargetToken);
+                if (!!tokenTypesByCampaign[campaign.campaignId]?.typeInfo.priceTargetToken && getEnv() === "prod")
+                    await TokenRepository.updateAddressPrices(campaign.campaignParameters.targetToken, tokenTypesByCampaign[campaign.campaignId]?.typeInfo.priceTargetToken);
             }
             catch (e) {
                 log.warn(`failed to update target token price: ${e}`);
             }
             i += callsForCampaign;
-            let whitelistedSupplyTargetToken = tokenTypeDataByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
+            let whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
             const totalSupplyTargetToken = whitelistedSupplyTargetToken;
-            const priceTargetToken = tokenTypeDataByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
+            const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
             let lastEligibilityRatio = 1;
             if (!!campaign.campaignParameters.hooks?.length) {
                 lastEligibilityRatio =
@@ -203,15 +165,15 @@ export class Erc20DynamicData {
                 apr = getFixedApr(campaign, priceRewardToken, priceTargetToken);
             }
             if (campaign.chainId === ChainId.ETHERLINK) {
-                whitelistedSupplyTargetToken = tokenTypeDataByCampaign[campaign.campaignId].typeInfo.totalSupply;
+                whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;
             }
             dynamicData.push({
                 ...campaign,
                 apr,
                 totalSupplyTargetToken,
                 tvl: whitelistedSupplyTargetToken * priceTargetToken,
-                type: processor.type,
-                typeInfo,
+                type: tokenTypesByCampaign[campaign.campaignId].type,
+                typeInfo: tokenTypesByCampaign[campaign.campaignId].typeInfo,
                 priceRewardToken: priceRewardToken,
                 lastEligibilityRatio,
             });

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

@@ -1,8 +1,7 @@
 import type { Pricer } from "@/utils/pricer";
-import { type CallDto, type CampaignParameters } from "@sdk";
+import { type CallDto, type Campaign, type CampaignParameters } from "@sdk";
 import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
-import { type tokenType } from "./constants";
-import type { tokenTypeStruct } from "./interface";
+import { type tokenType, type tokenTypeStruct } from "./helpers/tokenType";
 export declare enum Round {
     one = "round1",
     two = "round2",
@@ -10,13 +9,14 @@ export declare enum Round {
     four = "round4"
 }
 export type callType = {
-    key: string;
-    call: string;
-    target: string;
-    callArgs?: string;
+    key: any;
+    call: any;
+    target: any;
+    metaData?: any;
     optional?: boolean;
 };
 export type mandatoryCallKeys = {
+    type: tokenType;
     protocol: string;
     tokenAddress: string;
     blacklistedSupply: string;
@@ -28,8 +28,11 @@ 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;
@@ -39,6 +42,7 @@ export type dataRaw = {
 } & stakingKeys;
 export type dataType = {
     protocol: string;
+    type: tokenType;
     tokenAddress: string;
     totalSupply: number;
     blacklistedSupply: number;
@@ -59,11 +63,6 @@ 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[];
@@ -76,23 +75,24 @@ 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<ERC20SupportedCampaignType>): {
+    handleWhiteListBlacklistRound5(typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): {
         whitelistedSupplyTargetToken: any;
         totalSupply: any;
         blacklistedSupply: any;
     };
-    processingRound5(_index: number, type: tokenType, typeInfo: DataRaw, _calls: string[], campaign: CampaignParameters<ERC20SupportedCampaignType>, pricer: Pricer): Promise<Output>;
-    computeRound1(typeInfo: DataRaw): tokenTypeStruct;
+    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;
     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<ERC20SupportedCampaignType>): CallDto[];
-    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<ERC20SupportedCampaignType>): CallDto[];
+    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[];
     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 "./constants";
-import { parseForStaking } from "./subtypesRound1";
+import { tokenTypeToProtocolAndAction } from "./helpers/tokenType";
 export var Round;
 (function (Round) {
     Round["one"] = "round1";
@@ -19,16 +19,6 @@ 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: [],
@@ -46,6 +36,7 @@ export class GenericProcessor {
         round3: [],
         round4: [],
     };
+    debug = false;
     processingRound1(_typeInfo) { }
     processingRound2(_typeInfo, _campaign) { }
     processingRound3(_typeInfo) { }
@@ -78,38 +69,38 @@ export class GenericProcessor {
             priceTargetToken,
             tvl,
             blacklistedSupply,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
         };
     }
-    computeRound1(typeInfo) {
-        typeInfo = { type: this.type, ...tokenTypeToProtocolAndAction[this.type], ...typeInfo };
+    computeRound1(type, typeInfo) {
+        typeInfo = { type, ...tokenTypeToProtocolAndAction[type], ...typeInfo };
         this.processingRound1(typeInfo);
-        let calls = this.encodeNextRound(Round.one, this.type, typeInfo);
-        if (this.isStaking) {
-            calls = calls.concat(this.encodeStakingNextRound(Round.one, this.type, typeInfo));
+        let calls = this.encodeNextRound(Round.one, type, typeInfo);
+        if (typeInfo.isStaking === "true") {
+            calls = calls.concat(this.encodeStakingNextRound(Round.one, type, typeInfo));
         }
         if (this.debug) {
             console.log("Round 1", {
-                type: this.type,
+                type: type,
                 calls,
                 typeInfo,
             });
         }
         return {
-            type: this.type,
+            type: type,
             calls,
             typeInfo,
         };
     }
     computeRound2(index, type, typeInfo, calls, campaign) {
         this.decodePreviousRound(Round.one, calls, typeInfo, type, index);
-        if (this.isStaking) {
+        if (typeInfo.isStaking === "true") {
             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 (this.isStaking) {
+        if (typeInfo.isStaking === "true") {
             nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.two, type, typeInfo));
         }
         if (this.debug) {
@@ -127,12 +118,12 @@ export class GenericProcessor {
     }
     computeRound3(index, type, typeInfo, calls) {
         this.decodePreviousRound(Round.two, calls, typeInfo, type, index);
-        if (this.isStaking) {
+        if (typeInfo.isStaking === "true") {
             this.decodePreviousStakingRound(Round.two, calls, typeInfo, type, index + this.rounds.round2.length);
         }
         this.processingRound3(typeInfo);
         let nextCalls = this.encodeNextRound(Round.three, type, typeInfo);
-        if (this.isStaking) {
+        if (typeInfo.isStaking === "true") {
             nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.three, type, typeInfo));
         }
         if (this.debug) {
@@ -152,12 +143,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 (this.isStaking) {
+        if (typeInfo.isStaking === "true") {
             this.decodePreviousStakingRound(Round.three, calls, typeInfo, type, index + this.rounds.round3.length);
         }
         this.processingRound4(typeInfo);
         let nextCalls = this.encodeNextRound(Round.four, type, typeInfo);
-        if (this.isStaking) {
+        if (typeInfo.isStaking === "true") {
             nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.four, type, typeInfo));
         }
         if (this.debug) {
@@ -181,7 +172,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 (this.isStaking) {
+        if (typeInfo.isStaking === "true") {
             this.decodePreviousStakingRound(Round.four, calls, typeInfo, type, index + this.rounds.round4.length);
         }
         const outputInfo = (await this.processingRound5(index, type, typeInfo, calls, campaign, pricer));
@@ -189,13 +180,19 @@ export class GenericProcessor {
             console.log("Round 5", {
                 type: type,
                 calls: [],
-                typeInfo: outputInfo,
+                typeInfo: {
+                    ...outputInfo,
+                    icons: generateIcons(type, typeInfo, campaign),
+                },
             });
         }
         return {
             type: type,
             calls: [],
-            typeInfo: outputInfo,
+            typeInfo: {
+                ...outputInfo,
+                icons: generateIcons(type, typeInfo, campaign),
+            },
         };
     }
     generateWhitelistCall(type, typeInfo, campaign) {
@@ -277,12 +274,12 @@ export class GenericProcessor {
     }
     encodeRound(round, callInfo, type) {
         return round
-            .map(({ call, target, callArgs, optional }) => {
-            if (!optional && !callInfo[target]) {
+            .map(({ call, target, metaData, optional }) => {
+            if (optional && !callInfo[target]) {
                 return [];
             }
-            if (callArgs) {
-                return createCall(callInfo[target], call, type, callInfo[callArgs]);
+            if (metaData) {
+                return createCall(callInfo[target], call, type, callInfo[metaData]);
             }
             return createCall(callInfo[target], call, type);
         })

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

@@ -1,4 +1,4 @@
-import { tokenType } from "../constants";
+import { tokenType } from "./tokenType";
 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 "../constants";
+import { tokenType } from "./tokenType";
 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 "../constants";
+import { tokenType } from "./tokenType";
 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 "../constants";
+import { tokenType } from "./tokenType";
 const chainAddressToType = {
     [ChainId.CORN]: {
         "0xab3291b73a1087265e126e330cede0cfd4b8a693": tokenType.curveNPool,

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

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

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

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

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

@@ -1,5 +1,6 @@
 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",
@@ -102,3 +103,8 @@ 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/implementations/AaveProcessor.d.ts

@@ -1,11 +1,12 @@
 import type { Pricer } from "@/utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType } from "../constants";
+import type { tokenType } from "../helpers/tokenType";
 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,6 +7,7 @@ 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;
@@ -16,7 +17,7 @@ export class AaveProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             tvl: tvl,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, 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 } from "../constants";
-import type { tokenTypeStruct } from "../interface";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawAnglesLiquid;
     call: string;
     target: keyof callKeysAnglesLiquid;
+    metaData?: keyof callKeysAnglesLiquid;
 };
 type callKeysAnglesLiquid = mandatoryCallKeys & {
     poolToken: string;
@@ -26,6 +26,7 @@ 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,6 +12,7 @@ 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;
@@ -28,10 +29,13 @@ export class AnglesLiquidProcessor extends GenericProcessor {
             symbolUnderlyingToken,
             totalAssets: typeInfo.totalAssets,
             poolToken: typeInfo.poolToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, 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,11 +1,12 @@
 import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import { tokenType } from "../constants";
+import { tokenType } from "../helpers/tokenType";
 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 "../constants";
+import { tokenType } from "../helpers/tokenType";
 export class AssetProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -41,7 +41,7 @@ export class AssetProcessor extends GenericProcessor {
             exchangeRate,
             whitelistedSupplyTargetToken,
             blacklistedSupply,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
         };
     }