@merkl/api 0.9.15

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

@@ -0,0 +1,95 @@
+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 CurveNPoolProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "numberTokens", call: "N_COINS", 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[`${i}`] = i.toString();
+            this.rounds.round2 = this.rounds.round2.concat([
+                { key: `token${i}`, call: "coins", target: "tokenAddress", metaData: i.toString() },
+            ]);
+        }
+    }
+    processingRound3(typeInfo) {
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            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", 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", metaData: i.toString() },
+            ]);
+        }
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            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", metaData: i.toString() },
+            ]);
+        }
+        return super.computeRound4(index, type, typeInfo, calls, campaign);
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        let tvl = 0;
+        // Hardocded in case we don't find it
+        let hardcodedSymbol = "unknown";
+        if (typeInfo.name.includes("BTC"))
+            hardcodedSymbol = "BTC";
+        if (typeInfo.name.includes("ETH"))
+            hardcodedSymbol = "ETH";
+        if (typeInfo.name.includes("STABLE"))
+            hardcodedSymbol = "USDC";
+        for (let i = 0; i < typeInfo.numberTokens; i++) {
+            const symbol = typeInfo[`symbolToken${i}`];
+            let price = (await pricer.get({ symbol: symbol })) ?? 0;
+            if (price === 0) {
+                // For cross curve
+                const parsedSymbol = symbol.split("_")[0].slice(1);
+                price = (await pricer.get({ symbol: parsedSymbol })) ?? 0;
+                if (price === 0) {
+                    price = (await pricer.get({ symbol: hardcodedSymbol })) ?? 0;
+                }
+            }
+            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)) {
+                delete typeInfo[key];
+            }
+        }
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,49 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawCurve;
+    call: string;
+    target: keyof callKeysCurve;
+    metaData?: keyof callKeysCurve;
+    optional?: boolean;
+};
+type callKeysCurve = mandatoryCallKeys & {
+    lp_price: string;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+};
+type dataRawCurve = callKeysCurve & {
+    poolTokens: {
+        [key: string]: string;
+    };
+    numberTokens: number;
+};
+type dataTypeCurve = dataType & {
+    numberTokens: number;
+    lp_price: number;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+export declare class CurveProcessor extends GenericProcessor<callKeysCurve, dataRawCurve, dataTypeCurve> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawCurve, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCurve>;
+}
+export {};

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

@@ -0,0 +1,70 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+export class CurveProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "lp_price", call: "lp_price", target: "tokenAddress" },
+            { key: "token0", call: "coin0", target: "tokenAddress" },
+            { key: "token1", call: "coin1", target: "tokenAddress" },
+            { key: "token2", call: "coin2", target: "tokenAddress", optional: true },
+        ],
+        round2: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "symbolToken2", call: "symbol", target: "token2", optional: true },
+        ],
+        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);
+        let priceTargetToken = lp_price;
+        if (typeInfo.token2) {
+            typeInfo.poolTokens = {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+                [typeInfo.token2]: typeInfo.symbolToken2,
+            };
+            typeInfo.numberTokens = 3;
+        }
+        else {
+            typeInfo.poolTokens = {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+            };
+            typeInfo.numberTokens = 2;
+        }
+        if (type === tokenType.curve_2) {
+            const prices = [];
+            for (const symbol of Object.values(typeInfo.poolTokens)) {
+                const price = (await pricer.get({ symbol: symbol })) ?? 0;
+                prices.push(price);
+            }
+            let minPrice = Math.min(...prices);
+            if (!minPrice) {
+                minPrice = 1;
+            }
+            priceTargetToken = priceTargetToken * minPrice;
+        }
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            lp_price,
+            poolTokens: {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+                [typeInfo.token2]: typeInfo.symbolToken2,
+            },
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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/implementations/processorMapping.js

@@ -0,0 +1,142 @@
+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,
+    [tokenType.syncswap]: UniswapProcessor,
+    [tokenType.ra]: UniswapProcessor,
+    [tokenType.yei_borrowing]: AaveProcessor,
+    [tokenType.yei_lending]: AaveProcessor,
+    [tokenType.zerolend_borrowing]: AaveProcessor,
+    [tokenType.zerolend_lending]: AaveProcessor,
+    [tokenType.ironclad_lending]: AaveProcessor,
+    [tokenType.ironclad_borrowing]: AaveProcessor,
+    [tokenType.poolside]: UniswapProcessor,
+    [tokenType.gearbox]: GearboxProcessor,
+    [tokenType.compound]: CompoundProcessor,
+    [tokenType.radiant_borrow]: RadiantProcessor,
+    [tokenType.radiant_lend]: RadiantProcessor,
+    [tokenType.ionic]: AssetProcessor,
+    [tokenType.metamorpho]: MetamorphoProcessor,
+    [tokenType.aerodrome]: UniswapProcessor,
+    [tokenType.velodrome]: UniswapProcessor,
+    [tokenType.moonwell]: AssetProcessor,
+    [tokenType.aave_lending]: AaveProcessor,
+    [tokenType.aave_borrowing]: AaveProcessor,
+    [tokenType.fraxlend]: FraxProcessor,
+    [tokenType.curve]: CurveProcessor,
+    [tokenType.sturdy_aggregator]: FraxProcessor,
+    [tokenType.koi]: UniswapProcessor,
+    [tokenType.baseswap]: UniswapProcessor,
+    [tokenType.layerbank]: AssetProcessor,
+    [tokenType.zkswap]: UniswapProcessor,
+    [tokenType.akron]: UniswapProcessor,
+    [tokenType.aura]: AuraProcessor,
+    [tokenType.dragonswap]: UniswapProcessor,
+    [tokenType.sturdy_silo]: SturdySiloProcessor,
+    [tokenType.silostaking]: FraxProcessor,
+    [tokenType.fluid]: FluidProcessor,
+    [tokenType.filament]: FluidProcessor,
+    [tokenType.enzyme]: EnzymeProcessor,
+    [tokenType.curve_2]: CurveProcessor,
+    [tokenType.crosscurve]: CurveNPoolProcessor,
+    [tokenType.fenix]: UniswapProcessor,
+    [tokenType.euler_lend]: EulerLendProcessor,
+    [tokenType.euler_borrow]: EulerBorrowProcessor,
+    [tokenType.beefy]: BeefyProcessor,
+    [tokenType.unknown]: GenericProcessor,
+    [tokenType.toros]: TorosProcessor,
+    [tokenType.splice]: SpliceProcessor,
+    [tokenType.pendle]: PendleProcessor,
+    [tokenType.ironcladStaking]: GenericProcessor,
+    [tokenType.rfx]: RfxProcessor,
+    [tokenType.woofi]: WoofiProcessor,
+    [tokenType.maverickBoostedPosition]: MaverickBPProcessor,
+    [tokenType.zkSwapThreePool]: ZkSwapThreePoolProcessor,
+    [tokenType.maha]: StakedCurveProcessor,
+    [tokenType.tempest]: TempestVaultProcessor,
+    [tokenType.pendleYT]: PendleYTProcessor,
+    [tokenType.pancakeswap]: UniswapProcessor,
+    [tokenType.tempestStaking]: TempestVaultProcessor,
+    [tokenType.holdstation]: HoldStationProcessor,
+    [tokenType.noLinkVault]: NoLinkVaultProcessor,
+    [tokenType.cpmmGamma]: GammaProcessor,
+    [tokenType.venus]: AssetProcessor,
+    [tokenType.reactor_fusion]: AssetProcessor,
+    [tokenType.vicuna]: VicunaProcessor,
+    [tokenType.traderJoe]: UniswapProcessor,
+    [tokenType.curveNPool]: CurveNPoolProcessor,
+    [tokenType.avalon_lending]: AaveProcessor,
+    [tokenType.avalon_borrowing]: AaveProcessor,
+    [tokenType.satlayer]: SatlayerProcessor,
+    [tokenType.veda]: NoLinkVaultProcessor,
+    [tokenType.superlend_lending]: AaveProcessor,
+    [tokenType.superlend_borrowing]: AaveProcessor,
+    [tokenType.cian]: ERC4626Processor,
+    [tokenType.concrete]: ERC4626Processor,
+    [tokenType.lendle_borrowing]: AaveProcessor,
+    [tokenType.lendle_lending]: AaveProcessor,
+    [tokenType.takotako_lending]: AaveProcessor,
+    [tokenType.takotako_borrowing]: AaveProcessor,
+    [tokenType.equalizer_gauge]: EqualizerGaugeProcessor,
+    [tokenType.vicuna_borrowing]: AaveProcessor,
+    [tokenType.vicuna_lending]: AaveProcessor,
+    [tokenType.anglesLiquid]: AnglesLiquidProcessor,
+    [tokenType.spectra_lpt]: SpectraProcessor,
+    [tokenType.spectra_yt]: SpectraYTProcessor,
+    [tokenType.rfx_slv]: ERC4626Processor,
+    [tokenType.hourglass]: HourglassProcessor,
+    [tokenType.katana]: UniswapProcessor,
+    [tokenType.balancerV3]: BalancerV3PoolProcessor,
+    [tokenType.hanji_liquidity_vault_token]: HanjiVaultProcessor,
+    [tokenType.xU308]: xU308Processor,
+    [tokenType.bunniV2]: BunniV2Processor,
+    [tokenType.beraborrow_gauge]: BEXRewardGaugeProcessor,
+    [tokenType.beratrax_vault]: BEXRewardGaugeProcessor,
+};

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

@@ -0,0 +1,54 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawStakedCurve;
+    call: string;
+    target: keyof callKeysStakedCurve;
+    metaData?: keyof callKeysStakedCurve;
+    optional?: boolean;
+};
+type callKeysStakedCurve = mandatoryCallKeys & {
+    lp_price: string;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    underlying: string;
+    amount: string;
+};
+type dataRawStakedCurve = callKeysStakedCurve & {
+    poolTokens: {
+        [key: string]: string;
+    };
+    toAssets: string;
+    symbolUnderlyingToken: string;
+};
+type dataTypeStakedCurve = dataType & {
+    lp_price: number;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    underlying: string;
+    symbolToken2: string;
+    symbolUnderlyingToken: string;
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+export declare class StakedCurveProcessor extends GenericProcessor<callKeysStakedCurve, dataRawStakedCurve, dataTypeStakedCurve> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound3(typeInfo: dataRawStakedCurve): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawStakedCurve, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeStakedCurve>;
+}
+export {};

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

@@ -0,0 +1,77 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { BigNumber } from "ethers";
+import { GenericProcessor } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+export class StakedCurveProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
+        round2: [
+            { key: "lp_price", call: "lp_price", target: "underlying" },
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
+            { key: "token0", call: "coin0", target: "underlying" },
+            { key: "token1", call: "coin1", target: "underlying" },
+            { key: "token2", call: "coin2", target: "underlying", optional: true },
+        ],
+        round3: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "symbolToken2", call: "symbol", target: "token2", optional: true },
+        ],
+        round4: [
+            { 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();
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const lp_price = BN2Number(typeInfo.lp_price, 18);
+        let priceTargetToken = lp_price;
+        if (typeInfo.token2) {
+            typeInfo.poolTokens = {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+                [typeInfo.token2]: typeInfo.symbolToken2,
+            };
+        }
+        else {
+            typeInfo.poolTokens = {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+            };
+        }
+        if (type === tokenType.curve_2) {
+            const prices = [];
+            for (const symbol of Object.values(typeInfo.poolTokens)) {
+                const price = (await pricer.get({ symbol: symbol })) ?? 0;
+                prices.push(price);
+            }
+            let minPrice = Math.min(...prices);
+            if (!minPrice) {
+                minPrice = 1;
+            }
+            priceTargetToken = priceTargetToken * minPrice;
+        }
+        const exchangeRate = BN2Number(typeInfo.toAssets, 18);
+        const tvl = priceTargetToken * totalSupply * exchangeRate;
+        return {
+            ...typeInfo,
+            lp_price,
+            poolTokens: {
+                [typeInfo.token0]: typeInfo.symbolToken0,
+                [typeInfo.token1]: typeInfo.symbolToken1,
+                [typeInfo.token2]: typeInfo.symbolToken2,
+            },
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,37 @@
+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 dataRawxU308;
+    call: string;
+    target: keyof callKeysxU308;
+    metaData?: keyof callKeysxU308;
+};
+type callKeysxU308 = mandatoryCallKeys & {
+    pool: string;
+    _token0: string;
+    _token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+    totalAssets: string;
+};
+type dataRawxU308 = callKeysxU308 & {};
+type dataTypexU308 = dataType & {
+    pool: string;
+};
+export declare class xU308Processor extends GenericProcessor<callKeysxU308, dataRawxU308, dataTypexU308> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawxU308): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawxU308, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypexU308>;
+}
+export {};

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

@@ -0,0 +1,49 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class xU308Processor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [
+            { key: "_token0", call: "token0", target: "pool" },
+            { key: "_token1", call: "token1", target: "pool" },
+        ],
+        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: "pool" },
+            { key: "balanceToken1", call: "balanceOf", target: "_token1", metaData: "pool" },
+        ],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound2(typeInfo) {
+        typeInfo.pool = "0xB387D0A73619791420De4a1e5e710023Cb0f49c0";
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        let priceTargetToken = 0;
+        if (typeInfo._token0 !== typeInfo.tokenAddress) {
+            const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+            priceTargetToken =
+                (priceToken0 * BN2Number(typeInfo.balanceToken0, Number(typeInfo.decimalsToken0))) /
+                    BN2Number(typeInfo.balanceToken1, Number(typeInfo.decimalsToken1));
+        }
+        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        priceTargetToken =
+            (priceToken1 * BN2Number(typeInfo.balanceToken1, Number(typeInfo.decimalsToken1))) /
+                BN2Number(typeInfo.balanceToken0, Number(typeInfo.decimalsToken0));
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            totalSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+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;