@merkl/api 0.21.47 → 1.0.0

package/dist/src/engine/deprecated/dynamicData/utils/getFixedApr.js

@@ -1,27 +0,0 @@
-// TODO: Enhance APR display for non-dollar denominations when front-end is ready.
-// This should handle cases where one or both token price are unavailable, showing the APR as a direct ratio
-// (e.g., X reward tokens per Y target tokens) instead of dollar values.
-export function getFixedApr(campaignParameters, priceRewardToken, priceTargetToken) {
-    const { targetTokenPricing, rewardTokenPricing, apr: fixedApr } = campaignParameters.campaignParameters;
-    const targetApr = Number(fixedApr);
-    // Handle all pricing configurations
-    if (targetTokenPricing && rewardTokenPricing) {
-        // Case 1: Fixed $ amount of reward per $ of liquidity
-        return targetApr * 100;
-    }
-    if (targetTokenPricing && !rewardTokenPricing) {
-        // Case 2: Fixed # amount of reward per $ of liquidity
-        // Return 0 if reward token price is invalid
-        return !priceRewardToken ? 0 : targetApr * priceRewardToken * 100;
-    }
-    if (!targetTokenPricing && rewardTokenPricing) {
-        // Case 3: Fixed $ amount of reward per # of liquidity
-        // Return 0 if target token price is invalid
-        return !priceTargetToken || priceTargetToken === 0 ? 0 : targetApr * (1 / priceTargetToken) * 100;
-    }
-    // Case 4: Fixed # amount of reward per # of liquidity
-    // Return 0 if either price is invalid
-    return !priceRewardToken || !priceTargetToken || priceTargetToken === 0
-        ? 0
-        : targetApr * (priceRewardToken / priceTargetToken) * 100;
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/GenericProcessor.js

@@ -1,335 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { decodeCall } from "@/utils/decodeCalls";
-import { createCall } from "@/utils/encodeCalls";
-import { generateCardName } from "@/utils/generateCardName";
-import { BN2Number } from "@sdk";
-import { tokenTypeToProtocolAndAction } from "./tokenTypeToProtocolAndAction";
-export var Round;
-(function (Round) {
-    Round["one"] = "round1";
-    Round["two"] = "round2";
-    Round["three"] = "round3";
-    Round["four"] = "round4";
-})(Round || (Round = {}));
-/**
- * Generic Processor to compute dynamic data of ERC20 tokens
- *
- * @params Input - Sets of value that will be passed from rounds to rounds in order to query the blockchain
- * @params DataRaw - Raw data output from the view function calls
- * @params Output - Final output of the processor
- */
-export class GenericProcessor {
-    rounds = {
-        round1: [],
-        round2: [],
-        round3: [],
-        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
-    };
-    stakingRounds = {
-        round1: [
-            { key: "lockNFT", call: "lockNFT", target: "stakingContract", optional: true },
-            { key: "eip712DomainName", call: "eip712DomainName", target: "stakingContract", optional: true },
-            { key: "stakingName", call: "name", target: "stakingContract", optional: true },
-            { key: "stakingSymbol", call: "symbol", target: "stakingContract", optional: true },
-        ],
-        round2: [{ key: "stakingSymbol", call: "symbol", target: "lockNFT", optional: true }],
-        round3: [],
-        round4: [],
-    };
-    debug = false;
-    processingRound1(_typeInfo) { }
-    processingRound2(_typeInfo, _campaign) { }
-    processingRound3(_typeInfo) { }
-    processingRound4(_typeInfo) { }
-    handleWhiteListBlacklistRound5(typeInfo, campaign) {
-        const blacklistedSupplyBN = BigInt(typeInfo.blacklistedSupply);
-        const totalSupplyBN = BigInt(typeInfo.totalSupply);
-        const totalSupply = BN2Number(typeInfo.totalSupply, campaign.campaignParameters.decimalsTargetToken);
-        const whitelistedSupply = BN2Number(typeInfo.whitelistedSupply, campaign.campaignParameters.decimalsTargetToken);
-        const blacklistedSupply = BN2Number(typeInfo.blacklistedSupply, campaign.campaignParameters.decimalsTargetToken);
-        let whitelistedSupplyTargetToken = whitelistedSupply
-            ? whitelistedSupply
-            : BN2Number(totalSupplyBN - blacklistedSupplyBN, campaign.campaignParameters.decimalsTargetToken);
-        whitelistedSupplyTargetToken = whitelistedSupplyTargetToken ? whitelistedSupplyTargetToken : 0.00001;
-        return {
-            whitelistedSupplyTargetToken,
-            totalSupply,
-            blacklistedSupply,
-        };
-    }
-    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const priceTargetToken = await TokenService.getPrice({
-            address: campaign.campaignParameters.targetToken,
-            chainId: campaign.computeChainId,
-        });
-        const tvl = whitelistedSupplyTargetToken * priceTargetToken;
-        return {
-            protocol: typeInfo.protocol,
-            type,
-            whitelistedSupplyTargetToken,
-            totalSupply,
-            priceTargetToken,
-            tvl,
-            blacklistedSupply,
-            cardName: generateCardName(type, typeInfo, campaign),
-            tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
-        };
-    }
-    computeRound1(type, typeInfo) {
-        typeInfo = { type, ...tokenTypeToProtocolAndAction[type], ...typeInfo };
-        this.processingRound1(typeInfo);
-        let calls = this.encodeNextRound(Round.one, type, typeInfo);
-        if (typeInfo.isStaking === "true") {
-            calls = calls.concat(this.encodeStakingNextRound(Round.one, type, typeInfo));
-        }
-        if (this.debug) {
-            console.log("Round 1", {
-                type: type,
-                calls,
-                typeInfo,
-            });
-        }
-        return {
-            type: type,
-            calls,
-            typeInfo,
-        };
-    }
-    computeRound2(index, type, typeInfo, calls, campaign) {
-        this.decodePreviousRound(Round.one, calls, typeInfo, type, index);
-        if (typeInfo.isStaking === "true") {
-            this.decodePreviousStakingRound(Round.one, calls, typeInfo, type, index + this.rounds.round1.length);
-        }
-        this.processingRound2(typeInfo, campaign);
-        let nextCalls = this.encodeNextRound(Round.two, type, typeInfo);
-        if (typeInfo.isStaking === "true") {
-            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.two, type, typeInfo));
-        }
-        if (this.debug) {
-            console.log("Round 2", {
-                type: type,
-                calls: nextCalls,
-                typeInfo,
-            });
-        }
-        return {
-            type: type,
-            calls: nextCalls,
-            typeInfo,
-        };
-    }
-    computeRound3(index, type, typeInfo, calls) {
-        this.decodePreviousRound(Round.two, calls, typeInfo, type, index);
-        if (typeInfo.isStaking === "true") {
-            this.decodePreviousStakingRound(Round.two, calls, typeInfo, type, index + this.rounds.round2.length);
-        }
-        this.processingRound3(typeInfo);
-        let nextCalls = this.encodeNextRound(Round.three, type, typeInfo);
-        if (typeInfo.isStaking === "true") {
-            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.three, type, typeInfo));
-        }
-        if (this.debug) {
-            console.log("Round 3", {
-                type: type,
-                calls: nextCalls,
-                typeInfo,
-            });
-        }
-        return {
-            type: type,
-            calls: nextCalls,
-            typeInfo,
-        };
-    }
-    computeRound4(index, type, typeInfo, calls, campaign) {
-        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
-        const whitelistedLiquidityCalls = this.generateWhitelistCall(type, typeInfo, campaign);
-        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
-        if (typeInfo.isStaking === "true") {
-            this.decodePreviousStakingRound(Round.three, calls, typeInfo, type, index + this.rounds.round3.length);
-        }
-        this.processingRound4(typeInfo);
-        let nextCalls = this.encodeNextRound(Round.four, type, typeInfo);
-        if (typeInfo.isStaking === "true") {
-            nextCalls = nextCalls.concat(this.encodeStakingNextRound(Round.four, type, typeInfo));
-        }
-        if (this.debug) {
-            console.log("Round 4", {
-                type: type,
-                calls: nextCalls,
-                typeInfo,
-            });
-        }
-        return {
-            type: type,
-            calls: whitelistedLiquidityCalls.concat(blacklistedLiquidityCalls).concat(nextCalls),
-            typeInfo: {
-                ...typeInfo,
-            },
-        };
-    }
-    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
-        typeInfo.whitelistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.whitelist, calls);
-        index = index + campaign.campaignParameters.whitelist.length;
-        typeInfo.blacklistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.blacklist, calls);
-        index = index + campaign.campaignParameters.blacklist.length;
-        this.decodePreviousRound(Round.four, calls, typeInfo, type, index);
-        if (typeInfo.isStaking === "true") {
-            this.decodePreviousStakingRound(Round.four, calls, typeInfo, type, index + this.rounds.round4.length);
-        }
-        const outputInfo = (await this.processingRound5(index, type, typeInfo, calls, campaign, pricer));
-        if (this.debug) {
-            console.log("Round 5", {
-                type: type,
-                calls: [],
-                typeInfo: {
-                    ...outputInfo,
-                },
-            });
-        }
-        return {
-            type: type,
-            calls: [],
-            typeInfo: {
-                ...outputInfo,
-            },
-        };
-    }
-    generateWhitelistCall(type, typeInfo, campaign) {
-        const whitelistedLiquidityCalls = [];
-        if (campaign.campaignParameters.whitelist.length > 0) {
-            for (const whitelistedAddress of campaign.campaignParameters.whitelist) {
-                if (!campaign.campaignParameters.blacklist.includes(whitelistedAddress)) {
-                    whitelistedLiquidityCalls.push(createCall(typeInfo.tokenAddress, "balanceOf", type, whitelistedAddress));
-                }
-            }
-        }
-        return whitelistedLiquidityCalls;
-    }
-    generateBlackListCall(type, typeInfo, campaign) {
-        const blacklistedLiquidityCalls = [];
-        if (campaign.campaignParameters.blacklist.length > 0) {
-            for (const blacklistedAddress of campaign.campaignParameters.blacklist) {
-                blacklistedLiquidityCalls.push(createCall(typeInfo.tokenAddress, "balanceOf", type, blacklistedAddress));
-            }
-        }
-        return blacklistedLiquidityCalls;
-    }
-    decodeListedSupply(index, list, calls) {
-        if (list.length === 0) {
-            return "0";
-        }
-        let listedSupply = 0n;
-        for (const _ of list) {
-            listedSupply += BigInt(decodeCall(calls, index++, "balanceOf"));
-        }
-        return listedSupply.toString();
-    }
-    decodeRound(round, index, calls, type, data) {
-        round.map(({ key, call, optional }) => {
-            if (optional) {
-                try {
-                    const value = decodeCall(calls, index, call, type);
-                    index++;
-                    data[key] = value;
-                }
-                catch {
-                    index++;
-                }
-            }
-            else {
-                const value = decodeCall(calls, index, call, type);
-                index++;
-                data[key] = value;
-            }
-        });
-    }
-    decodePreviousRound(round, calls, data, type, index) {
-        if (round === Round.one) {
-            this.decodeRound(this.rounds.round1, index, calls, type, data);
-        }
-        if (round === Round.two) {
-            this.decodeRound(this.rounds.round2, index, calls, type, data);
-        }
-        if (round === Round.three) {
-            this.decodeRound(this.rounds.round3, index, calls, type, data);
-        }
-        if (round === Round.four) {
-            this.decodeRound(this.rounds.round4, index, calls, type, data);
-        }
-    }
-    decodePreviousStakingRound(round, calls, data, type, index) {
-        if (round === Round.one) {
-            this.decodeRound(this.stakingRounds.round1, index, calls, type, data);
-        }
-        if (round === Round.two) {
-            this.decodeRound(this.stakingRounds.round2, index, calls, type, data);
-        }
-        if (round === Round.three) {
-            this.decodeRound(this.stakingRounds.round3, index, calls, type, data);
-        }
-        if (round === Round.four) {
-            this.decodeRound(this.stakingRounds.round4, index, calls, type, data);
-        }
-    }
-    encodeRound(round, callInfo, type) {
-        return round
-            .map(({ call, target, metaData, optional }) => {
-            if (optional && !callInfo[target]) {
-                return [];
-            }
-            if (metaData) {
-                return createCall(callInfo[target], call, type, callInfo[metaData]);
-            }
-            return createCall(callInfo[target], call, type);
-        })
-            .filter(call => Array.isArray(call) === false);
-    }
-    encodeNextRound(round, type, data) {
-        const keys = Object.keys(data);
-        const callInfo = keys.reduce((acc, key) => {
-            if (data[key]) {
-                acc[key] = data[key];
-            }
-            return acc;
-        }, {});
-        let calls = [];
-        if (round === Round.one) {
-            calls = this.encodeRound(this.rounds.round1, callInfo, type);
-        }
-        if (round === Round.two) {
-            calls = this.encodeRound(this.rounds.round2, callInfo, type);
-        }
-        if (round === Round.three) {
-            calls = this.encodeRound(this.rounds.round3, callInfo, type);
-        }
-        if (round === Round.four) {
-            calls = this.encodeRound(this.rounds.round4, callInfo, type);
-        }
-        return calls;
-    }
-    encodeStakingNextRound(round, type, data) {
-        const keys = Object.keys(data);
-        const callInfo = keys.reduce((acc, key) => {
-            if (data[key]) {
-                acc[key] = data[key];
-            }
-            return acc;
-        }, {});
-        let calls = [];
-        if (round === Round.one) {
-            calls = this.encodeRound(this.stakingRounds.round1, callInfo, type);
-        }
-        if (round === Round.two) {
-            calls = this.encodeRound(this.stakingRounds.round2, callInfo, type);
-        }
-        if (round === Round.three) {
-            calls = this.encodeRound(this.stakingRounds.round3, callInfo, type);
-        }
-        if (round === Round.four) {
-            calls = this.encodeRound(this.stakingRounds.round4, callInfo, type);
-        }
-        return calls;
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/helpers/eulerVaultNames.js

@@ -1,13 +0,0 @@
-// https://splice-api-ad64cd01a25d.herokuapp.com/mode/markets?market=0x34cf9BF641bd5f34197060A3f3478a1f97f78f0a
-import axios from "axios";
-export async function fetchEulerVaultName(vaultAddress, chainId) {
-    const url = `https://raw.githubusercontent.com/euler-xyz/euler-labels/refs/heads/master/${chainId}/vaults.json`;
-    try {
-        const response = await axios.get(url);
-        const vaultName = response.data[vaultAddress].name;
-        return vaultName;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/helpers/factoryFinder.js

@@ -1,47 +0,0 @@
-import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
-const factoryAddresses = {
-    "0x420DD381b31aEf6683db6B902084cB0FFECe40Da": Erc20SubType.aerodrome, // Aerodrome Base Factory
-    "0x31832f2a97Fd20664D76Cc421207669b55CE4BC0": Erc20SubType.velodrome, // Velodrome Mode Factory
-    "0xc9Fe0C63Af9A39402e8a5514f9c43Af0322b665F": Erc20SubType.curve, // Curve Factory Fraxtal
-    "0xc6C09471Ee39C7E30a067952FcC89c8922f9Ab53": Erc20SubType.curve, // Curve Optimism Factory
-    "0x98EE851a00abeE0d95D08cF4CA2BdCE32aeaAF7F": Erc20SubType.curve, // Curve Mainnet Factory
-    "0x9e6d12097339ddd5402FDD39fc0Ef86Eec54AB39": Erc20SubType.splice, // Splice Mode Factory
-    "0x49Afe3abCf66CF09Fab86cb1139D8811C8afe56F": Erc20SubType.toros, // Toros Base Factory
-    "0xAf39606bec181887951Ab6912Ac7EA216Bd6E4B4": Erc20SubType.akron, // Akron Arbitrum Factory
-    "0xC3DC853dD716bd5754f421ef94fdCbac3902ab32": Erc20SubType.enzyme, // Enzyme ETH Factory
-    "0x2e25271297537B8124b8f883a92fFd95C4032733": Erc20SubType.enzyme, // Enzyme Polygon Factory
-    "0x71f6b49ae1558357bBb5A6074f1143c46cBcA03d": Erc20SubType.dragonswap, // DragonSwap SEI Factory
-    "0x40be1cBa6C5B47cDF9da7f963B6F761F4C60627D": Erc20SubType.koi, // Silo Staking Factory
-    "0xFDa619b6d20975be80A10332cD39b9a4b0FAa8BB": Erc20SubType.baseswap, // Poolside Factory
-    "0xa19C51D91891D3DF7C13Ed22a2f89d328A82950f": Erc20SubType.fenix, // Fenix Factory
-    "0x3a76e377ED58c8731F9DF3A36155942438744Ce3": Erc20SubType.zkswap, // ZKSwap Factory
-    "0x6fcf753f2C67b83f7B09746Bbc4FA0047b35D050": Erc20SubType.pendle, // Pendle Factory
-    "0x35A338522a435D46f77Be32C70E215B813D0e3aC": Erc20SubType.pendleYT, // Pendle YT Factory
-    "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73": Erc20SubType.pancakeswap, // PancakeSwap Factory BNB
-    "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD": Erc20SubType.pendleYT, // Pendle YT Factory
-    "0x0582D93FD9c9d42f26bE5D86a5f75291F92102C2": Erc20SubType.pendleYT, // Pendle Factory
-    "0xFeE31A6eC6eBefa0b5A594Bf5b1139e3c6fAA0fB": Erc20SubType.pendle, // Pendle Factory
-    "0xFD513630F697A9C1731F196185fb9ebA6eAAc20B": Erc20SubType.cpmmGamma, // CPMMGAMMA Factory
-    "0x9Ad6C38BE94206cA50bb0d90783181662f0Cfa10": Erc20SubType.traderJoe, // Trader Joe Factory
-    "0x5Ea9DD3b6f042A34Df818C6c1324BC5A7c61427a": Erc20SubType.curve, // Curve Corn 2crypto Factory
-    "0xd7E72f3615aa65b92A4DBdC211E296a35512988B": Erc20SubType.curveNPool, // Curve Corn Stableswap Factory
-    "0x7Ca46A636b02D4aBC66883D7FF164bDE506DC66a": Erc20SubType.curveNPool, // Curve Corn 3crypto Factory
-    "0xbC0797015fcFc47d9C1856639CaE50D0e69FbEE8": Erc20SubType.curveTricrypto, // Curve Arbitrum 3crypto Factory
-    "0xA5961898870943c68037F6848d2D866Ed2016bcB": Erc20SubType.curveNPool, // Curve Base
-    "0xB255D6A720BB7c39fee173cE22113397119cB930": Erc20SubType.katana, // Katana Ronin
-    "0x29372c22459a4e373851798bFd6808e71EA34A71": Erc20SubType.punchswap, // Punchswap Flow EVM
-    "0x724412C00059bf7d6ee7d4a1d0D5cd4de3ea1C48": Erc20SubType.hyperswap, // Hyperswap Factory HyperEVM
-    "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6": Erc20SubType.uniswapv2, // Uniswap Factory Base
-    "0xBA51AA60B3b8d9A36cc748a62Aa56801060183f8": Erc20SubType.pinto, // Pinto Factory on Base
-};
-export function getTypeFromFactoryAddress(address) {
-    if (factoryAddresses[address]) {
-        return factoryAddresses[address];
-    }
-    return Erc20SubType.unknown;
-}
-// Mapping of dispatcher to fund value calculator for enzyme
-export const enzymeFundValueCalculatorRouterMapping = {
-    "0xC3DC853dD716bd5754f421ef94fdCbac3902ab32": "0x7c728cd0CfA92401E01A4849a01b57EE53F5b2b9", // ETH
-    "0x2e25271297537B8124b8f883a92fFd95C4032733": "0xD70389a7d6171e1DBA6C3df4DB7331811fd93f08", // Polygon
-};

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

@@ -1,22 +0,0 @@
-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/deprecated/erc20SubTypeProcessors/helpers/getCrossCurveTokenPrice.js

@@ -1,13 +0,0 @@
-import axios from "axios";
-export async function getCrossCurveTokenPrice(address) {
-    const apiUrl = `https://api.crosscurve.fi/prices/${address}`;
-    let price = 0;
-    try {
-        const response = await axios.get(apiUrl);
-        if (response.data) {
-            price = Number(response.data);
-        }
-    }
-    catch (e) { }
-    return price;
-}

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

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

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

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

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

@@ -1,35 +0,0 @@
-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/deprecated/erc20SubTypeProcessors/helpers/ownerFinder.js

@@ -1,16 +0,0 @@
-import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
-const ownerAddresses = {
-    "0xbF7E49483881C76487b0989CD7d9A8239B20CA41": Erc20SubType.curve_2,
-    "0x42a856dbEBB97AbC1269EAB32f3bb40C15102819": Erc20SubType.satlayer,
-    "0x4C911bf7A008C497719CBEb1a376f1cEc9e2c1d6": Erc20SubType.hanji_liquidity_vault_token,
-    "0x6e9d701fB6478Ed5972a37886C2BA6C82a4cBb4C": Erc20SubType.gamma, // Gamma Bob owner
-    "0x14fB20565a11b15cA2065A06740A0C46F5986eD0": Erc20SubType.lendle_vaults, // Gamma Alice owner
-    "0xBebB5CEe893110cF477901AF7FA94E4840606421": Erc20SubType.termmax,
-    "0x65955cac2B4a91BB19ee64df82Af6C18758c5FD6": Erc20SubType.hypurrfi_isolated_market,
-};
-export function getTypeFromOwnerAddress(address) {
-    if (ownerAddresses[address]) {
-        return ownerAddresses[address];
-    }
-    return Erc20SubType.unknown;
-}

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

@@ -1,23 +0,0 @@
-// 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,
-            address: market.token.address,
-            priceTargetToken: market.pool.price,
-            tvl: market.pool.tvl,
-        };
-    }
-    catch (e) {
-        return {
-            symbolUnderlyingToken: "",
-            priceTargetToken: 0,
-            address: "",
-            tvl: 1,
-        };
-    }
-}

package/dist/src/engine/deprecated/erc20SubTypeProcessors/helpers/treasuryFinder.js

@@ -1,10 +0,0 @@
-import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
-const treasuryAddresses = {
-    "0x3E965117A51186e41c2BB58b729A1e518A715e5F": Erc20SubType.gearbox, // Gearbox ETH Treasury
-};
-export function getTypeFromTreasuryAddress(address) {
-    if (treasuryAddresses[address]) {
-        return treasuryAddresses[address];
-    }
-    return Erc20SubType.unknown;
-}

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

@@ -1,26 +0,0 @@
-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,
-            tokensDisplay: [{ symbol: typeInfo.symbolUnderlyingToken, address: typeInfo.underlying }],
-        };
-    }
-}

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

@@ -1,51 +0,0 @@
-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),
-            tokensDisplay: [{ symbol: symbolUnderlyingToken, address: typeInfo.poolToken }],
-        };
-    }
-    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);
-    }
-}