@merkl/api 0.10.128 → 0.10.130

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.js

@@ -0,0 +1,106 @@
+// This enum's order is important, do not change it unless you know what you are doing
+export var tokenType;
+(function (tokenType) {
+    tokenType["aura"] = "aura";
+    tokenType["poolside"] = "poolside";
+    tokenType["balancerGauge"] = "balancerGauge";
+    tokenType["gearbox"] = "gearbox";
+    tokenType["euler_borrow"] = "euler_borrow";
+    tokenType["euler_lend"] = "euler_lend";
+    tokenType["filament"] = "filament";
+    tokenType["fluid"] = "fluid";
+    tokenType["compound"] = "compound";
+    tokenType["radiant_lend"] = "radiant_lend";
+    tokenType["radiant_borrow"] = "radiant_borrow";
+    tokenType["ionic"] = "ionic";
+    tokenType["layerbank"] = "layerbank";
+    tokenType["moonwell"] = "moonwell";
+    tokenType["yei_borrowing"] = "yei_borrowing";
+    tokenType["ironclad_borrowing"] = "ironclad_borrowing";
+    tokenType["zerolend_borrowing"] = "zerolend_borrowing";
+    tokenType["yei_lending"] = "yei_lending";
+    tokenType["ironclad_lending"] = "ironclad_lending";
+    tokenType["zerolend_lending"] = "zerolend_lending";
+    tokenType["aave_borrowing"] = "aave_borrowing";
+    tokenType["aave_lending"] = "aave_lending";
+    tokenType["sturdy_aggregator"] = "sturdy_aggregator";
+    tokenType["sturdy_silo"] = "sturdy_silo";
+    tokenType["fraxlend"] = "fraxlend";
+    tokenType["uniswapv2"] = "uniswapv2";
+    tokenType["fenix"] = "fenix";
+    tokenType["ra"] = "ra";
+    tokenType["syncswap"] = "syncswap";
+    tokenType["curve_2"] = "curve_2";
+    tokenType["silostaking"] = "silostaking";
+    tokenType["beefy"] = "beefy";
+    tokenType["balancerPool"] = "balancerPool";
+    tokenType["unknown"] = "unknown";
+    tokenType["metamorpho"] = "metamorpho";
+    tokenType["aerodrome"] = "aerodrome";
+    tokenType["velodrome"] = "velodrome";
+    tokenType["curve"] = "curve";
+    tokenType["splice"] = "splice";
+    tokenType["toros"] = "toros";
+    tokenType["akron"] = "akron";
+    tokenType["enzyme"] = "enzyme";
+    tokenType["dragonswap"] = "dragonswap";
+    tokenType["koi"] = "koi";
+    tokenType["baseswap"] = "baseswap";
+    tokenType["zkswap"] = "zkswap";
+    tokenType["pendle"] = "pendle";
+    tokenType["ironcladStaking"] = "ironcladStaking";
+    tokenType["rfx"] = "rfx";
+    tokenType["woofi"] = "woofi";
+})(tokenType || (tokenType = {}));
+export const tokenTypeToProtocol = {
+    [tokenType.aave_borrowing]: { protocol: "Aave" },
+    [tokenType.aave_lending]: { protocol: "Aave" },
+    [tokenType.aerodrome]: { protocol: "Aerodrome V2" },
+    [tokenType.akron]: { protocol: "Akron V2" },
+    [tokenType.aura]: { protocol: "Aura" },
+    [tokenType.balancerGauge]: { protocol: "Balancer Gauge" },
+    [tokenType.balancerPool]: { protocol: "Balancer Pool" },
+    [tokenType.baseswap]: { protocol: "Baseswap V2" },
+    [tokenType.beefy]: { protocol: "Moo Velodrome V2" },
+    [tokenType.compound]: { protocol: "Compound" },
+    [tokenType.curve]: { protocol: "Curve" },
+    [tokenType.curve_2]: { protocol: "Curve" },
+    [tokenType.dragonswap]: { protocol: "Dragonswap V2" },
+    [tokenType.enzyme]: { protocol: "Enzyme" },
+    [tokenType.euler_borrow]: { protocol: "Euler V2" },
+    [tokenType.euler_lend]: { protocol: "Euler V2" },
+    [tokenType.fenix]: { protocol: "Fenix V2" },
+    [tokenType.filament]: { protocol: "Filament" },
+    [tokenType.fluid]: { protocol: "Fluid" },
+    [tokenType.fraxlend]: { protocol: "Fraxlend" },
+    [tokenType.gearbox]: { protocol: "Gearbox" },
+    [tokenType.ionic]: { protocol: "Ionic" },
+    [tokenType.ironclad_borrowing]: { protocol: "Ironclad" },
+    [tokenType.ironclad_lending]: { protocol: "Ironclad" },
+    [tokenType.koi]: { protocol: "Koi" },
+    [tokenType.layerbank]: { protocol: "Layerbank" },
+    [tokenType.metamorpho]: { protocol: "Metamorpho" },
+    [tokenType.moonwell]: { protocol: "Moonwell" },
+    [tokenType.pendle]: { protocol: "Pendle" },
+    [tokenType.poolside]: { protocol: "Poolside" },
+    [tokenType.ra]: { protocol: "Ra" },
+    [tokenType.radiant_borrow]: { protocol: "Radiant" },
+    [tokenType.radiant_lend]: { protocol: "Radiant" },
+    [tokenType.silostaking]: { protocol: "Silo Staking", symbolUnderlyingToken: "SEI" },
+    [tokenType.splice]: { protocol: "Splice" },
+    [tokenType.sturdy_aggregator]: { protocol: "Sturdy" },
+    [tokenType.sturdy_silo]: { protocol: "Sturdy" },
+    [tokenType.syncswap]: { protocol: "SyncSwap" },
+    [tokenType.toros]: { protocol: "Toros" },
+    [tokenType.uniswapv2]: { protocol: "Uniswap V2" },
+    [tokenType.velodrome]: { protocol: "Velodrome V2" },
+    [tokenType.unknown]: { protocol: "Unknown" },
+    [tokenType.yei_borrowing]: { protocol: "Yei Finance" },
+    [tokenType.yei_lending]: { protocol: "Yei Finance" },
+    [tokenType.zerolend_borrowing]: { protocol: "ZeroLend" },
+    [tokenType.zerolend_lending]: { protocol: "ZeroLend" },
+    [tokenType.zkswap]: { protocol: "ZKSwap" },
+    [tokenType.ironcladStaking]: { protocol: "Ironclad" },
+    [tokenType.rfx]: { protocol: "RFX" },
+    [tokenType.woofi]: { protocol: "Woofi" },
+};

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

@@ -0,0 +1,26 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { GenericProcessor } from "./GenericProcessor";
+export class AaveProcessor 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 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/libs/campaigns/campaignTypes/ERC20SubTypes/processor/AssetProcessor.js

@@ -0,0 +1,47 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor } from "./GenericProcessor";
+export class AssetProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "underlying", call: "underlying", target: "tokenAddress" },
+            { key: "exchangeRate", call: "exchangeRate", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "symbolUnderlyingToken", call: "symbol", target: "underlying", optional: true },
+            { key: "decimalsUnderlyingToken", call: "decimals", target: "underlying", optional: true },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    processingRound2(typeInfo) {
+        if (typeInfo.underlying === "0x0000000000000000000000000000000000000000") {
+            typeInfo.symbolUnderlyingToken = "ETH";
+            typeInfo.decimalsUnderlyingToken = "18";
+            this.rounds.round2 = [];
+        }
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        let exchangeRate = BN2Number(typeInfo.exchangeRate, 18);
+        if (type === tokenType.moonwell) {
+            exchangeRate =
+                exchangeRate /
+                    10 ** (Number(typeInfo.decimalsUnderlyingToken) - campaign.campaignParameters.decimalsTargetToken);
+        }
+        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const tvl = baseTokenPrice * whitelistedSupplyTargetToken * exchangeRate;
+        const priceTargetToken = baseTokenPrice * exchangeRate;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            priceTargetToken,
+            exchangeRate,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

@@ -0,0 +1,103 @@
+import { decodeCall } from "../../../../../utils/decodeCalls";
+import { createCall } from "../../../../../utils/encodeCalls";
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor, roundType } from "./GenericProcessor";
+export class AuraProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "balancerPool", call: "underlying", target: "tokenAddress" },
+            { key: "auraOperator", call: "operator", target: "tokenAddress" },
+            { key: "pid", call: "pid", target: "tokenAddress" },
+        ],
+        round2: [
+            { key: "poolId", call: "getPoolId", target: "balancerPool" },
+            { key: "vault", call: "getVault", target: "balancerPool" },
+            { key: "totalSupplyBalancerPool", call: "totalSupply", target: "balancerPool" },
+            { key: "gaugeContract", call: "poolInfo", target: "auraOperator", metaData: "pid" },
+            { key: "auraStaker", call: "staker", target: "auraOperator" },
+        ],
+        round3: [
+            { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
+            { key: "gaugeBalance", call: "balanceOf", target: "balancerPool", metaData: "gaugeContract" },
+            { key: "auraBalance", call: "balanceOf", target: "gaugeContract", metaData: "auraStaker" },
+            { key: "totalSupplyGauge", call: "totalSupply", target: "gaugeContract" },
+        ],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound4(typeInfo) {
+        const tokens = typeInfo.poolTokensRaw[0];
+        const balances = typeInfo.poolTokensRaw[1];
+        let i = 0;
+        const poolTokens = [];
+        for (const token of tokens) {
+            if (token !== typeInfo.tokenAddress) {
+                poolTokens.push({
+                    token: token,
+                    balance: balances[i].toString(),
+                });
+                i++;
+                typeInfo.poolTokens = poolTokens;
+            }
+        }
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const totalSupplyBalancerPool = BN2Number(typeInfo.totalSupplyBalancerPool, 18);
+        const gaugeBalance = BN2Number(typeInfo.gaugeBalance, 18);
+        const auraBalance = BN2Number(typeInfo.auraBalance, 18);
+        const totalSupplyGauge = BN2Number(typeInfo.totalSupplyGauge, 18);
+        const poolTokensinfo = {};
+        let poolTvl = 0;
+        const symbols = [];
+        let indexUpdated = index + this.rounds.round4.length;
+        for (const poolToken of typeInfo.poolTokens) {
+            const symbol = decodeCall(calls, indexUpdated++, "symbol");
+            const decimals = decodeCall(calls, indexUpdated++, "decimals");
+            poolTokensinfo[poolToken.token] = {
+                symbol: symbol,
+                decimals: decimals,
+                amountInPool: BN2Number(poolToken.balance, decimals),
+                price: (await pricer.get({ symbol: symbol })) ?? 0,
+            };
+            poolTvl += poolTokensinfo[poolToken.token].price * poolTokensinfo[poolToken.token].amountInPool;
+            symbols.push(symbol);
+        }
+        const percentageOfSupplyInAura = (auraBalance / totalSupplyGauge) * (gaugeBalance / totalSupplyBalancerPool);
+        const tvl = poolTvl * percentageOfSupplyInAura;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupplyBalancerPool,
+            gaugeBalance,
+            auraBalance,
+            totalSupplyGauge,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            poolTokens: poolTokensinfo,
+            tvl: tvl,
+            priceTargetToken: priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
+        };
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        // This is to enforce type checking
+        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
+        this.decodePreviousRound(roundType.three, calls, typeInfo, type, index);
+        this.processingRound4(typeInfo);
+        const poolCalls = this.encodeNextRound(roundType.four, type, typeInfo);
+        for (const poolToken of typeInfo.poolTokens) {
+            poolCalls.push(createCall(poolToken.token, "symbol"));
+            poolCalls.push(createCall(poolToken.token, "decimals"));
+        }
+        return {
+            type: type,
+            calls: blacklistedLiquidityCalls.concat(poolCalls),
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,83 @@
+import { decodeCall } from "../../../../../utils/decodeCalls";
+import { createCall } from "../../../../../utils/encodeCalls";
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor, roundType } from "./GenericProcessor";
+export class BalancerGaugeProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "gyroscopeToken", call: "lp_token", target: "tokenAddress" }],
+        round2: [
+            { key: "balanceUnderlyingPoolTokens", call: "balanceOf", target: "gyroscopeToken", metaData: "tokenAddress" },
+            { key: "totalSupplyUnderlyingPoolTokens", call: "totalSupply", target: "gyroscopeToken" },
+            { key: "poolId", call: "getPoolId", target: "gyroscopeToken" },
+            { key: "vault", call: "getVault", target: "gyroscopeToken" },
+        ],
+        round3: [{ key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" }],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound4(typeInfo) {
+        const tokens = typeInfo.poolTokensRaw[0];
+        const balances = typeInfo.poolTokensRaw[1];
+        let i = 0;
+        const poolTokens = [];
+        for (const token of tokens) {
+            poolTokens.push({
+                token: token,
+                balance: balances[i].toString(),
+            });
+            i++;
+            typeInfo.poolTokens = poolTokens;
+        }
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const poolTokensinfo = {};
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        let tvlUnderlyingPool = 0;
+        const symbols = [];
+        let indexUpdated = index + this.rounds.round4.length;
+        for (const poolToken of typeInfo.poolTokens) {
+            const symbol = decodeCall(calls, indexUpdated++, "symbol");
+            const decimals = decodeCall(calls, indexUpdated++, "decimals");
+            poolTokensinfo[poolToken.token] = {
+                symbol: symbol,
+                decimals: decimals,
+                amountInPool: BN2Number(poolToken.balance, decimals),
+                price: (await pricer.get({ symbol: symbol })) ?? 0,
+            };
+            tvlUnderlyingPool += poolTokensinfo[poolToken.token].price * poolTokensinfo[poolToken.token].amountInPool;
+            symbols.push(symbol);
+        }
+        const percentageOfSupplyUnderlyingPoolTokens = BN2Number(typeInfo.balanceUnderlyingPoolTokens, 18) / BN2Number(typeInfo.totalSupplyUnderlyingPoolTokens, 18);
+        const tvl = tvlUnderlyingPool * percentageOfSupplyUnderlyingPoolTokens;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply: totalSupply,
+            poolTokens: poolTokensinfo,
+            tvl: tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken: priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
+        };
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        // This is to enforce type checking
+        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
+        this.decodePreviousRound(roundType.three, calls, typeInfo, type, index);
+        this.processingRound4(typeInfo);
+        const poolCalls = [createCall(typeInfo.tokenAddress, "totalSupply")];
+        for (const poolToken of typeInfo.poolTokens) {
+            poolCalls.push(createCall(poolToken.token, "symbol"));
+            poolCalls.push(createCall(poolToken.token, "decimals"));
+        }
+        return {
+            type: type,
+            calls: blacklistedLiquidityCalls.concat(poolCalls),
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,99 @@
+import { decodeCall } from "../../../../../utils/decodeCalls";
+import { createCall } from "../../../../../utils/encodeCalls";
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { BigNumber } from "ethers";
+import { utils } from "ethers";
+import { GenericProcessor, roundType } from "./GenericProcessor";
+export class BalancerPoolProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [
+            { key: "poolId", call: "getPoolId", target: "tokenAddress" },
+            { key: "vault", call: "getVault", target: "tokenAddress" },
+        ],
+        round3: [{ key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" }],
+        round4: [
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+            { key: "vaultBalance", call: "balanceOf", target: "tokenAddress", metaData: "vault" },
+        ],
+    };
+    // override computeRound1(): void {}
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        let { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const totalSupplyBN = BigNumber.from(typeInfo.totalSupply);
+        const vaultBalanceBN = BigNumber.from(typeInfo.vaultBalance);
+        const totalSupplyUpdated = BN2Number(totalSupplyBN.sub(vaultBalanceBN), campaign.campaignParameters.decimalsTargetToken);
+        const vaultBalance = BN2Number(vaultBalanceBN, campaign.campaignParameters.decimalsTargetToken);
+        const poolTokensinfo = {};
+        let tvl = 0;
+        const symbols = [];
+        let indexUpdated = index + this.rounds.round4.length;
+        const vaultIndex = campaign.campaignParameters.blacklist
+            ?.map(b => utils.getAddress(b))
+            ?.indexOf(utils.getAddress(typeInfo.vault)); // Check if the vault is blacklisted
+        if (vaultIndex !== -1) {
+            blacklistedSupply -= BN2Number(decodeCall(calls, index + vaultIndex, "balanceOf"), campaign.campaignParameters.decimalsTargetToken); // The vault balance was already removed from the total supply
+        }
+        for (const poolToken of typeInfo.poolTokens) {
+            const symbol = decodeCall(calls, indexUpdated++, "symbol");
+            const decimals = decodeCall(calls, indexUpdated++, "decimals");
+            poolTokensinfo[poolToken.token] = {
+                symbol: symbol,
+                decimals: decimals,
+                amountInPool: BN2Number(poolToken.balance, decimals),
+                price: (await pricer.get({ symbol: symbol })) ?? 0,
+            };
+            tvl += poolTokensinfo[poolToken.token].price * poolTokensinfo[poolToken.token].amountInPool;
+            symbols.push(symbol);
+        }
+        const priceTargetToken = tvl / totalSupplyUpdated;
+        return {
+            tokenAddress: typeInfo.tokenAddress,
+            poolId: typeInfo.poolId,
+            vault: typeInfo.vault,
+            poolTokens: poolTokensinfo,
+            totalSupply: totalSupplyUpdated,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            tvl: tvl,
+            priceTargetToken: priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
+            vaultBalance: vaultBalance,
+        };
+    }
+    processingRound4(typeInfo) {
+        const tokens = typeInfo.poolTokensRaw[0];
+        const balances = typeInfo.poolTokensRaw[1];
+        let i = 0;
+        const poolTokens = [];
+        for (const token of tokens) {
+            if (token !== typeInfo.tokenAddress) {
+                poolTokens.push({
+                    token: token,
+                    balance: balances[i].toString(),
+                });
+            }
+            i++;
+            typeInfo.poolTokens = poolTokens;
+        }
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        // This is to enforce type checking
+        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
+        this.decodePreviousRound(roundType.three, calls, typeInfo, type, index);
+        this.processingRound4(typeInfo);
+        const poolCalls = this.encodeNextRound(roundType.four, type, typeInfo);
+        for (const poolToken of typeInfo.poolTokens) {
+            poolCalls.push(createCall(poolToken.token, "symbol"));
+            poolCalls.push(createCall(poolToken.token, "decimals"));
+        }
+        return {
+            type: type,
+            calls: blacklistedLiquidityCalls.concat(poolCalls),
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

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

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

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

@@ -0,0 +1,36 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "./GenericProcessor";
+export class CompoundProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "baseToken", call: "baseToken", target: "tokenAddress" }],
+        round2: [
+            { key: "totalBorrow", call: "totalAssets", target: "tokenAddress" },
+            { key: "balanceBaseToken", call: "balanceOf", target: "baseToken", metaData: "tokenAddress" },
+            { key: "symbolBaseToken", call: "symbol", target: "baseToken" },
+            { key: "decimalsBaseToken", call: "decimals", target: "baseToken" },
+        ],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const totalBorrow = BN2Number(typeInfo.totalBorrow, Number(typeInfo.decimalsBaseToken));
+        const balanceBaseToken = BN2Number(typeInfo.balanceBaseToken, Number(typeInfo.decimalsBaseToken));
+        const baseTokenPrice = (await pricer.get({ symbol: typeInfo.symbolBaseToken })) ?? 0;
+        const tvl = baseTokenPrice * (totalBorrow + balanceBaseToken);
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl: tvl,
+            whitelistedSupplyTargetToken,
+            totalBorrow,
+            blacklistedSupply,
+            balanceBaseToken,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

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

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

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

@@ -0,0 +1,46 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { fetchEulerVaultName } from "../helpers/eulerVaultNames";
+import { GenericProcessor } from "./GenericProcessor";
+export class EulerBorrowProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "vault", call: "eVault", target: "tokenAddress" }],
+        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: "vault" },
+        ],
+    };
+    // 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("totalBorrows", calls[index++])[0],
+        typeInfo.totalAssets, decimalsUnderlyingToken);
+        cardName = generateCardName(type, typeInfo, campaign);
+        const vaultName = await fetchEulerVaultName(typeInfo.vault, campaign.chainId);
+        if (!!vaultName) {
+            cardName = `Borrow from ${vaultName} vault`;
+        }
+        const tvl = priceUnderlying * totalAssetsOrBorrows;
+        const priceTargetToken = tvl / totalSupply;
+        return {
+            ...typeInfo,
+            totalSupply,
+            blacklistedSupply,
+            whitelistedSupplyTargetToken,
+            tvl,
+            priceTargetToken,
+            cardName: cardName,
+            totalAssets: typeInfo.totalAssets,
+        };
+    }
+}