@merkl/api 0.20.66 → 0.20.68

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

@@ -1,13 +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 dataRawUni;
     call: string;
     target: keyof callKeysUni;
-    callArgs?: keyof callKeysUni;
+    metaData?: keyof callKeysUni;
 };
 type callKeysUni = mandatoryCallKeys & {
     token0: string;

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

@@ -13,8 +13,8 @@ export class UniswapProcessor extends GenericProcessor {
             { key: "symbolToken1", call: "symbol", target: "token1" },
             { key: "decimalsToken0", call: "decimals", target: "token0" },
             { key: "decimalsToken1", call: "decimals", target: "token1" },
-            { key: "balanceToken0", call: "balanceOf", target: "token0", callArgs: "tokenAddress" },
-            { key: "balanceToken1", call: "balanceOf", target: "token1", callArgs: "tokenAddress" },
+            { key: "balanceToken0", call: "balanceOf", target: "token0", metaData: "tokenAddress" },
+            { key: "balanceToken1", call: "balanceOf", target: "token1", metaData: "tokenAddress" },
         ],
         round3: [],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
@@ -58,7 +58,7 @@ export class UniswapProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             tvl,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             decimalsToken0,
             decimalsToken1,
             balanceToken0,

package/dist/src/engine/erc20SubTypeProcessors/implementations/VicunaProcessor.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 dataRawVicuna;
     call: string;
     target: keyof callKeysVicuna;
+    metaData?: any;
 };
 type callKeysVicuna = mandatoryCallKeys & {
     tokenPrice: string;

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

@@ -29,7 +29,7 @@ export class VicunaProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/WoofiProcessor.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 type { tokenType } from "../constants";
+import type { tokenType } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBeefy;
     call: string;
     target: keyof callKeysBeefy;
+    metaData?: keyof callKeysBeefy;
 };
 type callKeysBeefy = mandatoryCallKeys & {
     decimalsToken: string;

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

@@ -15,6 +15,7 @@ export class WoofiProcessor extends GenericProcessor {
         round3: [],
         round4: [],
     };
+    // override computeRound1(): void {}
     async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const priceToken = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
@@ -31,7 +32,7 @@ export class WoofiProcessor extends GenericProcessor {
             totalSupply,
             whitelistedSupplyTargetToken,
             blacklistedSupply,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             pricePerShare,
             tvl,
             tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],

package/dist/src/engine/erc20SubTypeProcessors/implementations/ZkSwapThreePoolProcessor.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 { tokenType } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawzkSwapThreePool;
     call: string;
     target: keyof callKeysZkswapThreePool;
-    callArgs?: keyof callKeysZkswapThreePool;
+    metaData?: keyof callKeysZkswapThreePool;
 };
 type callKeysZkswapThreePool = mandatoryCallKeys & {
     balances: string;

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

@@ -5,12 +5,12 @@ export class ZkSwapThreePoolProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "pool", call: "minter", target: "tokenAddress" }],
         round2: [
-            { key: "token0Address", call: "coins", target: "pool", callArgs: "token0Index" },
-            { key: "balance0", call: "balances", target: "pool", callArgs: "token0Index" },
-            { key: "token1Address", call: "coins", target: "pool", callArgs: "token1Index" },
-            { key: "balance1", call: "balances", target: "pool", callArgs: "token1Index" },
-            { key: "token2Address", call: "coins", target: "pool", callArgs: "token2Index" },
-            { key: "balance2", call: "balances", target: "pool", callArgs: "token2Index" },
+            { key: "token0Address", call: "coins", target: "pool", metaData: "token0Index" },
+            { key: "balance0", call: "balances", target: "pool", metaData: "token0Index" },
+            { key: "token1Address", call: "coins", target: "pool", metaData: "token1Index" },
+            { key: "balance1", call: "balances", target: "pool", metaData: "token1Index" },
+            { key: "token2Address", call: "coins", target: "pool", metaData: "token2Index" },
+            { key: "balance2", call: "balances", target: "pool", metaData: "token2Index" },
         ],
         round3: [
             { key: "symbolToken0", call: "symbol", target: "token0Address" },
@@ -45,7 +45,7 @@ export class ZkSwapThreePoolProcessor extends GenericProcessor {
         return {
             ...rest,
             blacklistedSupply,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             priceTargetToken: priceTargetToken,
             totalSupply,
             tvl,

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

@@ -1,13 +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 dataRawCurveN;
     call: string;
     target: keyof callKeysCurveN;
-    callArgs?: keyof callKeysCurveN | string;
+    metaData?: keyof callKeysCurveN | string;
     optional?: boolean;
 };
 type callKeysCurveN = mandatoryCallKeys & {

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

@@ -12,12 +12,13 @@ export class CurveNPoolProcessor extends GenericProcessor {
         round3: [],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
+    // override computeRound1(): void {}
     processingRound2(typeInfo) {
         typeInfo.numberTokens = Number(typeInfo.numberTokens);
         for (let i = 0; i < typeInfo.numberTokens; i++) {
             typeInfo[`${i}`] = i.toString();
             this.rounds.round2 = this.rounds.round2.concat([
-                { key: `token${i}`, call: "coins", target: "tokenAddress", callArgs: i.toString() },
+                { key: `token${i}`, call: "coins", target: "tokenAddress", metaData: i.toString() },
             ]);
         }
     }
@@ -26,14 +27,14 @@ export class CurveNPoolProcessor extends GenericProcessor {
             this.rounds.round3 = this.rounds.round3.concat([
                 { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
                 { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
-                { key: `balanceToken${i}`, call: "balances", target: "tokenAddress", callArgs: i.toString() },
+                { key: `balanceToken${i}`, call: "balances", target: "tokenAddress", metaData: i.toString() },
             ]);
         }
     }
     computeRound3(index, type, typeInfo, calls) {
         for (let i = 0; i < typeInfo.numberTokens; i++) {
             this.rounds.round2 = this.rounds.round2.concat([
-                { key: `token${i}`, call: "coins", target: "tokenAddress", callArgs: i.toString() },
+                { key: `token${i}`, call: "coins", target: "tokenAddress", metaData: i.toString() },
             ]);
         }
         return super.computeRound3(index, type, typeInfo, calls);
@@ -43,7 +44,7 @@ export class CurveNPoolProcessor extends GenericProcessor {
             this.rounds.round3 = this.rounds.round3.concat([
                 { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
                 { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
-                { key: `balanceToken${i}`, call: "balances", target: "tokenAddress", callArgs: i.toString() },
+                { key: `balanceToken${i}`, call: "balances", target: "tokenAddress", metaData: i.toString() },
             ]);
         }
         return super.computeRound4(index, type, typeInfo, calls, campaign);
@@ -90,7 +91,7 @@ export class CurveNPoolProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay,
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/curveProcessor.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 dataRawCurve;
     call: string;
     target: keyof callKeysCurve;
+    metaData?: keyof callKeysCurve;
     optional?: boolean;
 };
 type callKeysCurve = mandatoryCallKeys & {

package/dist/src/engine/erc20SubTypeProcessors/implementations/curveProcessor.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 CurveProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -18,6 +18,7 @@ export class CurveProcessor 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 lp_price = BN2Number(typeInfo.lp_price, 18);
@@ -73,7 +74,7 @@ export class CurveProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay,
         };
     }

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

@@ -0,0 +1,6 @@
+import { GenericProcessor } from "../GenericProcessor";
+import type { callKeys, dataRaw, dataType } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+export declare const processorMapping: {
+    [key in tokenType]: typeof GenericProcessor<callKeys, dataRaw, dataType>;
+};

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

@@ -1,51 +1,51 @@
-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 = {
+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 = {
     [tokenType.uniswapv2]: UniswapProcessor,
     [tokenType.balancerGauge]: BalancerGaugeProcessor,
     [tokenType.balancerPool]: BalancerPoolProcessor,
@@ -143,4 +143,3 @@ const map = {
     [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/implementations/stakedCurveProcessor.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 { tokenType } from "../constants";
+import { tokenType } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawStakedCurve;
     call: string;
     target: keyof callKeysStakedCurve;
-    callArgs?: keyof callKeysStakedCurve;
+    metaData?: keyof callKeysStakedCurve;
     optional?: boolean;
 };
 type callKeysStakedCurve = mandatoryCallKeys & {

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

@@ -2,7 +2,7 @@ import { generateCardName } from "@/utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { BigNumber } from "ethers";
 import { GenericProcessor } from "../GenericProcessor";
-import { tokenType } from "../constants";
+import { tokenType } from "../helpers/tokenType";
 export class StakedCurveProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
@@ -19,10 +19,11 @@ export class StakedCurveProcessor extends GenericProcessor {
             { key: "symbolToken2", call: "symbol", target: "token2", optional: true },
         ],
         round4: [
-            { key: "toAssets", call: "convertToAssets", target: "tokenAddress", callArgs: "amount" },
+            { key: "toAssets", call: "convertToAssets", target: "tokenAddress", metaData: "amount" },
             { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
         ],
     };
+    // override computeRound1(): void {}
     processingRound3(typeInfo) {
         typeInfo.amount = BigNumber.from(10).pow(18).toString();
     }
@@ -80,7 +81,7 @@ export class StakedCurveProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay,
         };
     }

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

@@ -1,12 +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 dataRawxU308;
     call: string;
     target: keyof callKeysxU308;
-    callArgs?: keyof callKeysxU308;
+    metaData?: keyof callKeysxU308;
 };
 type callKeysxU308 = mandatoryCallKeys & {
     pool: string;

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

@@ -13,11 +13,12 @@ export class xU308Processor extends GenericProcessor {
             { key: "symbolToken1", call: "symbol", target: "_token1" },
             { key: "decimalsToken0", call: "decimals", target: "_token0" },
             { key: "decimalsToken1", call: "decimals", target: "_token1" },
-            { key: "balanceToken0", call: "balanceOf", target: "_token0", callArgs: "pool" },
-            { key: "balanceToken1", call: "balanceOf", target: "_token1", callArgs: "pool" },
+            { key: "balanceToken0", call: "balanceOf", target: "_token0", metaData: "pool" },
+            { key: "balanceToken1", call: "balanceOf", target: "_token1", metaData: "pool" },
         ],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
+    // override computeRound1(): void {}
     processingRound2(typeInfo) {
         typeInfo.pool = "0xB387D0A73619791420De4a1e5e710023Cb0f49c0";
     }
@@ -34,7 +35,7 @@ export class xU308Processor extends GenericProcessor {
             blacklistedSupply,
             priceTargetToken,
             totalSupply,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
         };
     }

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

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

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

@@ -0,0 +1,24 @@
+import { tokenType } from "./helpers/tokenType";
+import { processorMapping } from "./implementations/processorMapping";
+export async function getTokenPricesInfo(index, type, typeInfo, calls, campaign, pricer) {
+    const ProcessorClass = processorMapping[type];
+    try {
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: tokenType.unknown,
+            calls: [],
+            typeInfo: {
+                totalSupply: 0,
+                blacklistedSupply: 0,
+                priceTargetToken: 0,
+            },
+        };
+    }
+}

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

@@ -1,17 +1,3 @@
-import type { CampaignParameters } from "@sdk";
-import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
-import { tokenType } from "./constants";
-declare function generateResult(type: tokenType, name: string, campaign: CampaignParameters<ERC20SupportedCampaignType>, data?: {
-    owner?: string;
-    factory?: string;
-    fundValueCalculator?: string;
-    dispatcher?: string;
-}): import("./interface").tokenTypeStruct;
-export declare function parseForStaking(campaign: CampaignParameters<ERC20SupportedCampaignType>): {
-    isStaking: false;
-} | {
-    isStaking: true;
-    stakingContract: string;
-};
-export declare function getTokenTypeRound1(callResults: string[], index: number, campaign: CampaignParameters<ERC20SupportedCampaignType>): ReturnType<typeof generateResult>;
-export {};
+import type { Campaign, CampaignParameters, ResultDto } from "@sdk";
+import { type tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound1(calls: ResultDto[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;