@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,194 @@
+import { decodeCall } from "../../../../utils/decodeCalls";
+import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
+import { tokenType } from "./helpers/tokenType";
+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";
+        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");
+        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 = decodeCall(calls, index, "factory");
+        const name = decodeCall(calls, index + 2, "name");
+        const type = getTypeFromFactoryAddress(factory);
+        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 = 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 generateResult(type, name, targetToken, typeInfo);
+        }
+    }
+    catch (e) {
+        // No factory on this token
+    }
+}
+function parseForMetamorpho(calls, index, targetToken) {
+    // MetaMorpho check
+    try {
+        decodeCall(calls, index + 1, "MORPHO");
+        const name = decodeCall(calls, index + 2, "name");
+        return generateResult(tokenType.metamorpho, name, targetToken, {});
+    }
+    catch (e) {
+        // Not a metamorpho token
+    }
+}
+function parseForBalancer(calls, index, targetToken, name) {
+    // Check for balancer pools
+    try {
+        decodeCall(calls, index + 3, "getPoolId");
+        return generateResult(tokenType.balancerPool, name, targetToken, {});
+    }
+    catch (e) {
+        // Not a balancer pool
+    }
+}
+export function getTokenTypeRound1(calls, targetToken, index) {
+    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;
+    let name;
+    try {
+        name = decodeCall(returnValueOfCalls, index + 2, "name");
+    }
+    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, {});
+}