@merkl/api 0.10.128 → 0.10.130

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/EulerLendProcessor.js

@@ -0,0 +1,47 @@
+import { decodeCall } from "../../../../../utils/decodeCalls";
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { fetchEulerVaultName } from "../helpers/eulerVaultNames";
+import { GenericProcessor } from "./GenericProcessor";
+export class EulerLendProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
+        round3: [
+            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlying" },
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying" },
+        ],
+        round4: [
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "totalAssets", call: "totalAssets", 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 })) ?? 1;
+        let totalAssetsOrBorrows = 0;
+        let cardName = "";
+        const decimalsUnderlyingToken = Number(typeInfo.decimalsUnderlyingToken);
+        totalAssetsOrBorrows = BN2Number(
+        // eulerInterface.decodeFunctionResult("totalAssets", calls[index++])[0],
+        decodeCall(calls, index++, "totalAssets", type), decimalsUnderlyingToken);
+        cardName = generateCardName(type, typeInfo, campaign);
+        const vaultName = await fetchEulerVaultName(typeInfo.tokenAddress, campaign.chainId);
+        if (!!vaultName) {
+            cardName = `Supply ${typeInfo.symbolUnderlyingToken} on ${vaultName} vault`;
+        }
+        const tvl = priceUnderlying * totalAssetsOrBorrows;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            blacklistedSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            priceTargetToken,
+            cardName: cardName,
+            totalAssets: typeInfo.totalAssets,
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/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/libs/campaigns/campaignTypes/ERC20SubTypes/processor/FraxProcessor.js

@@ -0,0 +1,41 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor } from "./GenericProcessor";
+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/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GearboxProcessor.js

@@ -0,0 +1,44 @@
+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" }],
+        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" }],
+    };
+    // 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 balanceStakingToken = BN2Number(typeInfo.balanceStakingToken, Number(typeInfo.decimalsStakingToken));
+        const totalSupplyStakingToken = BN2Number(typeInfo.totalSupplyStakingToken, Number(typeInfo.decimalsStakingToken));
+        const percentageOfSupplyUnderlyingPoolTokens = balanceStakingToken / totalSupplyStakingToken;
+        const underlyingTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const tvl = underlyingTokenPrice * Number(totalAssets) * percentageOfSupplyUnderlyingPoolTokens;
+        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/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GenericProcessor.js

@@ -0,0 +1,239 @@
+import { decodeCall } from "../../../../../utils/decodeCalls";
+import { createCall } from "../../../../../utils/encodeCalls";
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { tokenTypeToProtocol } from "../helpers/tokenType";
+export var roundType;
+(function (roundType) {
+    roundType["one"] = "round1";
+    roundType["two"] = "round2";
+    roundType["three"] = "round3";
+    roundType["four"] = "round4";
+})(roundType || (roundType = {}));
+export class GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    debug = false;
+    processingRound1(typeInfo) { }
+    processingRound2(typeInfo) { }
+    processingRound3(typeInfo) { }
+    processingRound4(typeInfo) { }
+    handleWhiteListBlacklistRound5(typeInfo, campaign) {
+        const totalSupply = BN2Number(typeInfo.totalSupply, campaign.campaignParameters.decimalsTargetToken);
+        const whitelistedSupply = Number(typeInfo.whitelistedSupply);
+        const blacklistedSupply = Number(typeInfo.blacklistedSupply);
+        let whitelistedSupplyTargetToken = whitelistedSupply ? whitelistedSupply : totalSupply - blacklistedSupply;
+        whitelistedSupplyTargetToken = whitelistedSupplyTargetToken ? whitelistedSupplyTargetToken : 0.00001;
+        return {
+            whitelistedSupplyTargetToken,
+            totalSupply,
+            blacklistedSupply,
+        };
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceTargetToken = (await pricer.get({ symbol: campaign.campaignParameters.symbolTargetToken })) ?? 0;
+        const tvl = whitelistedSupplyTargetToken * priceTargetToken;
+        return {
+            whitelistedSupplyTargetToken,
+            totalSupply,
+            priceTargetToken,
+            tvl,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    computeRound1(type, typeInfo) {
+        typeInfo = { ...tokenTypeToProtocol[type], ...typeInfo };
+        this.processingRound1(typeInfo);
+        if (this.debug) {
+            console.log("Round 1", {
+                type: type,
+                calls: this.encodeNextRound(roundType.one, type, typeInfo),
+                typeInfo,
+            });
+        }
+        return {
+            type: type,
+            calls: this.encodeNextRound(roundType.one, type, typeInfo),
+            typeInfo,
+        };
+    }
+    computeRound2(index, type, typeInfo, calls) {
+        this.decodePreviousRound(roundType.one, calls, typeInfo, type, index);
+        this.processingRound2(typeInfo);
+        if (this.debug) {
+            console.log("Round 2", {
+                type: type,
+                calls: this.encodeNextRound(roundType.two, type, typeInfo),
+                typeInfo,
+            });
+        }
+        return {
+            type: type,
+            calls: this.encodeNextRound(roundType.two, type, typeInfo),
+            typeInfo,
+        };
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        this.decodePreviousRound(roundType.two, calls, typeInfo, type, index);
+        this.processingRound3(typeInfo);
+        if (this.debug) {
+            console.log("Round 3", {
+                type: type,
+                calls: this.encodeNextRound(roundType.three, type, typeInfo),
+                typeInfo,
+            });
+        }
+        return {
+            type: type,
+            calls: this.encodeNextRound(roundType.three, type, typeInfo),
+            typeInfo,
+        };
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
+        const whitelistedLiquidityCalls = this.generateWhitelistCall(type, typeInfo, campaign);
+        this.decodePreviousRound(roundType.three, calls, typeInfo, type, index);
+        this.processingRound4(typeInfo);
+        if (this.debug) {
+            console.log("Round 4", {
+                type: type,
+                calls: this.encodeNextRound(roundType.four, type, typeInfo),
+                typeInfo,
+            });
+        }
+        return {
+            type: type,
+            calls: whitelistedLiquidityCalls
+                .concat(blacklistedLiquidityCalls)
+                .concat(this.encodeNextRound(roundType.four, type, typeInfo)),
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
+        typeInfo.whitelistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.whitelist, calls);
+        index = index + campaign.campaignParameters.whitelist.length;
+        typeInfo.blacklistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
+        index = index + campaign.campaignParameters.blacklist.length;
+        this.decodePreviousRound(roundType.four, calls, typeInfo, type, index);
+        const outputInfo = (await this.processingRound5(index, type, typeInfo, calls, campaign, pricer));
+        if (this.debug) {
+            console.log("Round 5", {
+                type: type,
+                calls: [],
+                outputInfo,
+            });
+        }
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...outputInfo,
+            },
+        };
+    }
+    generateWhitelistCall(type, typeInfo, campaign) {
+        const whitelistedLiquidityCalls = [];
+        if (campaign.campaignParameters.whitelist.length > 0) {
+            for (const whitelistedAddress of campaign.campaignParameters.whitelist) {
+                if (!campaign.campaignParameters.blacklist.includes(whitelistedAddress)) {
+                    whitelistedLiquidityCalls.push(createCall(typeInfo.tokenAddress, "balanceOf", type, whitelistedAddress));
+                }
+            }
+        }
+        return whitelistedLiquidityCalls;
+    }
+    generateBlackListCall(type, typeInfo, campaign) {
+        const blacklistedLiquidityCalls = [];
+        if (campaign.campaignParameters.blacklist.length > 0) {
+            for (const blacklistedAddress of campaign.campaignParameters.blacklist) {
+                blacklistedLiquidityCalls.push(createCall(typeInfo.tokenAddress, "balanceOf", type, blacklistedAddress));
+            }
+        }
+        return blacklistedLiquidityCalls;
+    }
+    decodeListedSupply(index, decimals, list, calls) {
+        if (list.length === 0) {
+            return "0";
+        }
+        let listedSupply = 0;
+        for (const _ of list) {
+            listedSupply += BN2Number(decodeCall(calls, index++, "balanceOf"), decimals);
+        }
+        return listedSupply.toString();
+    }
+    decodeRound(round, index, calls, type, data) {
+        round.map(({ key, call, optional }) => {
+            if (optional) {
+                try {
+                    const value = decodeCall(calls, index, call, type);
+                    index++;
+                    data[key] = value;
+                }
+                catch (error) { }
+            }
+            else {
+                const value = decodeCall(calls, index, call, type);
+                index++;
+                data[key] = value;
+            }
+        });
+    }
+    decodePreviousRound(round, calls, data, type, index) {
+        if (round === roundType.one) {
+            this.decodeRound(this.rounds.round1, index, calls, type, data);
+        }
+        if (round === roundType.two) {
+            this.decodeRound(this.rounds.round2, index, calls, type, data);
+        }
+        if (round === roundType.three) {
+            this.decodeRound(this.rounds.round3, index, calls, type, data);
+        }
+        if (round === roundType.four) {
+            this.decodeRound(this.rounds.round4, index, calls, type, data);
+        }
+    }
+    encodeRound(round, callInfo, type) {
+        return round
+            .map(({ call, target, metaData, optional }) => {
+            if (optional && !callInfo[target]) {
+                return [];
+            }
+            if (metaData) {
+                return createCall(callInfo[target], call, type, callInfo[metaData]);
+            }
+            return createCall(callInfo[target], call, type);
+        })
+            .filter(call => Array.isArray(call) === false);
+    }
+    encodeNextRound(round, type, data) {
+        const keys = Object.keys(data);
+        const callInfo = keys.reduce((acc, key) => {
+            if (data[key]) {
+                acc[key] = data[key];
+            }
+            return acc;
+        }, {});
+        let calls = [];
+        if (round === roundType.one) {
+            calls = this.encodeRound(this.rounds.round1, callInfo, type);
+        }
+        if (round === roundType.two) {
+            calls = this.encodeRound(this.rounds.round2, callInfo, type);
+        }
+        if (round === roundType.three) {
+            calls = this.encodeRound(this.rounds.round3, callInfo, type);
+        }
+        if (round === roundType.four) {
+            calls = this.encodeRound(this.rounds.round4, callInfo, type);
+        }
+        return calls;
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/MetamorphoProcessor.js

@@ -0,0 +1,43 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { fetchMetamorphoTvl } from "../helpers/metamorphoTvl";
+import { GenericProcessor } from "./GenericProcessor";
+export class MetamorphoProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
+        round2: [{ key: "symbolUnderlyingToken", call: "symbol", 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 tvl = await fetchMetamorphoTvl(campaign.chainId, typeInfo.tokenAddress);
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    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/libs/campaigns/campaignTypes/ERC20SubTypes/processor/PendleProcessor.js

@@ -0,0 +1,31 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { ChainId } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class PendleProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "SYToken", call: "readTokens0", target: "tokenAddress" },
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+        ],
+        round2: [{ key: "underlying", call: "underlying", target: "SYToken" }],
+        round3: [{ key: "symbolUnderlyingToken", call: "symbol", target: "underlying" }],
+        round4: [],
+    };
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceTargetToken = (await pricer.get({
+            address: typeInfo.tokenAddress,
+            chainId: ChainId.MAINNET,
+        })) ?? 0;
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            priceTargetToken: priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+            blacklistedSupply,
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/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/libs/campaigns/campaignTypes/ERC20SubTypes/processor/RfxProcessor.js

@@ -0,0 +1,64 @@
+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 {
+            tokenAddress: typeInfo.tokenAddress,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+            priceTargetToken: priceTargetToken, // Add the appropriate value here
+            tvl,
+        };
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SpliceProcessor.js

@@ -0,0 +1,35 @@
+import { fetchSpliceInformation } from "../helpers/spliceTVL";
+import { GenericProcessor } from "./GenericProcessor";
+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 {
+            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",
+                },
+            };
+        }
+    }
+}