@merkl/api 0.10.199 → 0.10.200

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

@@ -1,392 +1,22 @@
-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);
+import { processorMapping } from "./processor/processorMapping";
 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,
-                },
-            };
+    try {
+        const ProcessorClass = processorMapping[type];
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
         }
-        return {
-            type: type,
-            calls: [],
-            typeInfo: {
-                ...typeInfo,
-                symbolUnderlyingToken,
-            },
-        };
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound3(index, type, typeInfo, returnValueOfCalls);
     }
-    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++;
-        }
+    catch (error) {
+        console.error(error);
         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/subtypesRound4.d.ts

@@ -1,4 +1,4 @@
-import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Campaign, CampaignParameters } from "@sdk";
 import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound4(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound4(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;