@merkl/api 0.10.129 → 0.10.130

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3.js

@@ -0,0 +1,392 @@
+import { Interface } from "@ethersproject/abi";
+import { BN2Number, ERC20Interface, UniswapV2PoolInterface } from "@sdk";
+import { BigNumber } from "ethers";
+import { tokenType } from "./helpers/tokenType";
+import { compoundInterface, fluidInterface } from "./subtypesRound1";
+import { auraOperatorInterface, balancerPoolInterface, gearboxVaultInterface } from "./subtypesRound2";
+export const BALANCER_VAULT_ADDRESS = "0xBA12222222228d8Ba445958a75a0704d566BF2C8"; // Same for all chains
+const balancerVaultABI = [
+    {
+        constant: true,
+        inputs: [
+            {
+                name: "poolId",
+                type: "bytes32",
+            },
+        ],
+        name: "getPoolTokens",
+        outputs: [
+            {
+                name: "tokens",
+                type: "address[]",
+            },
+            {
+                name: "balances",
+                type: "uint256[]",
+            },
+            {
+                name: "lastChangeBlock",
+                type: "uint256",
+            },
+        ],
+        payable: false,
+        stateMutability: "view",
+        type: "function",
+    },
+];
+export const balancerVaultInterface = new Interface(balancerVaultABI);
+export function getTokenTypeRound3(index, type, typeInfo, calls) {
+    if (type === tokenType.uniswapv2 ||
+        type === tokenType.poolside ||
+        type === tokenType.aerodrome ||
+        type === tokenType.velodrome ||
+        type === tokenType.dragonswap ||
+        type === tokenType.akron) {
+        const symbolToken0 = ERC20Interface.decodeFunctionResult("symbol", calls[index].returnData)[0];
+        const symbolToken1 = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
+        const decimalsToken0 = ERC20Interface.decodeFunctionResult("decimals", calls[index + 2].returnData)[0];
+        const decimalsToken1 = ERC20Interface.decodeFunctionResult("decimals", calls[index + 3].returnData)[0];
+        const balanceToken0 = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 4].returnData)[0];
+        const balanceToken1 = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 5].returnData)[0];
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                symbolToken0,
+                symbolToken1,
+                decimalsToken0,
+                decimalsToken1,
+                balanceToken0: BN2Number(balanceToken0, decimalsToken0),
+                balanceToken1: BN2Number(balanceToken1, decimalsToken1),
+            },
+        };
+    }
+    if (type === tokenType.balancerGauge) {
+        // Call the get Price function on the gyroscope pool address
+        // Get the balance of the balancer contract of the gyroscope pool token
+        const balanceUnderlyingPoolTokens = ERC20Interface.decodeFunctionResult("balanceOf", calls[index].returnData)[0];
+        const totalSupplyUnderlyingPoolTokens = ERC20Interface.decodeFunctionResult("totalSupply", calls[index + 1].returnData)[0];
+        const poolId = balancerPoolInterface.decodeFunctionResult("getPoolId", calls[index + 2].returnData)[0];
+        const vault = balancerPoolInterface.decodeFunctionResult("getVault", calls[index + 3].returnData)[0];
+        return {
+            type: tokenType.balancerGauge,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: balancerVaultInterface.encodeFunctionData("getPoolTokens", [poolId]),
+                    target: vault,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                percentageOfSupplyUnderlyingPoolTokens: BN2Number(balanceUnderlyingPoolTokens, 18) / BN2Number(totalSupplyUnderlyingPoolTokens, 18),
+                poolId,
+                vault,
+            },
+        };
+    }
+    // symbol is ECLP-USDC-USDT
+    if (type === tokenType.balancerPool) {
+        const poolId = balancerPoolInterface.decodeFunctionResult("getPoolId", calls[index].returnData)[0];
+        const vault = balancerPoolInterface.decodeFunctionResult("getVault", calls[index + 1].returnData)[0];
+        return {
+            type: tokenType.balancerPool,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: balancerVaultInterface.encodeFunctionData("getPoolTokens", [poolId]),
+                    target: vault,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                poolId,
+                vault,
+            },
+        };
+    }
+    if (type === tokenType.aura) {
+        const poolId = balancerPoolInterface.decodeFunctionResult("getPoolId", calls[index].returnData)[0];
+        const vault = balancerPoolInterface.decodeFunctionResult("getVault", calls[index + 1].returnData)[0];
+        const totalSupplyBalancerPool = ERC20Interface.decodeFunctionResult("totalSupply", calls[index + 2].returnData)[0];
+        const gaugeContract = auraOperatorInterface.decodeFunctionResult("poolInfo", calls[index + 3].returnData)[2];
+        const auraStaker = auraOperatorInterface.decodeFunctionResult("staker", calls[index + 4].returnData)[0];
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: balancerVaultInterface.encodeFunctionData("getPoolTokens", [poolId]),
+                    target: vault,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [gaugeContract]),
+                    target: typeInfo.balancerPool,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [auraStaker]),
+                    target: gaugeContract,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                    target: gaugeContract,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                poolId,
+                totalSupplyBalancerPool: BN2Number(totalSupplyBalancerPool, 18),
+                gaugeContract,
+                auraStaker,
+                vault,
+            },
+        };
+    }
+    if (type === tokenType.gearbox) {
+        // Get the underlying gearbox token to fetch the final underlying token
+        const balanceStakingToken = ERC20Interface.decodeFunctionResult("balanceOf", calls[index].returnData)[0];
+        const totalSupplyStakingToken = ERC20Interface.decodeFunctionResult("totalSupply", calls[index + 1].returnData)[0];
+        const decimalsStakingToken = ERC20Interface.decodeFunctionResult("decimals", calls[index + 2].returnData)[0];
+        const underlyingToken = gearboxVaultInterface.decodeFunctionResult("underlyingToken", calls[index + 3].returnData)[0];
+        const totalAssets = gearboxVaultInterface.decodeFunctionResult("totalAssets", calls[index + 4].returnData)[0];
+        const percentageOfSupplyUnderlyingPoolTokens = BN2Number(balanceStakingToken, decimalsStakingToken) / BN2Number(totalSupplyStakingToken, decimalsStakingToken);
+        return {
+            type: tokenType.gearbox,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("decimals"),
+                    target: underlyingToken,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("symbol"),
+                    target: underlyingToken,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                decimalsStakingToken,
+                underlyingToken,
+                totalAssets: totalAssets,
+                balanceStakingToken: BN2Number(balanceStakingToken, decimalsStakingToken),
+                totalSupplyStakingToken: BN2Number(totalSupplyStakingToken, decimalsStakingToken),
+                percentageOfSupplyUnderlyingPoolTokens,
+            },
+        };
+    }
+    if (type === tokenType.compound) {
+        // Get the underlying gearbox token to fetch the final underlying token
+        const totalBorrow = compoundInterface.decodeFunctionResult("totalBorrow", calls[index].returnData)[0];
+        const balanceBaseToken = ERC20Interface.decodeFunctionResult("balanceOf", calls[index + 1].returnData)[0];
+        const symbolBaseToken = ERC20Interface.decodeFunctionResult("symbol", calls[index + 2].returnData)[0];
+        const decimalsBaseToken = ERC20Interface.decodeFunctionResult("decimals", calls[index + 3].returnData)[0];
+        return {
+            type: tokenType.compound,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                totalBorrow: BN2Number(totalBorrow, decimalsBaseToken),
+                balanceBaseToken: BN2Number(balanceBaseToken, decimalsBaseToken),
+                symbolBaseToken,
+                decimalsBaseToken,
+            },
+        };
+    }
+    if (type === tokenType.ionic ||
+        type === tokenType.radiant_borrow ||
+        type === tokenType.radiant_lend ||
+        type === tokenType.layerbank ||
+        type === tokenType.metamorpho) {
+        let symbolUnderlyingToken;
+        try {
+            symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index].returnData)[0];
+        }
+        catch (e) {
+            // usually if this fails its because of native ETH
+            symbolUnderlyingToken = "ETH";
+        }
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                symbolUnderlyingToken: symbolUnderlyingToken,
+            },
+        };
+    }
+    if (type === tokenType.moonwell) {
+        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index].returnData)[0];
+        const decimalsUnderlyingToken = ERC20Interface.decodeFunctionResult("decimals", calls[index + 1].returnData)[0];
+        return {
+            type: tokenType.moonwell,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                symbolUnderlyingToken,
+                decimalsUnderlyingToken,
+            },
+        };
+    }
+    if (type === tokenType.aave_lending || type === tokenType.aave_borrowing) {
+        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index].returnData)[0];
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                symbolUnderlyingToken,
+            },
+        };
+    }
+    if (type === tokenType.fraxlend || type === tokenType.sturdy_aggregator || type === tokenType.sturdy_silo) {
+        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index].returnData)[0];
+        if (type === tokenType.sturdy_silo) {
+            const symbolCollateral = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
+            return {
+                type: type,
+                calls: [],
+                typeInfo: {
+                    ...typeInfo,
+                    symbolUnderlyingToken,
+                    symbolCollateral,
+                },
+            };
+        }
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                symbolUnderlyingToken,
+            },
+        };
+    }
+    if (type === tokenType.curve || type === tokenType.curve_2) {
+        const poolTokens = {};
+        let i = 0;
+        for (const token of typeInfo.poolTokensList) {
+            const symbol = ERC20Interface.decodeFunctionResult("symbol", calls[index + i].returnData)[0];
+            poolTokens[token] = symbol;
+            i++;
+        }
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                poolTokens: poolTokens,
+            },
+        };
+    }
+    if (type === tokenType.fluid) {
+        const decimalsUnderlyingToken = ERC20Interface.decodeFunctionResult("decimals", calls[index].returnData)[0];
+        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index + 1].returnData)[0];
+        // BigNumber.from(10).pow(decimals).toString()
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: fluidInterface.encodeFunctionData("convertToAssets", [
+                        BigNumber.from(10).pow(decimalsUnderlyingToken).toString(),
+                    ]),
+                    target: typeInfo.tokenAddress,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                decimalsUnderlyingToken: decimalsUnderlyingToken,
+                symbolUnderlyingToken: symbolUnderlyingToken,
+            },
+        };
+    }
+    if (type === tokenType.enzyme) {
+        const symbolUnderlyingToken = ERC20Interface.decodeFunctionResult("symbol", calls[index].returnData)[0];
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+                symbolUnderlyingToken,
+            },
+        };
+    }
+    if (type === tokenType.euler_borrow || type === tokenType.euler_lend) {
+        const underlyingToken = fluidInterface.decodeFunctionResult("asset", calls[index].returnData)[0];
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("decimals"),
+                    target: underlyingToken,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("symbol"),
+                    target: underlyingToken,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                underlyingToken: underlyingToken,
+            },
+        };
+    }
+    if (type === tokenType.beefy) {
+        const token0 = UniswapV2PoolInterface.decodeFunctionResult("token0", calls[index].returnData)[0];
+        const token1 = UniswapV2PoolInterface.decodeFunctionResult("token1", calls[index + 1].returnData)[0];
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("symbol"),
+                    target: token0,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("symbol"),
+                    target: token1,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("decimals"),
+                    target: token0,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("decimals"),
+                    target: token1,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [typeInfo.underlyingToken]),
+                    target: token0,
+                },
+                {
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [typeInfo.underlyingToken]),
+                    target: token1,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                token0,
+                token1,
+            },
+        };
+    }
+    return {
+        type: type,
+        calls: [],
+        typeInfo: {
+            ...typeInfo,
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3RefactoFinal.js

@@ -0,0 +1,22 @@
+import { processorMapping } from "./processor/processorMapping";
+export function getTokenTypeRound3(index, type, typeInfo, calls) {
+    try {
+        const ProcessorClass = processorMapping[type];
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound3(index, type, typeInfo, returnValueOfCalls);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}