@merkl/api 0.9.15

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

@@ -0,0 +1,47 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+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);
+        if (type === tokenType.moonwell || type === tokenType.venus) {
+            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/engine/erc20SubTypeProcessors/implementations/AuraProcessor.d.ts

@@ -0,0 +1,70 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawAura;
+    call: string;
+    target: keyof callKeysAura;
+    metaData?: keyof callKeysAura;
+};
+type callKeysAura = mandatoryCallKeys & {
+    balancerPool: string;
+    vault: string;
+    auraOperator: string;
+    poolId: string;
+    totalSupplyBalancerPool: string;
+    gaugeContract: string;
+    auraStaker: string;
+    totalSupplyGauge: string;
+    pid: string;
+    gaugeBalance: string;
+    auraBalance: string;
+    vaultBalance: string;
+};
+type dataRawAura = callKeysAura & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+        amountInPool: number;
+        symbol: string;
+        decimals: number;
+        price: number;
+    }>;
+};
+type dataTypeAura = dataType & {
+    balancerPool: string;
+    vault: string;
+    auraOperator: string;
+    poolId: string;
+    totalSupplyBalancerPool: number;
+    gaugeContract: string;
+    auraStaker: string;
+    totalSupplyGauge: number;
+    pid: string;
+    gaugeBalance: number;
+    auraBalance: number;
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+        amountInPool: number;
+        symbol: string;
+        decimals: number;
+        price: number;
+    }>;
+};
+export declare class AuraProcessor extends GenericProcessor<callKeysAura, dataRawAura, dataTypeAura> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound4(typeInfo: dataRawAura): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAura>;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+}
+export {};

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

@@ -0,0 +1,110 @@
+import { decodeCall } from "@/utils/decodeCalls";
+import { createCall } from "@/utils/encodeCalls";
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { utils } from "ethers";
+import { GenericProcessor, Round } 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: "vaultBalance", call: "balanceOf", target: "balancerPool", metaData: "vault" },
+            { 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(),
+                    amountInPool: 0,
+                    symbol: "",
+                    decimals: 0,
+                    price: 0,
+                });
+                i++;
+                typeInfo.poolTokens = poolTokens;
+            }
+        }
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        let { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const vaultBalance = BN2Number(typeInfo.vaultBalance, 18);
+        const vaultIndex = campaign.campaignParameters.blacklist
+            ?.map(b => utils.getAddress(b))
+            ?.indexOf(utils.getAddress(typeInfo.vault));
+        if (vaultIndex !== -1) {
+            blacklistedSupply -= BN2Number(decodeCall(calls, index + vaultIndex, "balanceOf"), campaign.campaignParameters.decimalsTargetToken); // The vault balance was already removed from the total supply
+        }
+        const totalSupplyBalancerPool = BN2Number(typeInfo.totalSupplyBalancerPool, 18) - vaultBalance;
+        const gaugeBalance = BN2Number(typeInfo.gaugeBalance, 18);
+        const auraBalance = BN2Number(typeInfo.auraBalance, 18);
+        const totalSupplyGauge = BN2Number(typeInfo.totalSupplyGauge, 18);
+        let poolTvl = 0;
+        const symbols = [];
+        let indexUpdated = index + this.rounds.round4.length;
+        for (const poolToken of typeInfo.poolTokens) {
+            poolToken.symbol = decodeCall(calls, indexUpdated++, "symbol");
+            poolToken.decimals = decodeCall(calls, indexUpdated++, "decimals");
+            poolToken.amountInPool = BN2Number(poolToken.balance, poolToken.decimals);
+            poolToken.price = (await pricer.get({ symbol: poolToken.symbol })) ?? 0;
+            poolTvl += poolToken.price * poolToken.amountInPool;
+            symbols.push(poolToken.symbol);
+        }
+        const percentageOfSupplyInAura = (auraBalance / totalSupplyGauge) * (gaugeBalance / totalSupplyBalancerPool);
+        const tvl = poolTvl * percentageOfSupplyInAura;
+        const priceTargetToken = tvl / totalSupplyBalancerPool;
+        return {
+            ...typeInfo,
+            totalSupplyBalancerPool,
+            gaugeBalance,
+            auraBalance,
+            totalSupplyGauge,
+            totalSupply,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            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(Round.three, calls, typeInfo, type, index);
+        this.processingRound4(typeInfo);
+        const poolCalls = this.encodeNextRound(Round.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/engine/erc20SubTypeProcessors/implementations/BEXRewardGaugeProcessor.d.ts

@@ -0,0 +1,51 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import { tokenType, type tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawBG;
+    call: string;
+    target: keyof callKeysBG;
+    metaData?: keyof callKeysBG;
+};
+type callKeysBG = mandatoryCallKeys & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+    vaultBalance: string;
+};
+type dataRawBG = callKeysBG & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+};
+type dataTypeBG = dataType & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+    vaultBalance: string;
+};
+export declare class BEXRewardGaugeProcessor extends GenericProcessor<callKeysBG, dataRawBG, dataTypeBG> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound4(typeInfo: dataRawBG): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+}
+export {};

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

@@ -0,0 +1,102 @@
+import { decodeCall } from "@/utils/decodeCalls";
+import { createCall } from "@/utils/encodeCalls";
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor, Round } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+export class BEXRewardGaugeProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "gyroscopeToken", call: "lp_token", target: "tokenAddress" }],
+        round2: [
+            { key: "balanceUnderlyingPoolTokens", call: "totalAssets", target: "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" },
+            { key: "vaultBalance", call: "balanceOf", target: "gyroscopeToken", metaData: "vault" },
+        ],
+        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);
+        }
+        let adjustedPoolTotalSupply = BN2Number(typeInfo.totalSupplyUnderlyingPoolTokens, 18) - BN2Number(typeInfo.vaultBalance, 18);
+        if (type === tokenType.beratrax_vault) {
+            // Weird edge case where the total supply is 80k higher than it should be because they minted stuff on an EOA
+            adjustedPoolTotalSupply -= 35724494.54 + 82793;
+        }
+        let percentageOfSupplyUnderlyingPoolTokens = 1;
+        if (adjustedPoolTotalSupply > 0) {
+            percentageOfSupplyUnderlyingPoolTokens =
+                BN2Number(typeInfo.balanceUnderlyingPoolTokens, 18) / adjustedPoolTotalSupply;
+        }
+        const tvl = tvlUnderlyingPool * percentageOfSupplyUnderlyingPoolTokens;
+        const priceTargetToken = tvl / totalSupply;
+        // If one of the symbols in the symbol list contains 2 of the other symbols of the list, remove it
+        // It's a weird edge case that happens with the BEX pools
+        const symbolToRemove = symbols.find(symbol => symbols.filter(s => symbol.includes(s)).length > 1);
+        if (symbolToRemove) {
+            symbols.splice(symbols.indexOf(symbolToRemove), 1);
+        }
+        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(Round.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/engine/erc20SubTypeProcessors/implementations/BalancerGaugeProcessor.d.ts

@@ -0,0 +1,49 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawBG;
+    call: string;
+    target: keyof callKeysBG;
+    metaData?: keyof callKeysBG;
+};
+type callKeysBG = mandatoryCallKeys & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+};
+type dataRawBG = callKeysBG & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+};
+type dataTypeBG = dataType & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+};
+export declare class BalancerGaugeProcessor extends GenericProcessor<callKeysBG, dataRawBG, dataTypeBG> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound4(typeInfo: dataRawBG): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+}
+export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/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, Round } 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(Round.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/engine/erc20SubTypeProcessors/implementations/BalancerPoolProcessor.d.ts

@@ -0,0 +1,60 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawBP;
+    call: string;
+    target: keyof callKeysBP;
+    metaData?: keyof callKeysBP;
+};
+type callKeysBP = mandatoryCallKeys & {
+    tokenAddress: string;
+    poolId: string;
+    vault: string;
+    totalSupply: string;
+    vaultBalance: string;
+    blacklistedSupply: string;
+};
+type dataRawBP = callKeysBP & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+        amountInPool: number;
+        symbol: string;
+        decimals: number;
+        price: number;
+    }>;
+};
+type dataTypeBP = dataType & {
+    tokenAddress: string;
+    poolId: string;
+    vault: string;
+    poolTokens: Array<{
+        token: string;
+        amountInPool: number;
+        symbol: string;
+        decimals: number;
+        price: number;
+    }>;
+    totalSupply: number;
+    blacklistedSupply: number;
+    tvl: number;
+    priceTargetToken: number;
+    cardName: string;
+    vaultBalance: number;
+};
+export declare class BalancerPoolProcessor extends GenericProcessor<callKeysBP, dataRawBP, dataTypeBP> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBP>;
+    processingRound4(typeInfo: dataRawBP): void;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+}
+export {};

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

@@ -0,0 +1,95 @@
+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, Round } 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);
+        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) {
+            poolToken.symbol = decodeCall(calls, indexUpdated++, "symbol");
+            poolToken.decimals = decodeCall(calls, indexUpdated++, "decimals");
+            poolToken.amountInPool = BN2Number(poolToken.balance, poolToken.decimals);
+            poolToken.price = (await pricer.get({ symbol: poolToken.symbol })) ?? 0;
+            tvl += poolToken.price * poolToken.amountInPool;
+            symbols.push(poolToken.symbol);
+        }
+        const priceTargetToken = tvl / totalSupplyUpdated;
+        return {
+            ...typeInfo,
+            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(),
+                    amountInPool: 0,
+                    symbol: "",
+                    decimals: 0,
+                    price: 0,
+                });
+            }
+            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(Round.three, calls, typeInfo, type, index);
+        this.processingRound4(typeInfo);
+        const poolCalls = this.encodeNextRound(Round.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,
+            },
+        };
+    }
+}