@merkl/api 0.9.15

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

@@ -0,0 +1,53 @@
+import { generateCardName } from "@/utils/generateCardName";
+import axios from "axios";
+import { GenericProcessor } from "../GenericProcessor";
+const findObjectByFarm = (dict, farmAddress) => {
+    for (const key in dict) {
+        if (dict[key].config && dict[key].config.farm === farmAddress) {
+            return dict[key];
+        }
+    }
+    return null;
+};
+export class EqualizerGaugeProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        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 EXTERNAL_EQUALIZER_ENDPOINT = "https://eqapi-sonic-prod-ltanm.ondigitalocean.app/sonic/v4/gauges/";
+        const data = (await axios(EXTERNAL_EQUALIZER_ENDPOINT)).data.data;
+        let tvl = 0;
+        let displayName = "Stake into Equalizer Gauge";
+        try {
+            if (!!data[typeInfo.tokenAddress]) {
+                tvl = data[typeInfo.tokenAddress].token0.reserveUsd + data[typeInfo.tokenAddress].token1.reserveUsd;
+                displayName = `Stake into ${data[typeInfo.tokenAddress].pair.displayName} Equalizer Gauge`;
+            }
+            else {
+                const EXTERNAL_EQUALIZER_CL_ENDPOINT = "https://eqapi-sonic-prod-ltanm.ondigitalocean.app/sonic/v4/clsets";
+                const data = (await axios(EXTERNAL_EQUALIZER_CL_ENDPOINT)).data.data;
+                const pool = findObjectByFarm(data, typeInfo.tokenAddress);
+                if (!!pool) {
+                    tvl = pool.integration.equalizerPair.tvlUsd;
+                    displayName = `Stake into ${pool.name} Equalizer Gauge`;
+                }
+            }
+        }
+        catch (e) { }
+        const priceTargetToken = tvl / totalSupply;
+        //const displayName = `Stake into ${data[typeInfo.tokenAddress].pair.displayName} Equalizer Gauge`;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign, [], displayName),
+        };
+    }
+}

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

@@ -0,0 +1,36 @@
+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 dataRawEuler;
+    call: string;
+    target: keyof callKeysEuler;
+    metaData?: keyof callKeysEuler;
+};
+type callKeysEuler = mandatoryCallKeys & {
+    addressVault: string;
+    totalAssets: string;
+};
+type dataRawEuler = callKeysEuler & {
+    symbolUnderlyingToken: string;
+};
+type dataTypeEuler = dataType & {
+    addressVault: string;
+    asset: string;
+    symbolAsset: string;
+    decimalsAsset: number;
+    totalSupply: number;
+    totalBorrows: string;
+};
+export declare class EulerBorrowProcessor extends GenericProcessor<callKeysEuler, dataRawEuler, dataTypeEuler> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawEuler, campaign: CampaignParameters<Campaign.EULER>): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawEuler, _calls: string[], campaign: CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
+}
+export {};

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

@@ -0,0 +1,51 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number, EulerSubCampaignType } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+import { fetchEulerVaultName } from "../helpers/eulerVaultNames";
+export class EulerBorrowProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        round3: [],
+        round4: [
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "totalAssets", call: "totalAssets", target: "addressVault" },
+        ],
+    };
+    processingRound2(typeInfo, campaign) {
+        typeInfo.addressVault = campaign.campaignParameters.evkAddress;
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const symbolAsset = campaign.campaignParameters.symbolAsset;
+        const decimalsAsset = Number(campaign.campaignParameters.decimalsAsset);
+        const priceAsset = (await pricer.get({ symbol: symbolAsset })) ?? 1;
+        const totalBorrows = BN2Number(typeInfo.totalAssets, decimalsAsset);
+        typeInfo.symbolUnderlyingToken = symbolAsset;
+        let cardName = generateCardName(type, typeInfo, campaign);
+        const vaultName = await fetchEulerVaultName(campaign.campaignParameters.evkAddress, campaign.chainId);
+        if (!!vaultName) {
+            cardName = `Borrow from ${vaultName} vault`;
+        }
+        if (campaign.campaignSubType === EulerSubCampaignType.BORROW_FROM_COLLATERAL) {
+            cardName = `${cardName} using ${campaign.campaignParameters.symbolCollateral}`;
+            // TODO
+        }
+        const tvl = priceAsset * totalBorrows;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            asset: campaign.campaignParameters.addressAsset,
+            addressVault: typeInfo.addressVault,
+            blacklistedSupply,
+            cardName: cardName,
+            decimalsAsset,
+            priceTargetToken,
+            symbolAsset,
+            totalBorrows: typeInfo.totalAssets.toString(),
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+        };
+    }
+}

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

@@ -0,0 +1,36 @@
+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 dataRawEuler;
+    call: string;
+    target: keyof callKeysEuler;
+    metaData?: keyof callKeysEuler;
+};
+type callKeysEuler = mandatoryCallKeys & {
+    addressVault: string;
+    totalAssets: string;
+};
+type dataRawEuler = callKeysEuler & {
+    symbolUnderlyingToken: string;
+};
+type dataTypeEuler = dataType & {
+    addressVault: string;
+    asset: string;
+    symbolAsset: string;
+    decimalsAsset: number;
+    totalSupply: number;
+    totalAssets: string;
+};
+export declare class EulerLendProcessor extends GenericProcessor<callKeysEuler, dataRawEuler, dataTypeEuler> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawEuler, campaign: CampaignParameters<Campaign.EULER>): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawEuler, calls: string[], campaign: CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+import { fetchEulerVaultName } from "../helpers/eulerVaultNames";
+export class EulerLendProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        round3: [],
+        round4: [
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "totalAssets", call: "totalAssets", target: "tokenAddress" },
+        ],
+    };
+    processingRound2(typeInfo, campaign) {
+        typeInfo.addressVault = campaign.campaignParameters.evkAddress;
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const symbolAsset = campaign.campaignParameters.symbolAsset;
+        const decimalsAsset = Number(campaign.campaignParameters.decimalsAsset);
+        const priceAsset = (await pricer.get({ symbol: symbolAsset })) ?? 1;
+        const totalAssets = BN2Number(typeInfo.totalAssets, decimalsAsset);
+        typeInfo.symbolUnderlyingToken = symbolAsset;
+        let cardName = generateCardName(type, typeInfo, campaign);
+        const vaultName = await fetchEulerVaultName(typeInfo.tokenAddress, campaign.chainId);
+        if (!!vaultName) {
+            cardName = `Supply ${symbolAsset} on ${vaultName} vault`;
+        }
+        const tvl = priceAsset * totalAssets;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            asset: campaign.campaignParameters.addressAsset,
+            addressVault: typeInfo.addressVault,
+            blacklistedSupply,
+            cardName: cardName,
+            decimalsAsset,
+            priceTargetToken,
+            symbolAsset,
+            totalAssets: typeInfo.totalAssets.toString(),
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+        };
+    }
+}

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

@@ -0,0 +1,39 @@
+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 dataRawFluid;
+    call: string;
+    target: keyof callKeysFluid;
+    metaData?: keyof callKeysFluid;
+};
+type callKeysFluid = mandatoryCallKeys & {
+    underlying: string;
+    exchangeRate: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    amount: string;
+    toAssets: string;
+};
+type dataRawFluid = callKeysFluid & {};
+type dataTypeFluid = dataType & {
+    underlying: string;
+    exchangeRate: number;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    totalSupply: number;
+    amount: string;
+    toAssets: string;
+};
+export declare class FluidProcessor extends GenericProcessor<callKeysFluid, dataRawFluid, dataTypeFluid> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawFluid, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFluid>;
+    processingRound3(typeInfo: dataRawFluid): void;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { BigNumber } from "ethers";
+import { GenericProcessor } from "../GenericProcessor";
+export class FluidProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
+        round2: [
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
+            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlying" },
+        ],
+        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;
+        const exchangeRate = BN2Number(typeInfo.toAssets, Number(typeInfo.decimalsUnderlyingToken));
+        const priceTargetToken = priceUnderlying * exchangeRate;
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            tvl,
+            exchangeRate,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            totalSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    processingRound3(typeInfo) {
+        typeInfo.amount = BigNumber.from(10).pow(typeInfo.decimalsUnderlyingToken).toString();
+    }
+}

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

@@ -0,0 +1,33 @@
+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 dataRawFrax;
+    call: string;
+    target: keyof callKeysFrax;
+    metaData?: keyof callKeysFrax;
+};
+type callKeysFrax = mandatoryCallKeys & {
+    underlying: string;
+    sharePrice: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+type dataRawFrax = callKeysFrax & {};
+type dataTypeFrax = dataType & {
+    underlying: string;
+    sharePrice: number;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+export declare class FraxProcessor extends GenericProcessor<callKeysFrax, dataRawFrax, dataTypeFrax> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawFrax, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFrax>;
+}
+export {};

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

@@ -0,0 +1,41 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+export class FraxProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "underlying", call: "underlying", target: "tokenAddress" },
+            { key: "sharePrice", call: "pricePerShare", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
+            { key: "decimalsUnderlyingToken", call: "decimals", 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 sharePrice = BN2Number(typeInfo.sharePrice, 18);
+        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 1;
+        let priceTargetToken = 0;
+        let tvl = 0;
+        if (type === tokenType.silostaking) {
+            priceTargetToken = priceUnderlying;
+            tvl = priceTargetToken * BN2Number(totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        }
+        tvl = sharePrice * totalSupply * priceUnderlying;
+        priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            sharePrice,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,43 @@
+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 dataRawGamma;
+    call: string;
+    target: keyof callKeysGamma;
+    metaData?: keyof callKeysGamma;
+};
+type callKeysGamma = mandatoryCallKeys & {
+    token0: string;
+    token1: string;
+    CFMMPrice: string;
+    cfmm: string;
+};
+type dataRawGamma = callKeysGamma & {
+    tokensRaw: string[];
+    tokenBalances: string[];
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+};
+type dataTypeGamma = dataType & {};
+export declare class GammaProcessor extends GenericProcessor<callKeysGamma, dataRawGamma, dataTypeGamma> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    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;
+    computeRound5(index: number, type: tokenType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+}
+export {};

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

@@ -0,0 +1,63 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class GammaProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "tokensRaw", call: "tokensRaw", target: "tokenAddress" },
+            { key: "tokenBalances", call: "tokenBalances", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "decimalsToken0", call: "decimals", target: "token0" },
+            { key: "decimalsToken1", call: "decimals", target: "token1" },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    processingRound2(typeInfo) {
+        typeInfo.token0 = typeInfo.tokensRaw[0];
+        typeInfo.token1 = typeInfo.tokensRaw[1];
+        typeInfo.balanceToken0 = typeInfo.tokenBalances[0];
+        typeInfo.balanceToken1 = typeInfo.tokenBalances[1];
+    }
+    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 priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        const balanceToken0 = BN2Number(typeInfo.balanceToken0, decimalsToken0);
+        const balanceToken1 = BN2Number(typeInfo.balanceToken1, decimalsToken1);
+        let tvl = 0;
+        if (priceToken0 !== 0 && priceToken1 !== 0) {
+            tvl = priceToken0 * balanceToken0 + priceToken1 * balanceToken1;
+        }
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            priceTargetToken,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            tvl,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    computeRound1(type, typeInfo) {
+        return super.computeRound1(type, typeInfo);
+    }
+    computeRound2(index, type, typeInfo, calls) {
+        return super.computeRound2(index, type, typeInfo, calls);
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        return super.computeRound4(index, type, typeInfo, calls, campaign);
+    }
+    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
+        return super.computeRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/implementations/GearboxProcessor.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 dataRawGearbox;
+    call: string;
+    target: keyof callKeysGearbox;
+    metaData?: keyof callKeysGearbox;
+    optional?: boolean;
+};
+type callKeysGearbox = mandatoryCallKeys & {
+    stakingToken: string;
+    balanceStakingToken: string;
+    underlyingToken: string;
+    totalSupplyStakingToken: string;
+    decimalsStakingToken: string;
+    totalAssets: string;
+    decimalsUnderlyingToken: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawGearbox = callKeysGearbox & {
+    isTrade: boolean;
+};
+type dataTypeGearbox = dataType & {
+    stakingToken: string;
+    balanceStakingToken: number;
+    underlyingToken: string;
+    totalSupplyStakingToken: number;
+    decimalsStakingToken: string;
+    totalAssets: number;
+    percentageOfSupplyUnderlyingPoolTokens: number;
+};
+export declare class GearboxProcessor extends GenericProcessor<callKeysGearbox, dataRawGearbox, dataTypeGearbox> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawGearbox): Promise<void>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawGearbox, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGearbox>;
+}
+export {};

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

@@ -0,0 +1,57 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class GearboxProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "stakingToken", call: "stakingToken", target: "tokenAddress", optional: true }],
+        round2: [
+            { 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" },
+            { key: "totalAssets", call: "totalAssets", target: "stakingToken" },
+        ],
+        round3: [
+            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlyingToken" },
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlyingToken" },
+        ],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    async processingRound2(typeInfo) {
+        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));
+        const underlyingTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        let tvl = 0;
+        let balanceStakingToken = 0;
+        let totalSupplyStakingToken = 0;
+        let percentageOfSupplyUnderlyingPoolTokens = 0;
+        if (!typeInfo.isTrade) {
+            balanceStakingToken = BN2Number(typeInfo.balanceStakingToken, Number(typeInfo.decimalsStakingToken));
+            totalSupplyStakingToken = BN2Number(typeInfo.totalSupplyStakingToken, Number(typeInfo.decimalsStakingToken));
+            percentageOfSupplyUnderlyingPoolTokens = balanceStakingToken / totalSupplyStakingToken;
+            tvl = underlyingTokenPrice * Number(totalAssets) * percentageOfSupplyUnderlyingPoolTokens;
+        }
+        else {
+            tvl = Number(totalAssets) * underlyingTokenPrice;
+        }
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            balanceStakingToken,
+            totalSupplyStakingToken,
+            whitelistedSupplyTargetToken,
+            percentageOfSupplyUnderlyingPoolTokens,
+            totalSupply,
+            totalAssets,
+            blacklistedSupply,
+            tvl: tvl,
+            priceTargetToken: priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,43 @@
+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 dataRawHanjiN;
+    call: string;
+    target: keyof callKeysHanjiN;
+    metaData?: keyof callKeysHanjiN | string;
+    optional?: boolean;
+};
+type callKeysHanjiN = mandatoryCallKeys & {
+    owner: string;
+    [key: `token${number}`]: string;
+    [key: `symbolToken${number}`]: string;
+    [key: `decimalsToken${number}`]: string;
+    [key: `balanceToken${number}`]: string;
+    [key: `${number}`]: string;
+    name: string;
+    helper: string;
+    tvl: string;
+};
+type dataRawHanjiN = callKeysHanjiN & {
+    numberTokens: number;
+};
+type dataTypeHanjiN = dataType & {
+    numberTokens: number;
+    tvl: number;
+};
+export declare class HanjiVaultProcessor extends GenericProcessor<callKeysHanjiN, dataRawHanjiN, dataTypeHanjiN> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawHanjiN): void;
+    processingRound3(typeInfo: dataRawHanjiN): void;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawHanjiN, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawHanjiN, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawHanjiN, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeHanjiN>;
+}
+export {};