@merkl/api 0.10.199 → 0.10.200

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

@@ -1,1209 +1,232 @@
-import { Interface } from "@ethersproject/abi";
-import { ERC20Interface, UniswapV2PoolInterface } from "@sdk";
+import { decodeCall } from "../../../../utils/decodeCalls";
 import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
 import { tokenType } from "./helpers/tokenType";
-import { balancerPoolInterface } from "./subtypesRound2";
-const factoryABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: "factory",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const balancerGaugeABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: "lp_token",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const OneInchStakingContract = [
-    {
-        constant: true,
-        inputs: [],
-        name: "stakingToken",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const compoundABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: "baseToken",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "totalBorrow",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const radiantABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: "UNDERLYING_ASSET_ADDRESS",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "getAssetPrice",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const ionicABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: "exchangeRateCurrent",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "underlying",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const layerBankABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: "exchangeRate",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "underlying",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const metamorphoABI = [
-    {
-        inputs: [],
-        name: "MORPHO",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "asset",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const moonwellABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: "exchangeRateStored",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "underlying",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const aaveABI = [
-    {
-        inputs: [],
-        name: "UNDERLYING_ASSET_ADDRESS",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const fraxlendABI = [
-    {
-        inputs: [],
-        name: "asset",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "pricePerShare",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const curveABI = [
-    {
-        inputs: [],
-        name: "lp_price",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                name: "arg0",
-                type: "uint256",
-            },
-        ],
-        name: "coins",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "get_virtual_price",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const sturdyABI = [
-    {
-        inputs: [],
-        name: "collateralContract",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const torosABI = [
-    {
-        inputs: [],
-        name: "tokenPrice",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "price",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const auraABI = [
-    {
-        inputs: [],
-        name: "asset",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "operator",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "pid",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const fluidABI = [
-    {
-        inputs: [],
-        name: "asset",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "uint256",
-                name: "shares_",
-                type: "uint256",
-            },
-        ],
-        name: "convertToAssets",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const enzymeABI = [
-    {
-        inputs: [],
-        name: "getCreator",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "_vaultProxy",
-                type: "address",
-            },
-        ],
-        name: "calcNetShareValue",
-        outputs: [
-            {
-                internalType: "address",
-                name: "denominationAsset_",
-                type: "address",
-            },
-            {
-                internalType: "uint256",
-                name: "netShareValue_",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-];
-const eulerABI = [
-    {
-        inputs: [],
-        name: "asset",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "eVault",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "totalBorrows",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "totalAssets",
-        outputs: [
-            {
-                name: "",
-                type: "uint256",
-            },
-        ],
-        payable: false,
-        stateMutability: "view",
-        type: "function",
-    },
-];
-const beefyABI = [
-    {
-        inputs: [],
-        name: "getPricePerFullShare",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "price",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "want",
-        outputs: [
-            {
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-];
-export const factoryInterface = new Interface(factoryABI);
-export const balancerGaugeInterface = new Interface(balancerGaugeABI);
-export const OneInchStakingInterface = new Interface(OneInchStakingContract);
-export const compoundInterface = new Interface(compoundABI);
-export const radiantInterface = new Interface(radiantABI);
-export const ionicInterface = new Interface(ionicABI);
-export const layerBankInterface = new Interface(layerBankABI);
-export const metamorphoInterface = new Interface(metamorphoABI);
-export const moonwellInterface = new Interface(moonwellABI);
-export const aaveInterface = new Interface(aaveABI);
-export const fraxlendInterface = new Interface(fraxlendABI);
-export const curveInterface = new Interface(curveABI);
-export const sturdyInterface = new Interface(sturdyABI);
-export const torosInterface = new Interface(torosABI);
-export const auraInterface = new Interface(auraABI);
-export const fluidInterface = new Interface(fluidABI);
-export const enzymeInterface = new Interface(enzymeABI);
-export const eulerInterface = new Interface(eulerABI);
-export const beefyInterface = new Interface(beefyABI);
-export function getTokenTypeRound1(calls, targetToken, index) {
+import { processorMapping } from "./processor/processorMapping";
+function satisfiesNameConditions(name, type) {
+    const lowerCaseName = name.toLowerCase();
+    switch (type) {
+        case tokenType.fraxlend:
+            return lowerCaseName.includes("fraxlend interest bearing");
+        case tokenType.sturdy_aggregator:
+            return lowerCaseName.includes("aggregator");
+        case tokenType.sturdy_silo:
+            return lowerCaseName.includes("sturdy interest bearing");
+        case tokenType.aura:
+            return lowerCaseName.includes("aura deposit vault");
+        case tokenType.poolside:
+            return lowerCaseName.includes("poolside");
+        case tokenType.balancerGauge:
+            return lowerCaseName.includes("balancer") && !lowerCaseName.includes("aura deposit vault");
+        case tokenType.gearbox:
+            return lowerCaseName.includes("farming of");
+        case tokenType.euler_borrow:
+            return lowerCaseName.startsWith("debt token of evk vault");
+        case tokenType.euler_lend:
+            return lowerCaseName.includes("evk vault");
+        case tokenType.fluid:
+            return lowerCaseName.startsWith("fluid");
+        case tokenType.filament:
+            return lowerCaseName.startsWith("filament");
+        case tokenType.radiant_lend:
+            return lowerCaseName.includes("radiant interest");
+        case tokenType.radiant_borrow:
+            return lowerCaseName.includes("radiant variable debt");
+        case tokenType.ionic:
+            return lowerCaseName.includes("ionic");
+        case tokenType.rfx:
+            return lowerCaseName.includes("rfx");
+        case tokenType.layerbank:
+            return lowerCaseName.includes("layerbank");
+        case tokenType.moonwell:
+            return lowerCaseName.includes("moonwell");
+        case tokenType.curve_2:
+            return (lowerCaseName === "crvusd/frax" ||
+                lowerCaseName === "ezeth/wfrxeth" ||
+                lowerCaseName === "pufeth/wsteth" ||
+                lowerCaseName === "hai/lusd");
+        case tokenType.silostaking:
+            return lowerCaseName === "isei";
+        case tokenType.beefy:
+            return lowerCaseName.startsWith("moo velo");
+        case tokenType.uniswapv2:
+            return lowerCaseName.includes("uniswap");
+        case tokenType.fenix:
+            return lowerCaseName.includes("stablev1 amm");
+        case tokenType.ra:
+            return lowerCaseName.includes("volatile pair -") || lowerCaseName.includes("correlated pair -");
+        case tokenType.syncswap:
+            return lowerCaseName.includes("syncswap");
+        case tokenType.aave_lending:
+            return lowerCaseName.includes("aave");
+        case tokenType.aave_borrowing:
+            return lowerCaseName.includes("aave") && lowerCaseName.includes("debt");
+        case tokenType.yei_borrowing:
+            return ((lowerCaseName.startsWith("yei") || (lowerCaseName.includes("aave") && lowerCaseName.includes("yei"))) &&
+                lowerCaseName.includes("debt"));
+        case tokenType.ironclad_borrowing:
+            return ((lowerCaseName.startsWith("ironclad") ||
+                (lowerCaseName.includes("aave") && lowerCaseName.includes("ironclad"))) &&
+                lowerCaseName.includes("debt") &&
+                name.toLowerCase() !== "ironclad token");
+        case tokenType.zerolend_borrowing:
+            return lowerCaseName.includes("zerolend") && lowerCaseName.includes("debt");
+        case tokenType.yei_lending:
+            return lowerCaseName.startsWith("yei") || (lowerCaseName.includes("aave") && lowerCaseName.includes("yei"));
+        case tokenType.ironclad_lending:
+            return ((lowerCaseName.startsWith("ironclad") ||
+                (lowerCaseName.includes("aave") && lowerCaseName.includes("ironclad"))) &&
+                name.toLowerCase() !== "ironclad token");
+        case tokenType.zerolend_lending:
+            return lowerCaseName.includes("zerolend");
+        case tokenType.compound:
+            return lowerCaseName.includes("compound");
+        case tokenType.ironcladStaking:
+            return lowerCaseName === "ironclad token";
+        case tokenType.woofi:
+            return lowerCaseName.includes("woofi");
+        case tokenType.maverickBoostedPosition:
+            return lowerCaseName.includes("maverick");
+        case tokenType.zkSwapThreePool:
+            return lowerCaseName.includes("zf");
+        case tokenType.maha:
+            return lowerCaseName.includes("staked") && lowerCaseName.includes("maha");
+        case tokenType.tempest:
+            return lowerCaseName.startsWith("ts");
+        case tokenType.tempestStaking:
+            return lowerCaseName.startsWith("tempest");
+        case tokenType.holdstation:
+            return lowerCaseName.startsWith("hs");
+        case tokenType.noLinkVault:
+            return lowerCaseName.startsWith("unifi eth");
+        default:
+            return false;
+    }
+}
+function generateResult(type, name, targetToken, typeInfo) {
+    const ProcessorClass = processorMapping[type];
+    if (!ProcessorClass) {
+        throw new Error(`Processor not found for key: ${type}`);
+    }
+    const processorObject = new ProcessorClass();
+    typeInfo = {
+        ...typeInfo,
+        name: name,
+        tokenAddress: targetToken,
+        totalSupply: 0,
+        blacklistedSupply: 0,
+    };
+    return processorObject.computeRound1(type, typeInfo);
+}
+function processNamingConditions(type, name, targetToken) {
+    if (satisfiesNameConditions(name, type)) {
+        return generateResult(type, name, targetToken, {});
+    }
+}
+function processNamingConditionsInOrder(types, name, targetToken) {
+    for (const type of types) {
+        const result = processNamingConditions(type, name, targetToken);
+        if (result)
+            return result;
+    }
+}
+function parseForFactory(calls, index, targetToken) {
     try {
-        const factory = factoryInterface.decodeFunctionResult("factory", calls[index].returnData)[0];
-        const name = ERC20Interface.decodeFunctionResult("name", calls[index + 2].returnData)[0];
+        const factory = decodeCall(calls, index, "factory");
+        const name = decodeCall(calls, index + 2, "name");
         const type = getTypeFromFactoryAddress(factory);
-        if (type === tokenType.aerodrome ||
-            type === tokenType.velodrome ||
-            type === tokenType.dragonswap ||
-            type === tokenType.akron) {
-            return {
-                type: type,
-                calls: [
-                    {
-                        allowFailure: true,
-                        callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
-                        target: targetToken,
-                    },
-                    {
-                        allowFailure: true,
-                        callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
-                        target: targetToken,
-                    },
-                ],
-                typeInfo: {
-                    name: name,
-                    tokenAddress: targetToken,
-                },
-            };
-        }
-        if (type === tokenType.koi ||
-            type === tokenType.baseswap ||
-            type === tokenType.fenix ||
-            type === tokenType.zkswap) {
-            let protocol = "Koi V2";
-            if (type === tokenType.baseswap) {
-                protocol = "BaseSwap V2";
-            }
-            else if (type === tokenType.fenix) {
-                protocol = "Fenix V2";
-            }
-            else if (type === tokenType.zkswap) {
-                protocol = "ZKSwap";
-            }
-            return {
-                type: tokenType.uniswapv2,
-                calls: [
-                    {
-                        allowFailure: true,
-                        callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
-                        target: targetToken,
-                    },
-                    {
-                        allowFailure: true,
-                        callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
-                        target: targetToken,
-                    },
-                ],
-                typeInfo: {
-                    name: name,
-                    tokenAddress: targetToken,
-                    protocol: protocol,
-                },
-            };
-        }
-        if (type === tokenType.curve) {
-            return {
-                type: type,
-                calls: [
-                    {
-                        allowFailure: true,
-                        callData: curveInterface.encodeFunctionData("lp_price"),
-                        target: targetToken,
-                    },
-                    {
-                        allowFailure: true,
-                        callData: curveInterface.encodeFunctionData("coins", [0]),
-                        target: targetToken,
-                    },
-                    {
-                        allowFailure: true,
-                        callData: curveInterface.encodeFunctionData("coins", [1]),
-                        target: targetToken,
-                    },
-                    {
-                        allowFailure: true,
-                        callData: curveInterface.encodeFunctionData("coins", [2]),
-                        target: targetToken,
-                    },
-                ],
-                typeInfo: {
-                    name: name,
-                    tokenAddress: targetToken,
-                },
-            };
-        }
-        // https://explorer.mode.network/address/0x34cf9BF641bd5f34197060A3f3478a1f97f78f0a?tab=read_contract
-        if (type === tokenType.splice) {
-            return {
-                type: type,
-                calls: [],
-                typeInfo: {
-                    name: name,
-                    tokenAddress: targetToken,
-                },
-            };
-        }
-        // Double proxy so explorer link is useless
-        // https://basescan.org/address/0xc1e02884af4a283ca25ab63c45360d220d69da52
-        // ABI here: https://github.com/dhedge/V2-Public/blob/master/abi/PoolLogic.json
-        if (type === tokenType.toros) {
-            return {
-                type: type,
-                calls: [],
-                typeInfo: {
-                    name: name,
-                    tokenAddress: targetToken,
-                },
-            };
-        }
+        if (type !== tokenType.unknown)
+            return generateResult(type, name, targetToken, { factory });
     }
     catch (e) {
         // No factory on this token
     }
+}
+function parseForEnzyme(calls, index, targetToken) {
     // Enzyme check
     try {
-        const dispatcher = enzymeInterface.decodeFunctionResult("getCreator", calls[index + 4].returnData)[0];
-        const name = ERC20Interface.decodeFunctionResult("name", calls[index + 2].returnData)[0];
+        const dispatcher = decodeCall(calls, index + 4, "getCreator");
+        const name = decodeCall(calls, index + 2, "name");
         const type = getTypeFromFactoryAddress(dispatcher);
         const fundValueCalculator = enzymeFundValueCalculatorRouterMapping[dispatcher];
+        const typeInfo = {
+            fundValueCalculator,
+            dispatcher,
+        };
         if (type === tokenType.enzyme) {
-            return {
-                type: type,
-                calls: [
-                    {
-                        allowFailure: true,
-                        callData: enzymeInterface.encodeFunctionData("calcNetShareValue", [targetToken]),
-                        target: fundValueCalculator,
-                    },
-                ],
-                typeInfo: {
-                    name: name,
-                    tokenAddress: targetToken,
-                    factory: dispatcher,
-                },
-            };
+            return generateResult(type, name, targetToken, typeInfo);
         }
     }
     catch (e) {
         // No factory on this token
     }
+}
+function parseForMetamorpho(calls, index, targetToken) {
     // MetaMorpho check
     try {
-        metamorphoInterface.decodeFunctionResult("MORPHO", calls[index + 1].returnData)[0];
-        const name = ERC20Interface.decodeFunctionResult("name", calls[index + 2].returnData)[0];
-        return {
-            type: tokenType.metamorpho,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: metamorphoInterface.encodeFunctionData("asset"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
+        decodeCall(calls, index + 1, "MORPHO");
+        const name = decodeCall(calls, index + 2, "name");
+        return generateResult(tokenType.metamorpho, name, targetToken, {});
     }
     catch (e) {
         // Not a metamorpho token
     }
-    let name;
-    try {
-        name = ERC20Interface.decodeFunctionResult("name", calls[index + 2].returnData)[0];
-    }
-    catch (e) {
-        return {
-            type: tokenType.unknown,
-            calls: [],
-            typeInfo: {
-                name: "Unknown",
-                tokenAddress: targetToken,
-            },
-        };
-    }
+}
+function parseForBalancer(calls, index, targetToken, name) {
     // Check for balancer pools
     try {
-        const poolId = balancerPoolInterface.decodeFunctionResult("getPoolId", calls[index + 3].returnData)[0];
-        return {
-            type: tokenType.balancerPool,
-            calls: [],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
+        decodeCall(calls, index + 3, "getPoolId");
+        return generateResult(tokenType.balancerPool, name, targetToken, {});
     }
     catch (e) {
         // Not a balancer pool
     }
-    // https://arbiscan.io/address/0xc5a583c532c519196cc2bea060f387780aecc61f
-    if (name.toLowerCase().includes("aura deposit vault")) {
-        return {
-            type: tokenType.aura,
-            calls: [
-                // Asset is the balancer pool lp token (not the gauge token)
-                {
-                    allowFailure: true,
-                    callData: auraInterface.encodeFunctionData("asset"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: auraInterface.encodeFunctionData("operator"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: auraInterface.encodeFunctionData("pid"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://etherscan.io/address/0xb0ac070ae1f9BC564c1F4EA23bD2Ed0aF1B6BA5A#readContract
-    if (name.toLowerCase().includes("poolside")) {
-        return {
-            type: tokenType.poolside,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://arbiscan.io/address/0xe882f63f74e5966c9d2424b745ad6655d24d1336#readContract
-    if (name.toLowerCase().includes("balancer") && !name.toLowerCase().includes("aura deposit vault")) {
-        // For balancer pools we need to fetch the gyroscope pool address by calling the lp_token function
-        return {
-            type: tokenType.balancerGauge,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: balancerGaugeInterface.encodeFunctionData("lp_token"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://etherscan.io/address/0x9ef444a6d7f4a5adcd68fd5329aa5240c90e14d2#readContract
-    if (name.toLowerCase().includes("farming of")) {
-        // 1inch reward staking contract
-        return {
-            type: tokenType.gearbox,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: OneInchStakingInterface.encodeFunctionData("stakingToken"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://etherscan.io/address/0xb0050BF47733b7B426b355C358C4700Aa7Ea473A#readContract
-    if (name.toLowerCase().includes("evk vault")) {
-        if (name.toLowerCase().startsWith("debt token of evk vault")) {
-            return {
-                type: tokenType.euler_borrow,
-                calls: [
-                    {
-                        allowFailure: true,
-                        callData: eulerInterface.encodeFunctionData("eVault"),
-                        target: targetToken,
-                    },
-                ],
-                typeInfo: {
-                    name: name,
-                    tokenAddress: targetToken,
-                },
-            };
-        }
-        return {
-            type: tokenType.euler_lend,
-            calls: [],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://etherscan.io/address/0x9fb7b4477576fe5b32be4c1843afb1e55f251b33
-    if (name.toLowerCase().startsWith("fluid") || name.toLowerCase().startsWith("filament")) {
-        let protocol = "Fluid";
-        if (name.toLowerCase().startsWith("filament")) {
-            protocol = "Filament";
-        }
-        return {
-            type: tokenType.fluid,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: fluidInterface.encodeFunctionData("asset"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-                protocol: protocol,
-            },
-        };
-    }
-    // https://arbiscan.io/address/0x9c4ec768c28520b50860ea7a15bd7213a9ff58bf#readProxyContract
-    if (name.toLowerCase().includes("compound")) {
-        return {
-            type: tokenType.compound,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: compoundInterface.encodeFunctionData("baseToken"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://arbiscan.io/address/0xb11A56DA177c5532D5E29cC8363d145bD0822c81#readProxyContract
-    if (name.toLowerCase().includes("radiant interest")) {
-        return {
-            type: tokenType.radiant_lend,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: radiantInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: radiantInterface.encodeFunctionData("getAssetPrice"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://arbiscan.io/address/0x2D7d510Dc21F5384C9efd30811D0366F8b4269DF#readProxyContract
-    if (name.toLowerCase().includes("radiant variable debt")) {
-        return {
-            type: tokenType.radiant_borrow,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: radiantInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: radiantInterface.encodeFunctionData("getAssetPrice"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://explorer.mode.network/address/0x71ef7EDa2Be775E5A7aa8afD02C45F059833e9d2
-    if (name.toLowerCase().includes("ionic")) {
-        return {
-            type: tokenType.ionic,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: ionicInterface.encodeFunctionData("underlying"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: ionicInterface.encodeFunctionData("exchangeRateCurrent"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://explorer.mode.network/address/0xe855B8018C22A05F84724e93693caf166912aDD5?tab=read_contract
-    if (name.toLowerCase().includes("layerbank")) {
-        return {
-            type: tokenType.layerbank,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: layerBankInterface.encodeFunctionData("underlying"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: layerBankInterface.encodeFunctionData("exchangeRate"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://basescan.org/address/0xedc817a28e8b93b03976fbd4a3ddbc9f7d176c22#readContract
-    if (name.toLowerCase().includes("moonwell")) {
-        return {
-            type: tokenType.moonwell,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: moonwellInterface.encodeFunctionData("underlying"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: moonwellInterface.encodeFunctionData("exchangeRateStored"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // https://basescan.org/address/0x4e65fe4dba92790696d040ac24aa414708f5c0ab#readProxyContract
-    if (name.toLowerCase().includes("aave") ||
-        name.toLowerCase().startsWith("yei") ||
-        (name.toLowerCase().startsWith("ironclad") && name.toLowerCase() !== "ironclad token") ||
-        name.toLowerCase().includes("zerolend")) {
-        let type = tokenType.aave_lending;
-        if (name.toLowerCase().includes("debt")) {
-            type = tokenType.aave_borrowing;
-        }
-        let protocol = "Aave";
-        if (name.toLowerCase().includes("yei")) {
-            protocol = "Yei Finance";
-        }
-        else if (name.toLowerCase().includes("ironclad") && name.toLowerCase() !== "ironclad token") {
-            protocol = "Ironclad";
-        }
-        else if (name.toLowerCase().includes("zerolend")) {
-            protocol = "ZeroLend";
-        }
-        return {
-            type: type,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: aaveInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-                protocol: protocol,
-            },
-        };
-    }
-    // https://fraxscan.com/address/0x4f968317721b9c300afbff3fd37365637318271d#readContract
-    if (name.toLowerCase().includes("fraxlend interest bearing") ||
-        name.toLowerCase().includes("aggregator") ||
-        name.toLowerCase().includes("sturdy interest bearing")) {
-        let type = tokenType.fraxlend;
-        if (name.toLowerCase().includes("aggregator")) {
-            type = tokenType.sturdy_aggregator;
-        }
-        else if (name.toLowerCase().includes("sturdy interest bearing")) {
-            type = tokenType.sturdy_silo;
-        }
-        const calls = [
-            {
-                allowFailure: true,
-                callData: fraxlendInterface.encodeFunctionData("asset"),
-                target: targetToken,
-            },
-            {
-                allowFailure: true,
-                callData: fraxlendInterface.encodeFunctionData("pricePerShare"),
-                target: targetToken,
-            },
-        ];
-        if (type === tokenType.sturdy_silo) {
-            calls.push({
-                allowFailure: true,
-                callData: sturdyInterface.encodeFunctionData("collateralContract"),
-                target: targetToken,
-            });
-        }
-        return {
-            type: type,
-            calls: calls,
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
-    }
-    // Doing these last because Ra is hard to categorize
-    if (name.toLowerCase().includes("uniswap") ||
-        name.toLowerCase().includes("stablev1 amm") ||
-        name.toLowerCase().includes("volatile pair -") ||
-        name.toLowerCase().includes("correlated pair -") ||
-        name.toLowerCase().includes("syncswap")) {
-        let protocol = "Uniswap V2";
-        if (name.toLowerCase().includes("stablev1 amm")) {
-            protocol = "Fenix V2";
-        }
-        else if (name.toLowerCase().includes("volatile pair -") || name.toLowerCase().includes("correlated pair -")) {
-            protocol = "Ra";
-        }
-        else if (name.toLowerCase().includes("syncswap")) {
-            protocol = "SyncSwap";
+}
+function parseForStaking(campaign, calls, index, targetToken) {
+    try {
+        const whitelist = campaign.campaignParameters.whitelist;
+        if (whitelist.length === 1) {
+            const forwarders = campaign.campaignParameters.forwarders;
+            if (forwarders.length === 1) {
+                if (forwarders[0].sender === whitelist[0]) {
+                    const name = decodeCall(calls, index + 2, "name");
+                    return generateResult(tokenType.staking, name, targetToken, { stakingContract: whitelist[0] });
+                }
+            }
         }
-        return {
-            type: tokenType.uniswapv2,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: UniswapV2PoolInterface.encodeFunctionData("token0"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: UniswapV2PoolInterface.encodeFunctionData("token1"),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-                protocol: protocol,
-            },
-        };
-    }
-    // Duo pool on Curve Fraxtal which has no factory
-    // https://fraxscan.com/address/0x63eb7846642630456707c3efbb50a03c79b89d81#readContract
-    if (name.toLowerCase() === "crvusd/frax" ||
-        name.toLowerCase() === "ezeth/wfrxeth" ||
-        name.toLowerCase() === "pufeth/wsteth") {
-        return {
-            type: tokenType.curve_2,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: curveInterface.encodeFunctionData("get_virtual_price"),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: curveInterface.encodeFunctionData("coins", [0]),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: curveInterface.encodeFunctionData("coins", [1]),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: curveInterface.encodeFunctionData("coins", [2]),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
     }
-    if (name.toLowerCase() === "isei") {
-        return {
-            type: tokenType.silostaking,
-            calls: [],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-                symbolUnderlyingToken: "SEI",
-            },
-        };
+    catch (e) {
+        // No factory on this token
+        // console.log(e);
     }
-    if (name.toLowerCase().startsWith("moo velo")) {
-        return {
-            type: tokenType.beefy,
-            calls: [
-                {
-                    allowFailure: true,
-                    callData: beefyInterface.encodeFunctionData("getPricePerFullShare", []),
-                    target: targetToken,
-                },
-                {
-                    allowFailure: true,
-                    callData: beefyInterface.encodeFunctionData("want", []),
-                    target: targetToken,
-                },
-            ],
-            typeInfo: {
-                name: name,
-                tokenAddress: targetToken,
-            },
-        };
+}
+export function getTokenTypeRound1(calls, targetToken, index, campaign) {
+    const returnValueOfCalls = calls.map(call => call.returnData);
+    let result = parseForFactory(returnValueOfCalls, index, targetToken);
+    if (result)
+        return result;
+    result = parseForEnzyme(returnValueOfCalls, index, targetToken);
+    if (result)
+        return result;
+    result = parseForMetamorpho(returnValueOfCalls, index, targetToken);
+    if (result)
+        return result;
+    result = parseForStaking(campaign, returnValueOfCalls, index, targetToken);
+    if (result)
+        return result;
+    let name;
+    try {
+        name = decodeCall(returnValueOfCalls, index + 2, "name");
     }
-    return {
-        type: tokenType.unknown,
-        calls: [],
-        typeInfo: {
-            name: name,
-            tokenAddress: targetToken,
-        },
-    };
+    catch (e) {
+        return generateResult(tokenType.unknown, "Unknown", targetToken, {});
+    }
+    result = parseForBalancer(returnValueOfCalls, index, targetToken, name);
+    if (result)
+        return result;
+    // Order matters
+    const ordered_token_Type = Object.values(tokenType).filter(value => typeof value === "string");
+    result = processNamingConditionsInOrder(ordered_token_Type, name, targetToken);
+    if (result)
+        return result;
+    return generateResult(tokenType.unknown, name, targetToken, {});
 }