@merkl/api 0.9.15

package/dist/src/engine/erc20SubTypeProcessors/helpers/getBlacklistedSupply.d.ts

@@ -0,0 +1,2 @@
+export declare function getBlacklistedSupply(index: number, decimals: number, blacklist: string[], calls: string[]): number;
+export declare function getWhitelistedSupply(index: number, decimals: number, blacklist: string[], whitelist: string[], calls: string[]): number;

package/dist/src/engine/erc20SubTypeProcessors/helpers/getBlacklistedSupply.js

@@ -0,0 +1,22 @@
+import { BN2Number, ERC20Interface } from "@sdk";
+export function getBlacklistedSupply(index, decimals, blacklist, calls) {
+    if (blacklist.length === 0) {
+        return 0;
+    }
+    let blacklistedSupply = 0;
+    for (const _ of blacklist) {
+        blacklistedSupply += BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", calls[index++])[0], decimals);
+    }
+    return blacklistedSupply;
+}
+export function getWhitelistedSupply(index, decimals, blacklist, whitelist, calls) {
+    if (whitelist.length === 0) {
+        return 0;
+    }
+    let start = index + blacklist.length;
+    let whitelistedSupply = 0;
+    for (const _ of whitelist) {
+        whitelistedSupply += BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", calls[start++])[0], decimals);
+    }
+    return whitelistedSupply;
+}

package/dist/src/engine/erc20SubTypeProcessors/helpers/hardcoded.d.ts

@@ -0,0 +1,3 @@
+import { ChainId } from "@sdk";
+import { tokenType } from "./tokenType";
+export declare function getTypeFromAddressChain(chain: ChainId, token: string): tokenType;

package/dist/src/engine/erc20SubTypeProcessors/helpers/hardcoded.js

@@ -0,0 +1,30 @@
+import { ChainId } from "@sdk";
+import { tokenType } from "./tokenType";
+const chainAddressToType = {
+    [ChainId.CORN]: {
+        "0xab3291b73a1087265e126e330cede0cfd4b8a693": tokenType.curveNPool,
+        "0xf024586aacaf91fc4f77468fa758df280b2c9cd4": tokenType.curveNPool,
+        "0x29c1b0baa9ac0182cf9f6ffceaf143f3ef3546a0": tokenType.curveNPool,
+        "0xebe423b5466f9675669b2a4521b6e9f852dd1f52": tokenType.curveNPool,
+        "0xb27d447cf1d211ca60676728ac28060ecfb90800": tokenType.curveNPool,
+    },
+    [ChainId.MAINNET]: {
+        "0x08c6F91e2B681FaF5e17227F2a44C307b3C1364C": tokenType.veda,
+        "0x5401b8620E5FB570064CA9114fd1e135fd77D57c": tokenType.veda,
+        "0xFE0C961A49E1aEe2AE2d842fE40157365C6d978f": tokenType.veda,
+        "0x42A03534DBe07077d705311854E3B6933dD6Af85": tokenType.veda,
+        "0x352180974C71f84a934953Cf49C4E538a6F9c997": tokenType.veda,
+        "0xeDa663610638E6557c27e2f4e973D3393e844E70": tokenType.veda,
+        "0xf0bb20865277aBd641a307eCe5Ee04E79073416C": tokenType.veda,
+        "0xFF94993fA7EA27Efc943645F95Adb36C1b81244b": tokenType.gearbox,
+    },
+    [ChainId.BOB]: {
+        "0x9998e05030Aee3Af9AD3df35A34F5C51e1628779": tokenType.veda,
+    },
+    [ChainId.ETHERLINK]: {
+        "0x79052Ab3C166D4899a1e0DD033aC3b379AF0B1fD": tokenType.xU308,
+    },
+};
+export function getTypeFromAddressChain(chain, token) {
+    return chainAddressToType?.[chain]?.[token] ?? tokenType.unknown;
+}

package/dist/src/engine/erc20SubTypeProcessors/helpers/metamorphoTvl.d.ts

@@ -0,0 +1 @@
+export declare function fetchMetamorphoTvl(chainId: number, vaultAddress: string): Promise<number>;

package/dist/src/engine/erc20SubTypeProcessors/helpers/metamorphoTvl.js

@@ -0,0 +1,35 @@
+export async function fetchMetamorphoTvl(chainId, vaultAddress) {
+    const metamorphoAPI = "https://blue-api.morpho.org/graphql";
+    const query = `
+        query {
+            vaultByAddress(
+                address: "${vaultAddress}"
+                chainId: ${chainId}
+            ) {
+                state {
+                    allocation {
+                        supplyAssetsUsd
+                    }
+                }
+            }
+        }
+    `;
+    const response = await fetch(metamorphoAPI, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ query }),
+    });
+    const data = await response.json();
+    let tvl = 0;
+    if (!data?.data) {
+        return tvl;
+    }
+    for (const allocation of data.data.vaultByAddress.state.allocation) {
+        if (allocation.supplyAssetsUsd) {
+            tvl += Number(allocation.supplyAssetsUsd);
+        }
+    }
+    return tvl;
+}

package/dist/src/engine/erc20SubTypeProcessors/helpers/ownerFinder.d.ts

@@ -0,0 +1,2 @@
+import { tokenType } from "./tokenType";
+export declare function getTypeFromOwnerAddress(address: string): tokenType;

package/dist/src/engine/erc20SubTypeProcessors/helpers/ownerFinder.js

@@ -0,0 +1,12 @@
+import { tokenType } from "./tokenType";
+const ownerAddresses = {
+    "0xbF7E49483881C76487b0989CD7d9A8239B20CA41": tokenType.curve_2,
+    "0x42a856dbEBB97AbC1269EAB32f3bb40C15102819": tokenType.satlayer,
+    "0x4C911bf7A008C497719CBEb1a376f1cEc9e2c1d6": tokenType.hanji_liquidity_vault_token,
+};
+export function getTypeFromOwnerAddress(address) {
+    if (ownerAddresses[address]) {
+        return ownerAddresses[address];
+    }
+    return tokenType.unknown;
+}

package/dist/src/engine/erc20SubTypeProcessors/helpers/spliceTVL.d.ts

@@ -0,0 +1,7 @@
+type SpliceInformation = {
+    symbolUnderlyingToken: string;
+    priceTargetToken: number;
+    tvl: number;
+};
+export declare function fetchSpliceInformation(marketAddress: string): Promise<SpliceInformation>;
+export {};

package/dist/src/engine/erc20SubTypeProcessors/helpers/spliceTVL.js

@@ -0,0 +1,21 @@
+// https://splice-api-ad64cd01a25d.herokuapp.com/mode/markets?market=0x34cf9BF641bd5f34197060A3f3478a1f97f78f0a
+import axios from "axios";
+export async function fetchSpliceInformation(marketAddress) {
+    const url = `https://splice-api-ad64cd01a25d.herokuapp.com/mode/markets?market=${marketAddress}`;
+    try {
+        const response = await axios.get(url);
+        const market = response.data?.markets[0];
+        return {
+            symbolUnderlyingToken: market.token.symbol,
+            priceTargetToken: market.pool.price,
+            tvl: market.pool.tvl,
+        };
+    }
+    catch (e) {
+        return {
+            symbolUnderlyingToken: "",
+            priceTargetToken: 0,
+            tvl: 1,
+        };
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/helpers/tokenType.d.ts

@@ -0,0 +1,107 @@
+import { OpportunityAction } from "@db/api";
+import type { CallDto } from "@sdk";
+export declare enum tokenType {
+    aura = "aura",
+    anglesLiquid = "anglesLiquid",
+    poolside = "poolside",
+    balancerGauge = "balancerGauge",
+    gearbox = "gearbox",
+    euler_borrow = "euler_borrow",
+    euler_lend = "euler_lend",
+    filament = "filament",
+    fluid = "fluid",
+    compound = "compound",
+    radiant_lend = "radiant_lend",
+    radiant_borrow = "radiant_borrow",
+    ionic = "ionic",
+    layerbank = "layerbank",
+    moonwell = "moonwell",
+    yei_borrowing = "yei_borrowing",
+    ironclad_borrowing = "ironclad_borrowing",
+    zerolend_borrowing = "zerolend_borrowing",
+    yei_lending = "yei_lending",
+    ironclad_lending = "ironclad_lending",
+    zerolend_lending = "zerolend_lending",
+    aave_borrowing = "aave_borrowing",
+    aave_lending = "aave_lending",
+    sturdy_aggregator = "sturdy_aggregator",
+    sturdy_silo = "sturdy_silo",
+    fraxlend = "fraxlend",
+    uniswapv2 = "uniswapv2",
+    fenix = "fenix",
+    ra = "ra",
+    syncswap = "syncswap",
+    curve_2 = "curve_2",
+    silostaking = "silostaking",
+    beefy = "beefy",
+    balancerPool = "balancerPool",
+    unknown = "unknown",
+    metamorpho = "metamorpho",
+    aerodrome = "aerodrome",
+    velodrome = "velodrome",
+    curve = "curve",
+    splice = "splice",// todo
+    toros = "toros",// todo
+    akron = "akron",
+    enzyme = "enzyme",
+    dragonswap = "dragonswap",
+    koi = "koi",
+    baseswap = "baseswap",
+    zkswap = "zkswap",
+    ironcladStaking = "ironcladStaking",
+    rfx_slv = "rfx_slv",
+    rfx = "rfx",
+    woofi = "woofi",
+    pendle = "pendle",
+    maverickBoostedPosition = "maverickBoostedPosition",
+    zkSwapThreePool = "zkSwapThreePool",
+    maha = "maha",
+    tempest = "tempest",
+    pendleYT = "pendleYT",
+    pancakeswap = "pancakeswap",
+    tempestStaking = "tempestStaking",
+    holdstation = "holdstation",
+    noLinkVault = "noLinkVault",
+    cpmmGamma = "cpmmGamma",
+    crosscurve = "crosscurve",
+    venus = "venus",
+    reactor_fusion = "reactor_fusion",
+    vicuna = "vicuna",
+    traderJoe = "traderJoe",
+    curveNPool = "curveNPool",
+    avalon_borrowing = "avalon_borrowing",
+    avalon_lending = "avalon_lending",
+    satlayer = "satlayer",
+    veda = "veda",
+    superlend_borrowing = "superlend_borrowing",
+    superlend_lending = "superlend_lending",
+    cian = "cian",
+    concrete = "concrete",
+    lendle_borrowing = "lendle_borrowing",
+    lendle_lending = "lendle_lending",
+    takotako_borrowing = "takotako_borrowing",
+    takotako_lending = "takotako_lending",
+    equalizer_gauge = "equalizer_gauge",
+    vicuna_lending = "vicuna_lending",
+    vicuna_borrowing = "vicuna_borrowing",
+    spectra_lpt = "spectra_lpt",
+    spectra_yt = "spectra_yt",
+    hourglass = "hourglass",
+    katana = "katana",
+    balancerV3 = "balancerV3",
+    hanji_liquidity_vault_token = "hanji_liquidity_vault_token",
+    xU308 = "xU308",
+    bunniV2 = "bunniV2",
+    beratrax_vault = "beratrax_vault",
+    beraborrow_gauge = "beraborrow_gauge"
+}
+export declare const tokenTypeToProtocol: {
+    [key in tokenType]: {
+        [key: string]: string | OpportunityAction;
+    };
+};
+export type tokenTypeStruct = {
+    type: tokenType;
+    calls: CallDto[];
+    typeInfo: any;
+};

package/dist/src/engine/erc20SubTypeProcessors/helpers/tokenType.js

@@ -0,0 +1,193 @@
+import { OpportunityAction } from "@db/api";
+// This enum's order is important, do not change it unless you know what you are doing
+export var tokenType;
+(function (tokenType) {
+    tokenType["aura"] = "aura";
+    tokenType["anglesLiquid"] = "anglesLiquid";
+    tokenType["poolside"] = "poolside";
+    tokenType["balancerGauge"] = "balancerGauge";
+    tokenType["gearbox"] = "gearbox";
+    tokenType["euler_borrow"] = "euler_borrow";
+    tokenType["euler_lend"] = "euler_lend";
+    tokenType["filament"] = "filament";
+    tokenType["fluid"] = "fluid";
+    tokenType["compound"] = "compound";
+    tokenType["radiant_lend"] = "radiant_lend";
+    tokenType["radiant_borrow"] = "radiant_borrow";
+    tokenType["ionic"] = "ionic";
+    tokenType["layerbank"] = "layerbank";
+    tokenType["moonwell"] = "moonwell";
+    tokenType["yei_borrowing"] = "yei_borrowing";
+    tokenType["ironclad_borrowing"] = "ironclad_borrowing";
+    tokenType["zerolend_borrowing"] = "zerolend_borrowing";
+    tokenType["yei_lending"] = "yei_lending";
+    tokenType["ironclad_lending"] = "ironclad_lending";
+    tokenType["zerolend_lending"] = "zerolend_lending";
+    tokenType["aave_borrowing"] = "aave_borrowing";
+    tokenType["aave_lending"] = "aave_lending";
+    tokenType["sturdy_aggregator"] = "sturdy_aggregator";
+    tokenType["sturdy_silo"] = "sturdy_silo";
+    tokenType["fraxlend"] = "fraxlend";
+    tokenType["uniswapv2"] = "uniswapv2";
+    tokenType["fenix"] = "fenix";
+    tokenType["ra"] = "ra";
+    tokenType["syncswap"] = "syncswap";
+    tokenType["curve_2"] = "curve_2";
+    tokenType["silostaking"] = "silostaking";
+    tokenType["beefy"] = "beefy";
+    tokenType["balancerPool"] = "balancerPool";
+    tokenType["unknown"] = "unknown";
+    tokenType["metamorpho"] = "metamorpho";
+    tokenType["aerodrome"] = "aerodrome";
+    tokenType["velodrome"] = "velodrome";
+    tokenType["curve"] = "curve";
+    tokenType["splice"] = "splice";
+    tokenType["toros"] = "toros";
+    tokenType["akron"] = "akron";
+    tokenType["enzyme"] = "enzyme";
+    tokenType["dragonswap"] = "dragonswap";
+    tokenType["koi"] = "koi";
+    tokenType["baseswap"] = "baseswap";
+    tokenType["zkswap"] = "zkswap";
+    tokenType["ironcladStaking"] = "ironcladStaking";
+    tokenType["rfx_slv"] = "rfx_slv";
+    tokenType["rfx"] = "rfx";
+    tokenType["woofi"] = "woofi";
+    tokenType["pendle"] = "pendle";
+    tokenType["maverickBoostedPosition"] = "maverickBoostedPosition";
+    tokenType["zkSwapThreePool"] = "zkSwapThreePool";
+    tokenType["maha"] = "maha";
+    tokenType["tempest"] = "tempest";
+    tokenType["pendleYT"] = "pendleYT";
+    tokenType["pancakeswap"] = "pancakeswap";
+    tokenType["tempestStaking"] = "tempestStaking";
+    tokenType["holdstation"] = "holdstation";
+    tokenType["noLinkVault"] = "noLinkVault";
+    tokenType["cpmmGamma"] = "cpmmGamma";
+    tokenType["crosscurve"] = "crosscurve";
+    tokenType["venus"] = "venus";
+    tokenType["reactor_fusion"] = "reactor_fusion";
+    tokenType["vicuna"] = "vicuna";
+    tokenType["traderJoe"] = "traderJoe";
+    tokenType["curveNPool"] = "curveNPool";
+    tokenType["avalon_borrowing"] = "avalon_borrowing";
+    tokenType["avalon_lending"] = "avalon_lending";
+    tokenType["satlayer"] = "satlayer";
+    tokenType["veda"] = "veda";
+    tokenType["superlend_borrowing"] = "superlend_borrowing";
+    tokenType["superlend_lending"] = "superlend_lending";
+    tokenType["cian"] = "cian";
+    tokenType["concrete"] = "concrete";
+    tokenType["lendle_borrowing"] = "lendle_borrowing";
+    tokenType["lendle_lending"] = "lendle_lending";
+    tokenType["takotako_borrowing"] = "takotako_borrowing";
+    tokenType["takotako_lending"] = "takotako_lending";
+    tokenType["equalizer_gauge"] = "equalizer_gauge";
+    tokenType["vicuna_lending"] = "vicuna_lending";
+    tokenType["vicuna_borrowing"] = "vicuna_borrowing";
+    tokenType["spectra_lpt"] = "spectra_lpt";
+    tokenType["spectra_yt"] = "spectra_yt";
+    tokenType["hourglass"] = "hourglass";
+    tokenType["katana"] = "katana";
+    tokenType["balancerV3"] = "balancerV3";
+    tokenType["hanji_liquidity_vault_token"] = "hanji_liquidity_vault_token";
+    tokenType["xU308"] = "xU308";
+    tokenType["bunniV2"] = "bunniV2";
+    tokenType["beratrax_vault"] = "beratrax_vault";
+    tokenType["beraborrow_gauge"] = "beraborrow_gauge";
+})(tokenType || (tokenType = {}));
+export const tokenTypeToProtocol = {
+    [tokenType.aave_borrowing]: { protocol: "Aave", action: OpportunityAction.BORROW },
+    [tokenType.anglesLiquid]: { protocol: "Angles", action: OpportunityAction.LEND },
+    [tokenType.aave_lending]: { protocol: "Aave", action: OpportunityAction.LEND },
+    [tokenType.aerodrome]: { protocol: "Aerodrome", action: OpportunityAction.POOL },
+    [tokenType.akron]: { protocol: "Akron", action: OpportunityAction.POOL },
+    [tokenType.aura]: { protocol: "Aura", action: OpportunityAction.POOL },
+    [tokenType.balancerGauge]: { protocol: "Balancer Gauge", action: OpportunityAction.POOL },
+    [tokenType.balancerPool]: { protocol: "Balancer", action: OpportunityAction.POOL },
+    [tokenType.baseswap]: { protocol: "Baseswap", action: OpportunityAction.HOLD },
+    [tokenType.beefy]: { protocol: "Moo Velodrome", action: OpportunityAction.POOL },
+    [tokenType.compound]: { protocol: "Compound", action: OpportunityAction.LEND },
+    [tokenType.curve]: { protocol: "Curve", action: OpportunityAction.POOL },
+    [tokenType.curve_2]: { protocol: "Curve", action: OpportunityAction.POOL },
+    [tokenType.dragonswap]: { protocol: "Dragonswap", action: OpportunityAction.POOL },
+    [tokenType.enzyme]: { protocol: "Enzyme", action: OpportunityAction.HOLD },
+    [tokenType.euler_borrow]: { protocol: "Euler", action: OpportunityAction.BORROW },
+    [tokenType.euler_lend]: { protocol: "Euler", action: OpportunityAction.LEND },
+    [tokenType.fenix]: { protocol: "Fenix", action: OpportunityAction.HOLD },
+    [tokenType.filament]: { protocol: "Filament", action: OpportunityAction.HOLD },
+    [tokenType.fluid]: { protocol: "Fluid", action: OpportunityAction.LEND },
+    [tokenType.fraxlend]: { protocol: "Fraxlend", action: OpportunityAction.LEND },
+    [tokenType.gearbox]: { protocol: "Gearbox", action: OpportunityAction.LEND },
+    [tokenType.ionic]: { protocol: "Ionic", action: OpportunityAction.LEND },
+    [tokenType.ironclad_borrowing]: { protocol: "Ironclad", action: OpportunityAction.HOLD },
+    [tokenType.ironclad_lending]: { protocol: "Ironclad", action: OpportunityAction.HOLD },
+    [tokenType.koi]: { protocol: "Koi", action: OpportunityAction.POOL },
+    [tokenType.layerbank]: { protocol: "Layerbank", action: OpportunityAction.LEND },
+    [tokenType.metamorpho]: { protocol: "Metamorpho", action: OpportunityAction.HOLD },
+    [tokenType.moonwell]: { protocol: "Moonwell", action: OpportunityAction.LEND },
+    [tokenType.pendle]: { protocol: "Pendle", action: OpportunityAction.HOLD },
+    [tokenType.poolside]: { protocol: "Poolside", action: OpportunityAction.POOL },
+    [tokenType.ra]: { protocol: "Ra", action: OpportunityAction.HOLD },
+    [tokenType.radiant_borrow]: { protocol: "Radiant", action: OpportunityAction.BORROW },
+    [tokenType.radiant_lend]: { protocol: "Radiant", action: OpportunityAction.LEND },
+    [tokenType.reactor_fusion]: { protocol: "Reactor Fusion", action: OpportunityAction.LEND },
+    [tokenType.silostaking]: { protocol: "Silo Staking", action: OpportunityAction.LEND },
+    [tokenType.splice]: { protocol: "Splice", action: OpportunityAction.HOLD },
+    [tokenType.sturdy_aggregator]: { protocol: "Sturdy", action: OpportunityAction.LEND },
+    [tokenType.sturdy_silo]: { protocol: "Sturdy", action: OpportunityAction.LEND },
+    [tokenType.syncswap]: { protocol: "SyncSwap", action: OpportunityAction.POOL },
+    [tokenType.toros]: { protocol: "Toros", action: OpportunityAction.HOLD },
+    [tokenType.uniswapv2]: { protocol: "Uniswap", action: OpportunityAction.POOL },
+    [tokenType.velodrome]: { protocol: "Velodrome", action: OpportunityAction.POOL },
+    [tokenType.venus]: { protocol: "Venus", action: OpportunityAction.LEND },
+    [tokenType.unknown]: { protocol: "Unknown", action: OpportunityAction.HOLD },
+    [tokenType.yei_borrowing]: { protocol: "Yei Finance", action: OpportunityAction.HOLD },
+    [tokenType.yei_lending]: { protocol: "Yei Finance", action: OpportunityAction.HOLD },
+    [tokenType.zerolend_borrowing]: { protocol: "ZeroLend", action: OpportunityAction.BORROW },
+    [tokenType.zerolend_lending]: { protocol: "ZeroLend", action: OpportunityAction.LEND },
+    [tokenType.zkswap]: { protocol: "ZKSwap", action: OpportunityAction.POOL },
+    [tokenType.rfx]: { protocol: "RFX", action: OpportunityAction.POOL },
+    [tokenType.woofi]: { protocol: "Woofi", action: OpportunityAction.LEND },
+    [tokenType.ironcladStaking]: { protocol: "Ironclad", action: OpportunityAction.HOLD },
+    [tokenType.maverickBoostedPosition]: { protocol: "Maverick", action: OpportunityAction.POOL },
+    [tokenType.zkSwapThreePool]: { protocol: "ZKSwap", action: OpportunityAction.POOL },
+    [tokenType.maha]: { protocol: "Maha", action: OpportunityAction.HOLD },
+    [tokenType.tempest]: { protocol: "Tempest", action: OpportunityAction.POOL },
+    [tokenType.pendleYT]: { protocol: "Pendle", action: OpportunityAction.HOLD },
+    [tokenType.pancakeswap]: { protocol: "PancakeSwap", action: OpportunityAction.POOL },
+    [tokenType.tempestStaking]: { protocol: "Tempest", action: OpportunityAction.HOLD },
+    [tokenType.holdstation]: { protocol: "HoldStation", action: OpportunityAction.HOLD },
+    [tokenType.noLinkVault]: { protocol: "NoLinkVault", action: OpportunityAction.HOLD },
+    [tokenType.cpmmGamma]: { protocol: "GammaSwap", action: OpportunityAction.POOL },
+    [tokenType.crosscurve]: { protocol: "CrossCurve", action: OpportunityAction.POOL },
+    [tokenType.curveNPool]: { protocol: "Curve", action: OpportunityAction.POOL },
+    [tokenType.vicuna]: { protocol: "Vicuna", action: OpportunityAction.POOL },
+    [tokenType.traderJoe]: { protocol: "Trader Joe", action: OpportunityAction.HOLD },
+    [tokenType.avalon_lending]: { protocol: "Avalon", action: OpportunityAction.HOLD },
+    [tokenType.avalon_borrowing]: { protocol: "Avalon", action: OpportunityAction.HOLD },
+    [tokenType.satlayer]: { protocol: "Satlayer", action: OpportunityAction.HOLD },
+    [tokenType.veda]: { protocol: "Veda", action: OpportunityAction.HOLD },
+    [tokenType.superlend_borrowing]: { protocol: "Superlend", action: OpportunityAction.BORROW },
+    [tokenType.superlend_lending]: { protocol: "Superlend", action: OpportunityAction.LEND },
+    [tokenType.cian]: { protocol: "Cian", action: OpportunityAction.HOLD },
+    [tokenType.concrete]: { protocol: "Concrete", action: OpportunityAction.HOLD },
+    [tokenType.lendle_borrowing]: { protocol: "Lendle", action: OpportunityAction.BORROW },
+    [tokenType.lendle_lending]: { protocol: "Lendle", action: OpportunityAction.LEND },
+    [tokenType.takotako_borrowing]: { protocol: "TakoTako", action: OpportunityAction.BORROW },
+    [tokenType.takotako_lending]: { protocol: "TakoTako", action: OpportunityAction.LEND },
+    [tokenType.equalizer_gauge]: { protocol: "Equalizer", action: OpportunityAction.HOLD },
+    [tokenType.vicuna_lending]: { protocol: "Vicuna", action: OpportunityAction.LEND },
+    [tokenType.vicuna_borrowing]: { protocol: "Vicuna", action: OpportunityAction.BORROW },
+    [tokenType.spectra_lpt]: { protocol: "Spectra", action: OpportunityAction.POOL },
+    [tokenType.spectra_yt]: { protocol: "Spectra", action: OpportunityAction.POOL },
+    [tokenType.rfx_slv]: { protocol: "RFX", action: OpportunityAction.POOL },
+    [tokenType.hourglass]: { protocol: "Hourglass", action: OpportunityAction.HOLD },
+    [tokenType.katana]: { protocol: "Katana", action: OpportunityAction.POOL },
+    [tokenType.balancerV3]: { protocol: "Balancer", action: OpportunityAction.POOL },
+    [tokenType.hanji_liquidity_vault_token]: { protocol: "Hanji", action: OpportunityAction.POOL },
+    [tokenType.xU308]: { protocol: "Uranium", action: OpportunityAction.HOLD },
+    [tokenType.bunniV2]: { protocol: "Bunni V2", action: OpportunityAction.HOLD },
+    [tokenType.beratrax_vault]: { protocol: "Beratrax", action: OpportunityAction.POOL },
+    [tokenType.beraborrow_gauge]: { protocol: "Beraborrow", action: OpportunityAction.POOL },
+};

package/dist/src/engine/erc20SubTypeProcessors/implementations/AaveProcessor.d.ts

@@ -0,0 +1,30 @@
+import type { Pricer } from "@/utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawAave;
+    call: string;
+    target: keyof callKeysAave;
+    metaData?: keyof callKeysAave;
+};
+export type callKeysAave = mandatoryCallKeys & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawAave = callKeysAave & {};
+type dataTypeAave = dataType & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+    priceTargetToken: number;
+};
+export declare class AaveProcessor extends GenericProcessor<callKeysAave, dataRawAave, dataTypeAave> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawAave, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAave>;
+}
+export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/AaveProcessor.js

@@ -0,0 +1,25 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { GenericProcessor } from "../GenericProcessor";
+export class AaveProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],
+        round2: [{ key: "symbolUnderlyingToken", call: "symbol", target: "underlying" }],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // // override computeRound1(): void {}
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceTargetToken = (await pricer.get({ symbol: typeInfo.symbolUnderlyingToken })) ?? 0;
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            whitelistedSupplyTargetToken,
+            tvl: tvl,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+            blacklistedSupply,
+            totalSupply,
+        };
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/implementations/AnglesLiquid.d.ts

@@ -0,0 +1,35 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawAnglesLiquid;
+    call: string;
+    target: keyof callKeysAnglesLiquid;
+    metaData?: keyof callKeysAnglesLiquid;
+};
+type callKeysAnglesLiquid = mandatoryCallKeys & {
+    poolToken: string;
+    totalAssets: string;
+};
+type dataRawAnglesLiquid = callKeysAnglesLiquid & {};
+type dataTypeAnglesLiquid = dataType & {
+    poolToken: string;
+    totalAssets: string;
+    symbolUnderlyingToken: string;
+};
+export declare class AnglesLiquidProcessor extends GenericProcessor<callKeysAnglesLiquid, dataRawAnglesLiquid, dataTypeAnglesLiquid> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAnglesLiquid>;
+    computeRound1(type: tokenType, typeInfo: dataRawAnglesLiquid): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: dataRawAnglesLiquid, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+}
+export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/AnglesLiquid.js

@@ -0,0 +1,50 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class AnglesLiquidProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        round3: [],
+        round4: [
+            { key: "poolToken", call: "asset", target: "tokenAddress" },
+            { key: "totalAssets", call: "totalAssets", target: "tokenAddress" },
+            { key: "totalSupply", call: "totalSupply", target: "tokenAddress" },
+        ],
+    };
+    // override computeRound1(): void {}
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const priceUnderlying = (await pricer.get({ symbol: "S" })) ?? 0;
+        const tvl = priceUnderlying * BN2Number(typeInfo.totalAssets, 18);
+        const priceTargetToken = totalSupply ? tvl / totalSupply : 0;
+        const symbolUnderlyingToken = "S";
+        return {
+            ...typeInfo,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            totalSupply,
+            symbolUnderlyingToken,
+            totalAssets: typeInfo.totalAssets,
+            poolToken: typeInfo.poolToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+    computeRound1(type, typeInfo) {
+        return super.computeRound1(type, typeInfo);
+    }
+    computeRound2(index, type, typeInfo, calls) {
+        return super.computeRound2(index, type, typeInfo, calls);
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        return super.computeRound4(index, type, typeInfo, calls, campaign);
+    }
+    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
+        return super.computeRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/implementations/AssetProcessor.d.ts

@@ -0,0 +1,35 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawAsset;
+    call: string;
+    target: keyof callKeysAsset;
+    metaData?: keyof callKeysAsset;
+    optional?: boolean;
+};
+type callKeysAsset = mandatoryCallKeys & {
+    underlying: string;
+    exchangeRate: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+type dataRawAsset = callKeysAsset & {};
+type dataTypeAsset = dataType & {
+    underlying: string;
+    exchangeRate: number;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+export declare class AssetProcessor extends GenericProcessor<callKeysAsset, dataRawAsset, dataTypeAsset> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawAsset): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawAsset, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAsset>;
+}
+export {};