@merkl/api 0.20.65 → 0.20.67

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

@@ -2,13 +2,12 @@ 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 } from "../constants";
-import type { tokenTypeStruct } from "../interface";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawAura;
     call: string;
     target: keyof callKeysAura;
-    callArgs?: keyof callKeysAura;
+    metaData?: keyof callKeysAura;
 };
 type callKeysAura = mandatoryCallKeys & {
     balancerPool: string;

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

@@ -15,18 +15,19 @@ 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", callArgs: "pid" },
+            { key: "gaugeContract", call: "poolInfo", target: "auraOperator", metaData: "pid" },
             { key: "auraStaker", call: "staker", target: "auraOperator" },
         ],
         round3: [
-            { 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: "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: "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];
@@ -87,7 +88,7 @@ export class AuraProcessor extends GenericProcessor {
             blacklistedSupply,
             tvl: tvl,
             priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign, symbols),
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
             tokensDisplay,
         };
     }

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

@@ -2,13 +2,12 @@ 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 } from "../constants";
-import type { tokenTypeStruct } from "../interface";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBG;
     call: string;
     target: keyof callKeysBG;
-    callArgs?: keyof callKeysBG;
+    metaData?: keyof callKeysBG;
 };
 type callKeysBG = mandatoryCallKeys & {
     gyroscopeToken: string;

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

@@ -11,14 +11,15 @@ export class BEXRewardGaugeProcessor extends GenericProcessor {
             { key: "totalSupplyUnderlyingPoolTokens", call: "totalSupply", target: "gyroscopeToken" },
             { key: "poolId", call: "getPoolId", target: "gyroscopeToken" },
             { key: "vault", call: "getVault", target: "gyroscopeToken" },
-            { key: "poolHolderBalance", call: "balanceOf", target: "gyroscopeToken", callArgs: "poolHolder" },
+            { key: "poolHolderBalance", call: "balanceOf", target: "gyroscopeToken", metaData: "poolHolder" },
         ],
         round3: [
-            { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", callArgs: "poolId" },
-            { key: "vaultBalance", call: "balanceOf", target: "gyroscopeToken", callArgs: "vault" },
+            { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
+            { key: "vaultBalance", call: "balanceOf", target: "gyroscopeToken", metaData: "vault" },
         ],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
+    // override computeRound1(): void {}
     processingRound2(typeInfo) {
         typeInfo.poolHolder = "0xC2BaA8443cDA8EBE51a640905A8E6bc4e1f9872c";
     }
@@ -85,7 +86,7 @@ export class BEXRewardGaugeProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign, symbols),
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
             tokensDisplay,
         };
     }

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

@@ -2,13 +2,12 @@ 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 } from "../constants";
-import type { tokenTypeStruct } from "../interface";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBG;
     call: string;
     target: keyof callKeysBG;
-    callArgs?: keyof callKeysBG;
+    metaData?: keyof callKeysBG;
 };
 type callKeysBG = mandatoryCallKeys & {
     gyroscopeToken: string;

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

@@ -7,14 +7,15 @@ export class BalancerGaugeProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "gyroscopeToken", call: "lp_token", target: "tokenAddress" }],
         round2: [
-            { key: "balanceUnderlyingPoolTokens", call: "balanceOf", target: "gyroscopeToken", callArgs: "tokenAddress" },
+            { key: "balanceUnderlyingPoolTokens", call: "balanceOf", target: "gyroscopeToken", metaData: "tokenAddress" },
             { key: "totalSupplyUnderlyingPoolTokens", call: "totalSupply", target: "gyroscopeToken" },
             { key: "poolId", call: "getPoolId", target: "gyroscopeToken" },
             { key: "vault", call: "getVault", target: "gyroscopeToken" },
         ],
-        round3: [{ key: "poolTokensRaw", call: "getPoolTokens", target: "vault", callArgs: "poolId" }],
+        round3: [{ key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" }],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
+    // override computeRound1(): void {}
     processingRound4(typeInfo) {
         const tokens = typeInfo.poolTokensRaw[0];
         const balances = typeInfo.poolTokensRaw[1];
@@ -60,7 +61,7 @@ export class BalancerGaugeProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign, symbols),
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
             tokensDisplay,
         };
     }

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

@@ -2,13 +2,12 @@ import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { BigNumber } from "ethers";
 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 dataRawBP;
     call: string;
     target: keyof callKeysBP;
-    callArgs?: keyof callKeysBP;
+    metaData?: keyof callKeysBP;
 };
 type callKeysBP = mandatoryCallKeys & {
     tokenAddress: string;

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

@@ -12,12 +12,13 @@ export class BalancerPoolProcessor extends GenericProcessor {
             { key: "poolId", call: "getPoolId", target: "tokenAddress" },
             { key: "vault", call: "getVault", target: "tokenAddress" },
         ],
-        round3: [{ key: "poolTokensRaw", call: "getPoolTokens", target: "vault", callArgs: "poolId" }],
+        round3: [{ key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" }],
         round4: [
             { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
-            { key: "vaultBalance", call: "balanceOf", target: "tokenAddress", callArgs: "vault" },
+            { key: "vaultBalance", call: "balanceOf", target: "tokenAddress", metaData: "vault" },
         ],
     };
+    // override computeRound1(): void {}
     async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
         let { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const totalSupplyBN = BigNumber.from(typeInfo.totalSupply);
@@ -54,7 +55,7 @@ export class BalancerPoolProcessor extends GenericProcessor {
             blacklistedSupply,
             tvl: tvl,
             priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign, symbols),
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
             vaultBalance: vaultBalance,
             tokensDisplay,
         };

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

@@ -2,12 +2,12 @@ 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 } from "../constants";
-import type { tokenTypeStruct } from "../interface";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBalancerV3;
     call: string;
     target: keyof callKeysBalancerV3;
+    metaData?: keyof callKeysBalancerV3 | string;
     optional?: boolean;
 };
 type callKeysBalancerV3 = mandatoryCallKeys & {

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

@@ -15,6 +15,7 @@ export class BalancerV3PoolProcessor 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++) {
@@ -73,7 +74,7 @@ export class BalancerV3PoolProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign, symbols),
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
             tokensDisplay,
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/BeefyProcessor.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 dataRawBeefy;
     call: string;
     target: keyof callKeysBeefy;
-    callArgs?: keyof callKeysBeefy;
+    metaData?: keyof callKeysBeefy;
 };
 type callKeysBeefy = mandatoryCallKeys & {
     underlying: string;

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

@@ -16,8 +16,8 @@ export class BeefyProcessor 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: "underlying" },
-            { key: "balanceToken1", call: "balanceOf", target: "token1", callArgs: "underlying" },
+            { key: "balanceToken0", call: "balanceOf", target: "token0", metaData: "underlying" },
+            { key: "balanceToken1", call: "balanceOf", target: "token1", metaData: "underlying" },
         ],
         round4: [
             { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
@@ -42,7 +42,7 @@ export class BeefyProcessor extends GenericProcessor {
             totalSupply,
             whitelistedSupplyTargetToken,
             blacklistedSupply,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             pricePerShare,
             tvl,
             tokensDisplay: [

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

@@ -2,12 +2,12 @@ import type { Pricer } from "@/utils/pricer";
 import { type Campaign, type CampaignParameters, type UniswapV4PoolKey } from "@sdk";
 import type { PoolStateStructOutput } from "libs/sdk/src/generated/BunniV2Hub";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
-import type { tokenType } from "../constants";
+import type { tokenType } from "../helpers/tokenType";
 type callType = {
     key: keyof dataRawBunniV2;
     call: string;
     target: keyof callKeysBunniV2;
-    callArgs?: keyof callKeysBunniV2;
+    metaData?: keyof callKeysBunniV2;
 };
 type callKeysBunniV2 = mandatoryCallKeys & {
     decimalsToken0: string;

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

@@ -30,7 +30,7 @@ export class BunniV2Processor extends GenericProcessor {
                 key: "poolState",
                 call: "poolState",
                 target: "hub",
-                callArgs: "poolId",
+                metaData: "poolId",
             },
         ],
         round3: [
@@ -77,7 +77,7 @@ export class BunniV2Processor extends GenericProcessor {
             balance0: amount0.toString(),
             balance1: amount1.toString(),
             blacklistedSupply,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             priceTargetToken: priceTargetToken,
             totalSupply,
             tvl,

package/dist/src/engine/erc20SubTypeProcessors/implementations/CompoundProcessor.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 dataRawCompound;
     call: string;
     target: keyof callKeysCompound;
-    callArgs?: keyof callKeysCompound;
+    metaData?: keyof callKeysCompound;
 };
 type callKeysCompound = mandatoryCallKeys & {
     tokenAddress: string;

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

@@ -6,13 +6,14 @@ export class CompoundProcessor extends GenericProcessor {
         round1: [{ key: "baseToken", call: "baseToken", target: "tokenAddress" }],
         round2: [
             { key: "totalBorrow", call: "totalAssets", target: "tokenAddress" },
-            { key: "balanceBaseToken", call: "balanceOf", target: "baseToken", callArgs: "tokenAddress" },
+            { key: "balanceBaseToken", call: "balanceOf", target: "baseToken", metaData: "tokenAddress" },
             { key: "symbolBaseToken", call: "symbol", target: "baseToken" },
             { key: "decimalsBaseToken", call: "decimals", target: "baseToken" },
         ],
         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 totalBorrow = BN2Number(typeInfo.totalBorrow, Number(typeInfo.decimalsBaseToken));
@@ -29,7 +30,7 @@ export class CompoundProcessor extends GenericProcessor {
             blacklistedSupply,
             balanceBaseToken,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: typeInfo.symbolBaseToken, address: typeInfo.baseToken }],
         };
     }

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

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

@@ -30,7 +30,7 @@ export class ERC4626Processor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: typeInfo.symbolAsset, address: typeInfo.asset }],
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/EnzymeProcessor.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 dataRawEnzyme;
     call: string;
     target: keyof callKeysEnzyme;
-    callArgs?: keyof callKeysEnzyme;
+    metaData?: keyof callKeysEnzyme;
 };
 type callKeysEnzyme = mandatoryCallKeys & {
     factory: string;

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

@@ -4,7 +4,7 @@ import { GenericProcessor } from "../GenericProcessor";
 export class EnzymeProcessor extends GenericProcessor {
     rounds = {
         round1: [
-            { key: "exchangeRateRaw", call: "calcNetShareValue", target: "fundValueCalculator", callArgs: "tokenAddress" },
+            { key: "exchangeRateRaw", call: "calcNetShareValue", target: "fundValueCalculator", metaData: "tokenAddress" },
         ],
         round2: [{ key: "symbolUnderlyingToken", call: "symbol", target: "underlying" }],
         round3: [],
@@ -24,7 +24,7 @@ export class EnzymeProcessor extends GenericProcessor {
             priceTargetToken,
             totalSupply,
             exchangeRate,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
         };
     }

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

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

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

package/dist/src/engine/erc20SubTypeProcessors/implementations/EulerBorrowProcessor.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 dataRawEuler;
     call: string;
     target: keyof callKeysEuler;
+    metaData?: keyof callKeysEuler;
 };
 type callKeysEuler = mandatoryCallKeys & {
     addressVault: string;

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

@@ -22,7 +22,7 @@ export class EulerBorrowProcessor extends GenericProcessor {
         const priceAsset = (await pricer.get({ symbol: symbolAsset })) ?? 1;
         const totalBorrows = BN2Number(typeInfo.totalAssets, decimalsAsset);
         typeInfo.symbolUnderlyingToken = symbolAsset;
-        let cardName = generateCardName(type, this.isStaking, typeInfo, campaign);
+        let cardName = generateCardName(type, typeInfo, campaign);
         const vaultName = await fetchEulerVaultName(campaign.campaignParameters.evkAddress, campaign.chainId);
         if (!!vaultName) {
             cardName = `Borrow from ${vaultName} vault`;

package/dist/src/engine/erc20SubTypeProcessors/implementations/EulerLendProcessor.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 dataRawEuler;
     call: string;
     target: keyof callKeysEuler;
+    metaData?: keyof callKeysEuler;
 };
 type callKeysEuler = mandatoryCallKeys & {
     addressVault: string;

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

@@ -27,7 +27,7 @@ export class EulerLendProcessor extends GenericProcessor {
         }
         const totalAssets = BN2Number(typeInfo.totalAssets, decimalsAsset);
         typeInfo.symbolUnderlyingToken = symbolAsset;
-        let cardName = generateCardName(type, this.isStaking, typeInfo, campaign);
+        let cardName = generateCardName(type, typeInfo, campaign);
         const vaultName = await fetchEulerVaultName(typeInfo.tokenAddress, campaign.chainId);
         if (!!vaultName) {
             cardName = `Supply ${symbolAsset} on ${vaultName} vault`;

package/dist/src/engine/erc20SubTypeProcessors/implementations/FluidProcessor.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 dataRawFluid;
     call: string;
     target: keyof callKeysFluid;
-    callArgs?: keyof callKeysFluid;
+    metaData?: keyof callKeysFluid;
 };
 type callKeysFluid = mandatoryCallKeys & {
     underlying: string;

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

@@ -9,9 +9,10 @@ export class FluidProcessor extends GenericProcessor {
             { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
             { key: "decimalsUnderlyingToken", call: "decimals", target: "underlying" },
         ],
-        round3: [{ key: "toAssets", call: "convertToAssets", target: "tokenAddress", callArgs: "amount" }],
+        round3: [{ key: "toAssets", call: "convertToAssets", target: "tokenAddress", metaData: "amount" }],
         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 priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
@@ -26,7 +27,7 @@ export class FluidProcessor extends GenericProcessor {
             blacklistedSupply,
             totalSupply,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/FraxProcessor.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 dataRawFrax;
     call: string;
     target: keyof callKeysFrax;
+    metaData?: keyof callKeysFrax;
 };
 type callKeysFrax = mandatoryCallKeys & {
     underlying: string;

package/dist/src/engine/erc20SubTypeProcessors/implementations/FraxProcessor.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 FraxProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -35,7 +35,7 @@ export class FraxProcessor extends GenericProcessor {
             blacklistedSupply,
             sharePrice,
             priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
         };
     }

package/dist/src/engine/erc20SubTypeProcessors/implementations/GammaProcessor.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 dataRawGamma;
     call: string;
     target: keyof callKeysGamma;
+    metaData?: keyof callKeysGamma;
 };
 type callKeysGamma = mandatoryCallKeys & {
     token0: string;
@@ -34,6 +34,7 @@ export declare class GammaProcessor extends GenericProcessor<callKeysGamma, data
     };
     processingRound2(typeInfo: dataRawGamma): void;
     processingRound5(_index: number, type: tokenType, typeInfo: dataRawGamma, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGamma>;
+    computeRound1(type: tokenType, typeInfo: dataRawGamma): tokenTypeStruct;
     computeRound2(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[]): tokenTypeStruct;
     computeRound3(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[]): tokenTypeStruct;
     computeRound4(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;

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

@@ -42,13 +42,16 @@ export class GammaProcessor extends GenericProcessor {
             whitelistedSupplyTargetToken,
             blacklistedSupply,
             tvl,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [
                 { symbol: typeInfo.symbolToken0, address: typeInfo.token0 },
                 { symbol: typeInfo.symbolToken1, address: typeInfo.token1 },
             ],
         };
     }
+    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/GearboxProcessor.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 dataRawGearbox;
     call: string;
     target: keyof callKeysGearbox;
-    callArgs?: keyof callKeysGearbox;
+    metaData?: keyof callKeysGearbox;
     optional?: boolean;
 };
 type callKeysGearbox = mandatoryCallKeys & {

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

@@ -5,7 +5,7 @@ export class GearboxProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "stakingToken", call: "stakingToken", target: "tokenAddress", optional: true }],
         round2: [
-            { key: "balanceStakingToken", call: "balanceOf", target: "stakingToken", callArgs: "tokenAddress" },
+            { key: "balanceStakingToken", call: "balanceOf", target: "stakingToken", metaData: "tokenAddress" },
             { key: "totalSupplyStakingToken", call: "totalSupply", target: "stakingToken" },
             { key: "decimalsStakingToken", call: "decimals", target: "stakingToken" },
             { key: "underlyingToken", call: "underlying", target: "stakingToken" },
@@ -21,6 +21,7 @@ export class GearboxProcessor extends GenericProcessor {
         typeInfo.stakingToken = typeInfo.stakingToken ?? typeInfo.tokenAddress;
         typeInfo.isTrade = typeInfo.stakingToken === typeInfo.tokenAddress;
     }
+    // override computeRound1(): void {}
     async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const totalAssets = BN2Number(typeInfo.totalAssets, Number(typeInfo.decimalsUnderlyingToken));
@@ -50,7 +51,7 @@ export class GearboxProcessor extends GenericProcessor {
             blacklistedSupply,
             tvl: tvl,
             priceTargetToken: priceTargetToken,
-            cardName: generateCardName(type, this.isStaking, typeInfo, campaign),
+            cardName: generateCardName(type, typeInfo, campaign),
             tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlyingToken }],
         };
     }