@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,1209 @@
+import { Interface } from "@ethersproject/abi";
+import { ERC20Interface, UniswapV2PoolInterface } from "@sdk";
+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) {
+    try {
+        const factory = factoryInterface.decodeFunctionResult("factory", calls[index].returnData)[0];
+        const name = ERC20Interface.decodeFunctionResult("name", calls[index + 2].returnData)[0];
+        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,
+                },
+            };
+        }
+    }
+    catch (e) {
+        // No factory on this token
+    }
+    // Enzyme check
+    try {
+        const dispatcher = enzymeInterface.decodeFunctionResult("getCreator", calls[index + 4].returnData)[0];
+        const name = ERC20Interface.decodeFunctionResult("name", calls[index + 2].returnData)[0];
+        const type = getTypeFromFactoryAddress(dispatcher);
+        const fundValueCalculator = enzymeFundValueCalculatorRouterMapping[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,
+                },
+            };
+        }
+    }
+    catch (e) {
+        // No factory on this token
+    }
+    // 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,
+            },
+        };
+    }
+    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,
+            },
+        };
+    }
+    // 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,
+            },
+        };
+    }
+    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";
+        }
+        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",
+            },
+        };
+    }
+    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,
+            },
+        };
+    }
+    return {
+        type: tokenType.unknown,
+        calls: [],
+        typeInfo: {
+            name: name,
+            tokenAddress: targetToken,
+        },
+    };
+}