@merkl/api 0.9.15

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

@@ -0,0 +1,32 @@
+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 dataRawRadiant;
+    call: string;
+    target: keyof callKeysRadiant;
+    metaData?: keyof callKeysRadiant;
+};
+type callKeysRadiant = mandatoryCallKeys & {
+    underlyingToken: string;
+    priceBN: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawRadiant = callKeysRadiant & {};
+type dataTypeRadiant = dataType & {
+    priceTargetToken: number;
+    underlyingToken: string;
+    symbolUnderlyingToken: string;
+};
+export declare class RadiantProcessor extends GenericProcessor<callKeysRadiant, dataRawRadiant, dataTypeRadiant> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawRadiant, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeRadiant>;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawRadiant, calls: string[]): tokenTypeStruct;
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class RadiantProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "underlyingToken", call: "underlying", target: "tokenAddress" },
+            { key: "priceBN", call: "getAssetPrice", target: "tokenAddress" },
+        ],
+        round2: [{ key: "symbolUnderlyingToken", call: "symbol", target: "underlyingToken" }],
+        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 priceTargetToken = BN2Number(typeInfo.priceBN, 8);
+        const tvl = priceTargetToken * totalSupply;
+        //  TO DO FIX THE CARD NAME
+        //  SEEMS I HAVE DROPPED THE BALL ON THIS ONE
+        let cardToken = typeInfo.symbolUnderlyingToken;
+        if (campaign.campaignParameters.symbolTargetToken.startsWith("r")) {
+            cardToken = campaign.campaignParameters.symbolTargetToken.substring(1);
+        }
+        let finalSymbol = typeInfo.symbolUnderlyingToken;
+        if (typeInfo.symbolUnderlyingToken.toLowerCase().includes("gm") && cardToken.toLowerCase().includes("gm")) {
+            // Remove gm from the card name
+            finalSymbol = cardToken.substring(2);
+        }
+        return {
+            ...typeInfo,
+            priceTargetToken,
+            whitelistedSupplyTargetToken,
+            totalSupply,
+            blacklistedSupply,
+            tvl,
+            cardName: generateCardName(type, typeInfo, campaign),
+            symbolUnderlyingToken: finalSymbol,
+        };
+    }
+    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/RfxProcessor.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 } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawTemplate;
+    call: string;
+    target: keyof callKeysRfx;
+    metaData?: keyof callKeysRfx;
+};
+type callKeysRfx = mandatoryCallKeys & {
+    shortToken: string;
+    longToken: string;
+    symbolShortToken: string;
+    symbolLongToken: string;
+    decimalsToken: string;
+    decimalsShortToken: string;
+    decimalsLongToken: string;
+    balanceShortToken: string;
+    balanceLongToken: string;
+    RFX_DATASTORE: string;
+    metaDataShort: string;
+    metaDataLong: string;
+};
+type dataRawTemplate = callKeysRfx & {};
+type dataTypeRfx = dataType & {
+    symbolShortToken: string;
+    symbolLongToken: string;
+};
+export declare class RfxProcessor extends GenericProcessor<callKeysRfx, dataRawTemplate, dataTypeRfx> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawTemplate): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeRfx>;
+}
+export {};

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

@@ -0,0 +1,67 @@
+import { RFX_DATASTORE } from "@/constants";
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { ethers } from "ethers";
+import { GenericProcessor } from "../GenericProcessor";
+export class RfxProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            {
+                key: "shortToken",
+                call: "shortToken",
+                target: "RFX_DATASTORE",
+                metaData: "metaDataShort",
+            },
+            {
+                key: "longToken",
+                call: "longToken",
+                target: "RFX_DATASTORE",
+                metaData: "metaDataLong",
+            },
+            { key: "decimalsToken", call: "decimals", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolShortToken", call: "symbol", target: "shortToken" },
+            { key: "symbolLongToken", call: "symbol", target: "longToken" },
+            { key: "decimalsShortToken", call: "decimals", target: "shortToken" },
+            { key: "decimalsLongToken", call: "decimals", target: "longToken" },
+            { key: "balanceShortToken", call: "balanceOf", target: "shortToken", metaData: "tokenAddress" },
+            { key: "balanceLongToken", call: "balanceOf", target: "longToken", metaData: "tokenAddress" },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound1(typeInfo) {
+        const hexShortToken = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["string"], ["SHORT_TOKEN"]));
+        const hexLongToken = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["string"], ["LONG_TOKEN"]));
+        typeInfo.RFX_DATASTORE = RFX_DATASTORE;
+        typeInfo.metaDataShort = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["address", "bytes32"], [typeInfo.tokenAddress, hexShortToken]));
+        typeInfo.metaDataLong = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["address", "bytes32"], [typeInfo.tokenAddress, hexLongToken]));
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        // return super.processingRound5(index, type, typeInfo, calls, campaign, pricer);
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceShortToken = (await pricer.get({ symbol: typeInfo.symbolShortToken })) ?? 0;
+        const priceLongToken = (await pricer.get({ symbol: typeInfo.symbolLongToken })) ?? 0;
+        let tvl = 0;
+        if (priceShortToken !== 0 && priceLongToken !== 0) {
+            tvl =
+                priceShortToken * BN2Number(typeInfo.balanceShortToken, Number(typeInfo.decimalsShortToken)) +
+                    priceLongToken * BN2Number(typeInfo.balanceLongToken, Number(typeInfo.decimalsLongToken));
+        }
+        const priceTargetToken = tvl / BN2Number(typeInfo.totalSupply, Number(typeInfo.decimalsToken));
+        return {
+            ...typeInfo,
+            tokenAddress: typeInfo.tokenAddress,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+            priceTargetToken: priceTargetToken, // Add the appropriate value here
+            tvl,
+            symbolShortToken: typeInfo.symbolShortToken,
+            symbolLongToken: typeInfo.symbolLongToken,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { GenericProcessor } from "../GenericProcessor";
+export class SatlayerProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "symbol", call: "symbol", target: "tokenAddress" }],
+        round2: [],
+        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);
+        typeInfo.symbolUnderlyingToken = typeInfo.symbol.replace("sat", "");
+        const priceUnderlying = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const tvl = priceUnderlying * totalSupply;
+        const priceTargetToken = priceUnderlying;
+        return {
+            ...typeInfo,
+            whitelistedSupplyTargetToken,
+            tvl: tvl,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+            blacklistedSupply,
+            totalSupply,
+        };
+    }
+}

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

@@ -0,0 +1,31 @@
+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 dataRawSpectra;
+    call: string;
+    target: keyof callKeysSpectra;
+    metaData?: any;
+};
+type callKeysSpectra = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+    minter: string;
+};
+type dataRawSpectra = callKeysSpectra & {
+    curvePool: string;
+};
+type dataTypeSpectra = dataType & {
+    tokenPrice: string;
+};
+export declare class SpectraProcessor extends GenericProcessor<callKeysSpectra, dataRawSpectra, dataTypeSpectra> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawSpectra, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSpectra>;
+}
+export {};

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

@@ -0,0 +1,41 @@
+import { NETWORK_SLUGS } from "@/constants";
+import { generateCardName } from "@/utils/generateCardName";
+import { GenericProcessor } from "../GenericProcessor";
+export class SpectraProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "curvePool", call: "minter", target: "tokenAddress" }],
+        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);
+        if (!NETWORK_SLUGS[campaign.computeChainId]) {
+            throw new Error("Network slug not found");
+        }
+        const curvePool = typeInfo.curvePool.toLowerCase();
+        const spectraData = (await (await fetch(`https://app.spectra.finance/api/v1/${NETWORK_SLUGS[campaign.computeChainId]}/pools`, {
+            headers: {
+                "x-client-id": "Merkl Studio",
+                source: "Merkl Studio",
+            },
+        })).json());
+        const poolData = spectraData
+            .find(d => d.pools.map(pool => pool.address.toLowerCase()).includes(curvePool))
+            ?.pools.find(pool => pool.address.toLowerCase() === curvePool);
+        if (!poolData) {
+            throw new Error("Pool not found in Spectra API");
+        }
+        const tvl = poolData.liquidity.usd; // in USD
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,31 @@
+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 dataRawSpectra;
+    call: string;
+    target: keyof callKeysSpectra;
+    metaData?: any;
+};
+type callKeysSpectra = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+    principalToken: string;
+};
+type dataRawSpectra = callKeysSpectra & {
+    principalToken: string;
+};
+type dataTypeSpectra = dataType & {
+    tokenPrice: string;
+};
+export declare class SpectraYTProcessor extends GenericProcessor<callKeysSpectra, dataRawSpectra, dataTypeSpectra> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawSpectra, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSpectra>;
+}
+export {};

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

@@ -0,0 +1,39 @@
+import { NETWORK_SLUGS } from "@/constants";
+import { generateCardName } from "@/utils/generateCardName";
+import { GenericProcessor } from "../GenericProcessor";
+export class SpectraYTProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "principalToken", call: "principalToken", target: "tokenAddress" }],
+        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);
+        if (!NETWORK_SLUGS[campaign.computeChainId]) {
+            throw new Error("Network slug not found");
+        }
+        const principalToken = typeInfo.principalToken.toLowerCase();
+        const spectraData = (await (await fetch(`https://app.spectra.finance/api/v1/${NETWORK_SLUGS[campaign.computeChainId]}/pools`, {
+            headers: {
+                "x-client-id": "Merkl Studio",
+                source: "Merkl Studio",
+            },
+        })).json());
+        const poolData = spectraData.find(d => d.address.toLowerCase() === principalToken);
+        if (!poolData) {
+            throw new Error("Pool not found in Spectra API");
+        }
+        const tvl = poolData.pools[0].ytPrice.usd * totalSupply; // in USD
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { Pricer } from "@/utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+type callKeysSplice = mandatoryCallKeys & {
+    priceTargetToken: string;
+};
+type dataRawSplice = callKeysSplice & {};
+type dataTypeSplice = dataType & {
+    priceTargetToken: number;
+};
+export declare class SpliceProcessor extends GenericProcessor<callKeysSplice, dataRawSplice, dataTypeSplice> {
+    processingRound5(_index: number, _type: tokenType, typeInfo: dataRawSplice, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSplice>;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawSplice, calls: string[]): tokenTypeStruct;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { GenericProcessor } from "../GenericProcessor";
+import { fetchSpliceInformation } from "../helpers/spliceTVL";
+export class SpliceProcessor extends GenericProcessor {
+    // override computeRound1(): void {}
+    async processingRound5(_index, _type, typeInfo, _calls, campaign, _pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const { symbolUnderlyingToken, priceTargetToken, tvl } = await fetchSpliceInformation(campaign.campaignParameters.targetToken);
+        return {
+            ...typeInfo,
+            totalSupply,
+            priceTargetToken,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            cardName: `Supply ${symbolUnderlyingToken} on Splice`,
+            tokenAddress: typeInfo.tokenAddress,
+        };
+    }
+    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/SturdySiloProcessor.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 dataRawSturdySilo;
+    call: string;
+    target: keyof callKeysSturdySilo;
+    metaData?: keyof callKeysSturdySilo;
+};
+type callKeysSturdySilo = mandatoryCallKeys & {
+    underlying: string;
+    sharePrice: string;
+    collateralContract: string;
+    collateral: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    symbolCollateral: string;
+};
+type dataRawSturdySilo = callKeysSturdySilo & {};
+type dataTypeSturdySilo = dataType & {
+    underlying: string;
+    sharePrice: number;
+    collateral: string;
+    collateralContract: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    symbolCollateral: string;
+};
+export declare class SturdySiloProcessor extends GenericProcessor<callKeysSturdySilo, dataRawSturdySilo, dataTypeSturdySilo> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawSturdySilo, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSturdySilo>;
+}
+export {};

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

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

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

@@ -0,0 +1,52 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import { tokenType, type tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawTempest;
+    call: string;
+    target: keyof callKeysTempest;
+    metaData?: keyof callKeysTempest;
+};
+type callKeysTempest = mandatoryCallKeys & {
+    addressToken0: string;
+    addressToken1: string;
+    addressesReturnData: string;
+};
+type dataRawTempest = callKeysTempest & {
+    addressToken0: string;
+    addressToken1: string;
+    addressesReturnData: {
+        [key: string]: string | number;
+    };
+    amount0Idle: string;
+    amount0Invested: string;
+    amount1Idle: string;
+    amount1Invested: string;
+    amountInQueue?: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    positionsReturnData: {
+        [key: string]: string | number;
+    };
+    symbolToken0: string;
+    symbolToken1: string;
+};
+type dataTypeTempest = dataType & {
+    addressToken0: string;
+    addressToken1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+};
+export declare class TempestVaultProcessor extends GenericProcessor<callKeysTempest, dataRawTempest, dataTypeTempest> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawTempest): void;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawTempest, calls: string[]): tokenTypeStruct;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawTempest, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeTempest>;
+}
+export {};