@merkl/api 0.9.15

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

@@ -0,0 +1,44 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawBalancerV3;
+    call: string;
+    target: keyof callKeysBalancerV3;
+    metaData?: keyof callKeysBalancerV3 | string;
+    optional?: boolean;
+};
+type callKeysBalancerV3 = mandatoryCallKeys & {
+    [key: `token${number}`]: string;
+    [key: `symbolToken${number}`]: string;
+    [key: `decimalsToken${number}`]: string;
+    [key: `${number}`]: string;
+    name: string;
+};
+type dataRawBalancerV3 = callKeysBalancerV3 & {
+    numberTokens: number;
+    [key: `balanceToken${number}`]: BigNumber;
+    tokenInfo: {
+        tokens: string[];
+        tokenInfo: string[][];
+        balancesRaw: BigNumber[];
+        lastBalancesLiveScaled18: BigNumber[];
+    };
+};
+type dataTypeBalancerV3 = dataType & {
+    numberTokens: number;
+};
+export declare class BalancerV3PoolProcessor extends GenericProcessor<callKeysBalancerV3, dataRawBalancerV3, dataTypeBalancerV3> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawBalancerV3): void;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawBalancerV3, calls: string[]): tokenTypeStruct;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBalancerV3, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBalancerV3>;
+}
+export {};

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

@@ -0,0 +1,75 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+const matchSingleNumber = (input) => {
+    const regex = /^\d+$/;
+    return regex.test(input);
+};
+export class BalancerV3PoolProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "numberTokens", call: "getTokens", target: "tokenAddress" },
+            { key: "tokenInfo", call: "getTokenInfo", target: "tokenAddress" },
+        ],
+        round2: [],
+        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[`token${i}`] = typeInfo.tokenInfo.tokens[i];
+            this.rounds.round2 = this.rounds.round2.concat([
+                { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
+                { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
+            ]);
+            typeInfo[`balanceToken${i}`] = typeInfo.tokenInfo.balancesRaw[i];
+        }
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            this.rounds.round2 = this.rounds.round2.concat([
+                { key: `symbolToken${i}`, call: "symbol", target: `token${i}` },
+                { key: `decimalsToken${i}`, call: "decimals", target: `token${i}` },
+            ]);
+        }
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        let tvl = 0;
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            let symbol = typeInfo[`symbolToken${i}`];
+            const price = (await pricer.get({ symbol: symbol })) ?? 0;
+            symbol = symbol.replace("wmooSiloV2Sonic", "");
+            typeInfo[`symbolToken${i}`] = symbol.replace(" (wS Market)", "");
+            const decimals = Number(typeInfo[`decimalsToken${i}`]);
+            const amount = BN2Number(typeInfo[`balanceToken${i}`], decimals);
+            tvl += amount * price;
+        }
+        const priceTargetToken = tvl / totalSupply;
+        // Remove all keys that start with a number or balanceToken
+        for (const key in typeInfo) {
+            if (key.startsWith("balanceToken") ||
+                key.startsWith("decimalsToken") ||
+                matchSingleNumber(key) ||
+                key.startsWith("tokenInfo")) {
+                delete typeInfo[key];
+            }
+        }
+        const symbols = [];
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            symbols.push(typeInfo[`symbolToken${i}`]);
+        }
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
+        };
+    }
+}

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

@@ -0,0 +1,48 @@
+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 "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawBeefy;
+    call: string;
+    target: keyof callKeysBeefy;
+    metaData?: keyof callKeysBeefy;
+};
+type callKeysBeefy = mandatoryCallKeys & {
+    underlying: string;
+    pricePerShare: string;
+    token0: string;
+    token1: string;
+    totalSupplyUnderlying: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+};
+type dataRawBeefy = callKeysBeefy & {};
+type dataTypeBeefy = dataType & {
+    underlying: string;
+    pricePerShare: number;
+    token0: string;
+    token1: string;
+    totalSupplyUnderlying: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+    priceTargetToken: number;
+};
+export declare class BeefyProcessor extends GenericProcessor<callKeysBeefy, dataRawBeefy, dataTypeBeefy> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBeefy, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBeefy>;
+}
+export {};

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

@@ -0,0 +1,50 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class BeefyProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "pricePerShare", call: "getPricePerFullShare", target: "tokenAddress" },
+            { key: "underlying", call: "want", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "token0", call: "token0", target: "underlying" },
+            { key: "token1", call: "token1", target: "underlying" },
+        ],
+        round3: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "decimalsToken0", call: "decimals", target: "token0" },
+            { key: "decimalsToken1", call: "decimals", target: "token1" },
+            { key: "balanceToken0", call: "balanceOf", target: "token0", metaData: "underlying" },
+            { key: "balanceToken1", call: "balanceOf", target: "token1", metaData: "underlying" },
+        ],
+        round4: [
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "totalSupplyUnderlying", call: "totalSupply", target: "underlying" },
+        ],
+    };
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        let tvl = 0;
+        if (priceToken0 !== 0 && priceToken1 !== 0) {
+            tvl =
+                priceToken0 * BN2Number(typeInfo.balanceToken0, Number(typeInfo.decimalsToken0)) +
+                    priceToken1 * BN2Number(typeInfo.balanceToken1, Number(typeInfo.decimalsToken1));
+        }
+        const pricePerShare = BN2Number(typeInfo.pricePerShare);
+        const priceTargetToken = (pricePerShare * tvl) / BN2Number(typeInfo.totalSupplyUnderlying);
+        return {
+            ...typeInfo,
+            priceTargetToken,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+            pricePerShare,
+            tvl,
+        };
+    }
+}

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

@@ -0,0 +1,45 @@
+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 "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawBunniV2;
+    call: string;
+    target: keyof callKeysBunniV2;
+    metaData?: keyof callKeysBunniV2;
+};
+type callKeysBunniV2 = mandatoryCallKeys & {
+    decimalsToken0: string;
+    decimalsToken1: string;
+    hub: string;
+    poolId: string;
+    poolKey: string;
+    poolState: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    token0: string;
+    token1: string;
+    totalSupply: string;
+};
+type dataRawBunniV2 = callKeysBunniV2 & {
+    poolId: string;
+    poolKey: UniswapV4PoolKey;
+    poolState: PoolStateStructOutput;
+};
+type dataTypeBunniV2 = dataType & {
+    poolId: string;
+    balance0: string;
+    balance1: string;
+};
+export declare class BunniV2Processor extends GenericProcessor<callKeysBunniV2, dataRawBunniV2, dataTypeBunniV2> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawBunniV2): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBunniV2, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBunniV2>;
+}
+export {};

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

@@ -0,0 +1,87 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number, computeUniswapV4PoolId } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class BunniV2Processor extends GenericProcessor {
+    rounds = {
+        round1: [
+            {
+                key: "hub",
+                call: "hub",
+                target: "tokenAddress",
+            },
+            {
+                key: "poolKey",
+                call: "poolKey",
+                target: "tokenAddress",
+            },
+            {
+                key: "token0",
+                call: "token0",
+                target: "tokenAddress",
+            },
+            {
+                key: "token1",
+                call: "token1",
+                target: "tokenAddress",
+            },
+        ],
+        round2: [
+            {
+                key: "poolState",
+                call: "poolState",
+                target: "hub",
+                metaData: "poolId",
+            },
+        ],
+        round3: [
+            {
+                key: "decimalsToken0",
+                call: "decimals",
+                target: "token0",
+            },
+            {
+                key: "symbolToken0",
+                call: "symbol",
+                target: "token0",
+            },
+            {
+                key: "decimalsToken1",
+                call: "decimals",
+                target: "token1",
+            },
+            {
+                key: "symbolToken1",
+                call: "symbol",
+                target: "token1",
+            },
+        ],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    processingRound2(typeInfo) {
+        typeInfo.poolId = computeUniswapV4PoolId(typeInfo.poolKey);
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const decimalsToken0 = Number(typeInfo.decimalsToken0);
+        const decimalsToken1 = Number(typeInfo.decimalsToken1);
+        const amount0 = BN2Number(typeInfo.poolState.rawBalance0, decimalsToken0) +
+            BN2Number(typeInfo.poolState.reserve0, decimalsToken0);
+        const amount1 = BN2Number(typeInfo.poolState.rawBalance1, decimalsToken0) +
+            BN2Number(typeInfo.poolState.reserve1, decimalsToken1);
+        const token0PRice = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const token1Price = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        const tvl = token0PRice * amount0 + token1Price * amount1;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            balance0: amount0.toString(),
+            balance1: amount1.toString(),
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+            priceTargetToken: priceTargetToken,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+        };
+    }
+}

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

@@ -0,0 +1,44 @@
+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 "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawCompound;
+    call: string;
+    target: keyof callKeysCompound;
+    metaData?: keyof callKeysCompound;
+};
+type callKeysCompound = mandatoryCallKeys & {
+    tokenAddress: string;
+    totalBorrow: string;
+    balanceBaseToken: string;
+    symbolBaseToken: string;
+    decimalsBaseToken: string;
+    baseToken: string;
+    totalSupply: string;
+    blacklistedSupply: string;
+};
+type dataRawCompound = callKeysCompound & {};
+type dataTypeCompound = dataType & {
+    tokenAddress: string;
+    totalBorrow: number;
+    balanceBaseToken: number;
+    symbolBaseToken: string;
+    decimalsBaseToken: string;
+    baseToken: string;
+    totalSupply: number;
+    tvl: number;
+    priceTargetToken: number;
+    cardName: string;
+    blacklistedSupply: number;
+};
+export declare class CompoundProcessor extends GenericProcessor<callKeysCompound, dataRawCompound, dataTypeCompound> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawCompound, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCompound>;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class CompoundProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "baseToken", call: "baseToken", target: "tokenAddress" }],
+        round2: [
+            { key: "totalBorrow", call: "totalAssets", target: "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));
+        const balanceBaseToken = BN2Number(typeInfo.balanceBaseToken, Number(typeInfo.decimalsBaseToken));
+        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolBaseToken })) ?? 0;
+        const tvl = baseTokenPrice * (totalBorrow + balanceBaseToken);
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl: tvl,
+            whitelistedSupplyTargetToken,
+            totalBorrow,
+            blacklistedSupply,
+            balanceBaseToken,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,34 @@
+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 "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawERC4626;
+    call: string;
+    target: keyof callKeysERC4626;
+    metaData?: any;
+};
+type callKeysERC4626 = mandatoryCallKeys & {
+    asset: string;
+    decimalsAsset: string;
+    name: string;
+    symbolAsset: string;
+    totalAssets: string;
+};
+type dataRawERC4626 = callKeysERC4626 & {};
+type dataTypeERC4626 = dataType & {
+    asset: string;
+    decimalsAsset: string;
+    symbolAsset: string;
+    totalAssets: string;
+};
+export declare class ERC4626Processor extends GenericProcessor<callKeysERC4626, dataRawERC4626, dataTypeERC4626> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawERC4626, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeERC4626>;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class ERC4626Processor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "asset", call: "asset", target: "tokenAddress" }],
+        round2: [
+            { key: "decimalsAsset", call: "decimals", target: "asset" },
+            { key: "symbolAsset", call: "symbol", target: "asset" },
+        ],
+        round3: [],
+        round4: [
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "totalAssets", call: "totalAssets", target: "tokenAddress" },
+        ],
+    };
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceAsset = (await pricer.get({
+            symbol: typeInfo.symbolAsset,
+        })) ?? 0;
+        const decimalsAsset = Number.parseInt(typeInfo.decimalsAsset);
+        const amountAsset = BN2Number(typeInfo.totalAssets, decimalsAsset);
+        const tvl = priceAsset * amountAsset;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawEnzyme;
+    call: string;
+    target: keyof callKeysEnzyme;
+    metaData?: keyof callKeysEnzyme;
+};
+type callKeysEnzyme = mandatoryCallKeys & {
+    factory: string;
+    underlying: string;
+    exchangeRate: string;
+    symbolUnderlyingToken: string;
+    fundValueCalculator: string;
+    dispatcher: string;
+};
+type dataRawEnzyme = callKeysEnzyme & {
+    exchangeRateRaw: Array<string>;
+};
+type dataTypeEnzyme = dataType & {
+    factory: string;
+    underlying: string;
+    exchangeRate: number;
+    symbolUnderlyingToken: string;
+    fundValueCalculator: string;
+};
+export declare class EnzymeProcessor extends GenericProcessor<callKeysEnzyme, dataRawEnzyme, dataTypeEnzyme> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawEnzyme, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEnzyme>;
+    processingRound2(typeInfo: dataRawEnzyme): void;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawEnzyme, calls: string[]): tokenTypeStruct;
+}
+export {};

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

@@ -0,0 +1,51 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class EnzymeProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "exchangeRateRaw", call: "calcNetShareValue", target: "fundValueCalculator", metaData: "tokenAddress" },
+        ],
+        round2: [{ key: "symbolUnderlyingToken", call: "symbol", target: "underlying" }],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    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;
+        const exchangeRate = BN2Number(typeInfo.exchangeRate, 18);
+        const priceTargetToken = priceUnderlying * exchangeRate;
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            totalSupply,
+            exchangeRate,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    processingRound2(typeInfo) {
+        typeInfo.underlying = typeInfo.exchangeRateRaw[0];
+        typeInfo.exchangeRate = typeInfo.exchangeRateRaw[1];
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        // This is to enforce type checking
+        try {
+            return super.computeRound3(index, type, typeInfo, calls);
+        }
+        catch (e) {
+            // usually if this fails its because of native ETH
+            return {
+                type: type,
+                calls: [],
+                typeInfo: {
+                    ...typeInfo,
+                    symbolUnderlyingToken: "ETH",
+                },
+            };
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { Pricer } from "@/utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawEqualizerGauge;
+    call: string;
+    target: keyof callKeysEqualizerGauge;
+    metaData?: any;
+};
+type callKeysEqualizerGauge = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+};
+type dataRawEqualizerGauge = callKeysEqualizerGauge & {};
+type dataTypeEqualizerGauge = dataType & {
+    tokenPrice: string;
+};
+export declare class EqualizerGaugeProcessor extends GenericProcessor<callKeysEqualizerGauge, dataRawEqualizerGauge, dataTypeEqualizerGauge> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawEqualizerGauge, _calls: string[], campaign: CampaignParameters<Campaign.ERC20>, _pricer: Pricer): Promise<dataTypeEqualizerGauge>;
+}
+export {};