@merkl/api 0.10.199 → 0.10.200

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound2.d.ts

@@ -1,7 +1,3 @@
-import { Interface } from "@ethersproject/abi";
 import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
-export declare const balancerPoolInterface: Interface;
-export declare const gearboxVaultInterface: Interface;
-export declare const auraOperatorInterface: Interface;
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
 export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;

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

@@ -1,645 +1,22 @@
-import { Interface } from "@ethersproject/abi";
-import { BN2Number, ERC20Interface, UniswapV2PoolInterface } from "@sdk";
-import { tokenType } from "./helpers/tokenType";
-import { OneInchStakingInterface, aaveInterface, auraInterface, balancerGaugeInterface, beefyInterface, compoundInterface, curveInterface, enzymeInterface, eulerInterface, fluidInterface, fraxlendInterface, ionicInterface, layerBankInterface, metamorphoInterface, moonwellInterface, radiantInterface, sturdyInterface, } from "./subtypesRound1";
-const balancerPoolABI = [
-    {
-        inputs: [],
-        name: "getPoolId",
-        outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getVault",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const gearboxVaultABI = [
-    {
-        inputs: [],
-        name: "totalAssets",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "underlyingToken",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-// lptoken address, token address, gauge address, crvRewards address, stash address, shutdown bool
-const auraOperatorABI = [
-    {
-        inputs: [
-            {
-                name: "input",
-                type: "uint256",
-            },
-        ],
-        name: "poolInfo",
-        outputs: [
-            {
-                name: "lptoken",
-                type: "address",
-            },
-            {
-                name: "token",
-                type: "address",
-            },
-            {
-                name: "gauge",
-                type: "address",
-            },
-            {
-                name: "crvRewards",
-                type: "address",
-            },
-            {
-                name: "stash",
-                type: "address",
-            },
-            {
-                name: "shutdown",
-                type: "bool",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "staker",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-export const balancerPoolInterface = new Interface(balancerPoolABI);
-export const gearboxVaultInterface = new Interface(gearboxVaultABI);
-export const auraOperatorInterface = new Interface(auraOperatorABI);
+import { processorMapping } from "./processor/processorMapping";
 export function getTokenTypeRound2(index, type, typeInfo, calls) {
-    if (type === tokenType.uniswapv2 ||
-        type === tokenType.poolside ||
-        type === tokenType.aerodrome ||
-        type === tokenType.velodrome ||
-        type === tokenType.dragonswap ||
-        type === tokenType.akron) {
-        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.tokenAddress]),
-                    target: token0,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [typeInfo.tokenAddress]),
-                    target: token1,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                token0,
-                token1,
-            },
-        };
-    }
-    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 lp_token = balancerGaugeInterface.decodeFunctionResult("lp_token", calls[index].returnData)[0];
-        return {
-            type: tokenType.balancerGauge,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [typeInfo.tokenAddress]),
-                    target: lp_token,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: lp_token,
-                },
-                {
-                    allowFailure: true,
-                    callData: balancerPoolInterface.encodeFunctionData("getPoolId"),
-                    target: lp_token,
-                },
-                {
-                    allowFailure: true,
-                    callData: balancerPoolInterface.encodeFunctionData("getVault"),
-                    target: lp_token,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                gyroscopeToken: lp_token,
-            },
-        };
-    }
-    // symbol is ECLP-USDC-USDT
-    if (type === tokenType.balancerPool) {
-        // Call the get Price function on the gyroscope pool address
-        return {
-            type: tokenType.balancerPool,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: balancerPoolInterface.encodeFunctionData("getPoolId"),
-                    target: typeInfo.tokenAddress,
-                },
-                {
-                    allowFailure: true,
-                    callData: balancerPoolInterface.encodeFunctionData("getVault"),
-                    target: typeInfo.tokenAddress,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-    if (type === tokenType.aura) {
-        const balancerPool = auraInterface.decodeFunctionResult("asset", calls[index].returnData)[0];
-        const auraOperator = auraInterface.decodeFunctionResult("operator", calls[index + 1].returnData)[0];
-        const pid = auraInterface.decodeFunctionResult("pid", calls[index + 2].returnData)[0].toNumber();
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: balancerPoolInterface.encodeFunctionData("getPoolId"),
-                    target: balancerPool,
-                },
-                {
-                    allowFailure: true,
-                    callData: balancerPoolInterface.encodeFunctionData("getVault"),
-                    target: balancerPool,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: balancerPool,
-                },
-                {
-                    allowFailure: true,
-                    callData: auraOperatorInterface.encodeFunctionData("poolInfo", [pid]),
-                    target: auraOperator,
-                },
-                {
-                    allowFailure: true,
-                    callData: auraOperatorInterface.encodeFunctionData("staker"),
-                    target: auraOperator,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                balancerPool: balancerPool,
-                auraOperator: auraOperator,
-                auraPoolId: pid,
-            },
-        };
-    }
-    if (type === tokenType.gearbox) {
-        // Get the underlying gearbox token to fetch the final underlying token
-        const stakingToken = OneInchStakingInterface.decodeFunctionResult("stakingToken", calls[index].returnData)[0];
-        return {
-            type: tokenType.gearbox,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [typeInfo.tokenAddress]),
-                    target: stakingToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                    target: stakingToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("decimals"),
-                    target: stakingToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: gearboxVaultInterface.encodeFunctionData("underlyingToken"),
-                    target: stakingToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: gearboxVaultInterface.encodeFunctionData("totalAssets"),
-                    target: stakingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                stakingToken: stakingToken,
-            },
-        };
-    }
-    if (type === tokenType.compound) {
-        // Get the underlying gearbox token to fetch the final underlying token
-        const baseToken = compoundInterface.decodeFunctionResult("baseToken", calls[index].returnData)[0];
-        return {
-            type: tokenType.compound,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: compoundInterface.encodeFunctionData("totalBorrow"),
-                    target: typeInfo.tokenAddress,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("balanceOf", [typeInfo.tokenAddress]),
-                    target: baseToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: baseToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("decimals"),
-                    target: baseToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                baseToken: baseToken,
-            },
-        };
-    }
-    if (type === tokenType.radiant_lend) {
-        const underlyingToken = radiantInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", calls[index].returnData)[0];
-        const priceBN = radiantInterface.decodeFunctionResult("getAssetPrice", calls[index + 1].returnData)[0];
-        return {
-            type: tokenType.radiant_lend,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken: underlyingToken,
-                priceTargetToken: BN2Number(priceBN, 8),
-            },
-        };
-    }
-    if (type === tokenType.radiant_borrow) {
-        const underlyingToken = radiantInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", calls[index].returnData)[0];
-        const priceBN = radiantInterface.decodeFunctionResult("getAssetPrice", calls[index + 1].returnData)[0];
-        return {
-            type: tokenType.radiant_borrow,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken: underlyingToken,
-                priceTargetToken: BN2Number(priceBN, 8),
-            },
-        };
-    }
-    // https://explorer.mode.network/address/0x71ef7EDa2Be775E5A7aa8afD02C45F059833e9d2
-    if (type === tokenType.ionic) {
-        const underlyingToken = ionicInterface.decodeFunctionResult("underlying", calls[index].returnData)[0];
-        const exchangeRate = ionicInterface.decodeFunctionResult("exchangeRateCurrent", calls[index + 1].returnData)[0];
-        return {
-            type: tokenType.ionic,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken: underlyingToken,
-                exchangeRate: BN2Number(exchangeRate, 18),
-            },
-        };
-    }
-    if (type === tokenType.layerbank) {
-        const underlyingToken = layerBankInterface.decodeFunctionResult("underlying", calls[index].returnData)[0];
-        const exchangeRate = layerBankInterface.decodeFunctionResult("exchangeRate", calls[index + 1].returnData)[0];
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken: underlyingToken,
-                exchangeRate: BN2Number(exchangeRate, 18),
-            },
-        };
-    }
-    if (type === tokenType.metamorpho) {
-        const underlyingToken = metamorphoInterface.decodeFunctionResult("asset", calls[index].returnData)[0];
-        return {
-            type: tokenType.metamorpho,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken,
-            },
-        };
-    }
-    if (type === tokenType.moonwell) {
-        const underlyingToken = moonwellInterface.decodeFunctionResult("underlying", calls[index].returnData)[0];
-        const exchangeRate = moonwellInterface.decodeFunctionResult("exchangeRateStored", calls[index + 1].returnData)[0];
-        return {
-            type: tokenType.moonwell,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("decimals"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken,
-                exchangeRate: BN2Number(exchangeRate, 18),
-            },
-        };
-    }
-    if (type === tokenType.aave_lending || type === tokenType.aave_borrowing) {
-        const underlyingToken = aaveInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", calls[index].returnData)[0];
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken,
-            },
-        };
-    }
-    if (type === tokenType.fraxlend || type === tokenType.sturdy_aggregator || type === tokenType.sturdy_silo) {
-        const underlyingToken = fraxlendInterface.decodeFunctionResult("asset", calls[index].returnData)[0];
-        const sharePrice = fraxlendInterface.decodeFunctionResult("pricePerShare", calls[index + 1].returnData)[0];
-        if (type === tokenType.sturdy_silo) {
-            const collateral = sturdyInterface.decodeFunctionResult("collateralContract", calls[index + 2].returnData)[0];
-            return {
-                type: type,
-                calls: [
-                    {
-                        allowFailure: true,
-                        callData: ERC20Interface.encodeFunctionData("symbol"),
-                        target: underlyingToken,
-                    },
-                    {
-                        allowFailure: true,
-                        callData: ERC20Interface.encodeFunctionData("symbol"),
-                        target: collateral,
-                    },
-                ],
-                typeInfo: {
-                    ...typeInfo,
-                    underlyingToken,
-                    sharePrice: BN2Number(sharePrice, 18),
-                    collateral,
-                },
-            };
-        }
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken,
-                sharePrice: BN2Number(sharePrice, 18),
-            },
-        };
-    }
-    if (type === tokenType.curve || type === tokenType.curve_2) {
-        let lp_price;
-        if (type === tokenType.curve) {
-            lp_price = curveInterface.decodeFunctionResult("lp_price", calls[index].returnData)[0];
-        }
-        else {
-            lp_price = curveInterface.decodeFunctionResult("get_virtual_price", calls[index].returnData)[0];
-        }
-        let i = 1;
-        const poolTokensList = [];
-        while (i <= 3) {
-            try {
-                const token = curveInterface.decodeFunctionResult("coins", calls[index + i].returnData)[0];
-                poolTokensList.push(token);
-            }
-            catch (e) { }
-            i++;
+    try {
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        const ProcessorClass = processorMapping[type];
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
         }
-        return {
-            type: type,
-            calls: poolTokensList.map(token => {
-                return {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: token,
-                };
-            }),
-            typeInfo: {
-                ...typeInfo,
-                lp_price: BN2Number(lp_price, 18),
-                poolTokensList,
-            },
-        };
-    }
-    if (type === tokenType.fluid) {
-        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.enzyme) {
-        const underlyingToken = enzymeInterface.decodeFunctionResult("calcNetShareValue", calls[index].returnData)[0];
-        const exchangeRate = BN2Number(enzymeInterface.decodeFunctionResult("calcNetShareValue", calls[index].returnData)[1]);
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ERC20Interface.encodeFunctionData("symbol"),
-                    target: underlyingToken,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                underlyingToken,
-                exchangeRate,
-            },
-        };
-    }
-    if (type === tokenType.euler_borrow) {
-        const vault = eulerInterface.decodeFunctionResult("eVault", calls[index].returnData)[0];
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: eulerInterface.encodeFunctionData("asset"),
-                    target: vault,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-                vault,
-            },
-        };
-    }
-    if (type === tokenType.euler_lend) {
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: eulerInterface.encodeFunctionData("asset"),
-                    target: typeInfo.tokenAddress,
-                },
-            ],
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound2(index, type, typeInfo, returnValueOfCalls);
     }
-    if (type === tokenType.beefy) {
-        const pricePerShare = BN2Number(beefyInterface.decodeFunctionResult("getPricePerFullShare", calls[index].returnData)[0]);
-        const underlyingToken = beefyInterface.decodeFunctionResult("want", calls[index + 1].returnData)[0];
+    catch (error) {
+        console.error(error);
         return {
             type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
-                    target: underlyingToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
-                    target: underlyingToken,
-                },
-            ],
+            calls: [],
             typeInfo: {
                 ...typeInfo,
-                underlyingToken,
-                pricePerShare,
             },
         };
     }
-    return {
-        type: type,
-        calls: [],
-        typeInfo: {
-            ...typeInfo,
-        },
-    };
 }

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3.d.ts

@@ -1,6 +1,3 @@
-import { Interface } from "@ethersproject/abi";
 import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
-export declare const BALANCER_VAULT_ADDRESS = "0xBA12222222228d8Ba445958a75a0704d566BF2C8";
-export declare const balancerVaultInterface: Interface;
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
 export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;