@merkl/api 0.10.129 → 0.10.131

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

@@ -0,0 +1,645 @@
+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);
+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++;
+        }
+        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,
+            },
+        };
+    }
+    if (type === tokenType.beefy) {
+        const pricePerShare = BN2Number(beefyInterface.decodeFunctionResult("getPricePerFullShare", calls[index].returnData)[0]);
+        const underlyingToken = beefyInterface.decodeFunctionResult("want", calls[index + 1].returnData)[0];
+        return {
+            type: type,
+            calls: [
+                {
+                    allowFailure: true,
+                    callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
+                    target: underlyingToken,
+                },
+                {
+                    allowFailure: true,
+                    callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
+                    target: underlyingToken,
+                },
+            ],
+            typeInfo: {
+                ...typeInfo,
+                underlyingToken,
+                pricePerShare,
+            },
+        };
+    }
+    return {
+        type: type,
+        calls: [],
+        typeInfo: {
+            ...typeInfo,
+        },
+    };
+}

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

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