@curvefi/llamalend-api 2.0.22 → 2.0.24

package/lib/mintMarkets/fetch/fetchMintMarkets.js

@@ -0,0 +1,138 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { _getCrvUsdMarketsData } from "../../external-api.js";
+import ERC20ABI from '../../constants/abis/ERC20.json' with { type: 'json' };
+import llammaABI from "../../constants/abis/crvUSD/llamma.json" with { type: 'json' };
+import controllerABI from "../../constants/abis/crvUSD/controller.json" with { type: 'json' };
+import controllerV2ABI from "../../constants/abis/crvUSD/controller_v2.json";
+import FactoryABI from "../../constants/abis/crvUSD/Factory.json" with { type: 'json' };
+import MonetaryPolicy2ABI from "../../constants/abis/crvUSD/MonetaryPolicy2.json" with { type: 'json' };
+import { extractDecimals } from "../../constants/utils.js";
+export const fetchMintMarketsByAPI = (llamalend) => __awaiter(void 0, void 0, void 0, function* () {
+    if (llamalend.chainId !== 1)
+        return;
+    const data = yield _getCrvUsdMarketsData();
+    const existingControllers = new Set(Object.values(llamalend.constants.LLAMMAS).map((l) => l.controller_address));
+    const newMarkets = data.filter((m) => !existingControllers.has(m.address.toLowerCase()));
+    if (newMarkets.length === 0)
+        return;
+    const N1 = Object.keys(llamalend.constants.LLAMMAS).length;
+    const controllers = newMarkets.map((m) => m.address.toLowerCase());
+    const amms = newMarkets.map((m) => m.llamma.toLowerCase());
+    const collaterals = newMarkets.map((m) => m.collateral_token.address.toLowerCase());
+    for (const collateral of collaterals)
+        llamalend.setContract(collateral, ERC20ABI);
+    for (const amm of amms)
+        llamalend.setContract(amm, llammaABI);
+    for (const controller of controllers)
+        llamalend.setContract(controller, controllerABI);
+    for (let i = 0; i < newMarkets.length; i++) {
+        const market = newMarkets[i];
+        const collateral_address = collaterals[i];
+        const is_eth = collateral_address === llamalend.constants.WETH;
+        const collateral_symbol = market.collateral_token.symbol;
+        const monetary_policy_address = market.monetary_policy_address.toLowerCase();
+        llamalend.setContract(monetary_policy_address, MonetaryPolicy2ABI);
+        const _llammaId = is_eth ? "eth" : collateral_symbol.toLowerCase();
+        let llammaId = _llammaId;
+        let j = 2;
+        while (llammaId in llamalend.constants.LLAMMAS)
+            llammaId = _llammaId + j++;
+        llamalend.constants.LLAMMAS[llammaId] = {
+            amm_address: amms[i],
+            controller_address: controllers[i],
+            monetary_policy_address,
+            collateral_address: is_eth ? "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" : collateral_address,
+            leverage_zap: llamalend.constants.ALIASES.leverage_zap,
+            deleverage_zap: "0x0000000000000000000000000000000000000000",
+            collateral_symbol: is_eth ? "ETH" : collateral_symbol,
+            collateral_decimals: market.collateral_token.decimals,
+            min_bands: 4,
+            max_bands: 50,
+            default_bands: 10,
+            A: market.amm_a,
+            monetary_policy_abi: MonetaryPolicy2ABI,
+            is_deleverage_supported: true,
+            index: N1 + i,
+        };
+    }
+    llamalend.constants.DECIMALS = Object.assign(Object.assign({}, llamalend.constants.DECIMALS), extractDecimals(llamalend.constants.LLAMMAS));
+});
+export const fetchMintMarketsByBlockchain = (llamalend) => __awaiter(void 0, void 0, void 0, function* () {
+    if (llamalend.chainId !== 1)
+        return;
+    llamalend.setContract(llamalend.constants.FACTORY, FactoryABI);
+    const factoryContract = llamalend.contracts[llamalend.constants.FACTORY].contract;
+    const factoryMulticallContract = llamalend.contracts[llamalend.constants.FACTORY].multicallContract;
+    const N1 = Object.keys(llamalend.constants.LLAMMAS).length;
+    const N2 = yield factoryContract.n_collaterals(llamalend.constantOptions);
+    let calls = [];
+    for (let i = N1; i < N2; i++) {
+        calls.push(factoryMulticallContract.collaterals(i), factoryMulticallContract.amms(i), factoryMulticallContract.controllers(i));
+    }
+    const res = (yield llamalend.multicallProvider.all(calls)).map((c) => c.toLowerCase());
+    const collaterals = res.filter((a, i) => i % 3 == 0);
+    const amms = res.filter((a, i) => i % 3 == 1);
+    const controllers = res.filter((a, i) => i % 3 == 2);
+    if (collaterals.length === 0)
+        return;
+    for (const collateral of collaterals)
+        llamalend.setContract(collateral, ERC20ABI);
+    calls = [];
+    for (const collateral of collaterals) {
+        calls.push(llamalend.contracts[collateral].multicallContract.symbol(), llamalend.contracts[collateral].multicallContract.decimals());
+    }
+    const collateralData = (yield llamalend.multicallProvider.all(calls)).map((x) => {
+        if (typeof x === "string")
+            return x.toLowerCase();
+        return x;
+    });
+    calls = [];
+    for (const amm of amms) {
+        llamalend.setContract(amm, llammaABI);
+        calls.push(llamalend.contracts[amm].multicallContract.A());
+    }
+    const AParams = (yield llamalend.multicallProvider.all(calls)).map((x) => Number(x));
+    for (let i = 0; i < collaterals.length; i++) {
+        const is_eth = collaterals[i] === llamalend.constants.WETH;
+        const [collateral_symbol, collateral_decimals] = collateralData.splice(0, 2);
+        if (i >= collaterals.length - 3) {
+            llamalend.setContract(controllers[i], controllerV2ABI);
+        }
+        else {
+            llamalend.setContract(controllers[i], controllerABI);
+        }
+        const monetary_policy_address = (yield llamalend.contracts[controllers[i]].contract.monetary_policy(llamalend.constantOptions)).toLowerCase();
+        llamalend.setContract(monetary_policy_address, MonetaryPolicy2ABI);
+        const _llammaId = is_eth ? "eth" : collateral_symbol.toLowerCase();
+        let llammaId = _llammaId;
+        let j = 2;
+        while (llammaId in llamalend.constants.LLAMMAS)
+            llammaId = _llammaId + j++;
+        llamalend.constants.LLAMMAS[llammaId] = {
+            amm_address: amms[i],
+            controller_address: controllers[i],
+            monetary_policy_address,
+            collateral_address: is_eth ? "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" : collaterals[i],
+            leverage_zap: llamalend.constants.ALIASES.leverage_zap,
+            deleverage_zap: "0x0000000000000000000000000000000000000000",
+            collateral_symbol: is_eth ? "ETH" : collateral_symbol,
+            collateral_decimals,
+            min_bands: 4,
+            max_bands: 50,
+            default_bands: 10,
+            A: AParams[i],
+            monetary_policy_abi: MonetaryPolicy2ABI,
+            is_deleverage_supported: true,
+            index: N1 + i,
+        };
+    }
+    llamalend.constants.DECIMALS = Object.assign(Object.assign({}, llamalend.constants.DECIMALS), extractDecimals(llamalend.constants.LLAMMAS));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curvefi/llamalend-api",
-  "version": "2.0.22",
+  "version": "2.0.24",
   "description": "JavaScript library for Curve Lending",
   "main": "lib/index.js",
   "author": "Macket",

package/src/external-api.ts

@@ -169,6 +169,34 @@ export const _getMarketsData = memoize(
     }
 )
 
+export interface ICrvUsdMarketAPI {
+    address: string;
+    llamma: string;
+    amm_a: number;
+    monetary_policy_address: string;
+    collateral_token: {
+        symbol: string;
+        address: string;
+        decimals: number;
+    };
+}
+
+export const _getCrvUsdMarketsData = memoize(
+    async (): Promise<ICrvUsdMarketAPI[]> => {
+        const url = 'https://prices.curve.finance/v1/crvusd/markets/ethereum';
+        const response = await fetch(url, { headers: { "accept": "application/json" } });
+        if (response.status !== 200) {
+            throw Error(`Fetch error: ${response.status} ${response.statusText}`);
+        }
+        const { data } = await response.json() as { data: ICrvUsdMarketAPI[] };
+        return data;
+    },
+    {
+        promise: true,
+        maxAge: 10 * 1000, // 10s
+    }
+)
+
 // --- ODOS ---
 
 export async function _getQuoteOdos(this: Llamalend, fromToken: string, toToken: string, _amount: bigint, blacklist: string, pathVizImage: boolean, slippage = 0.5): Promise<IQuoteOdos> {
@@ -214,18 +242,6 @@ export async function _assembleTxOdos(this: Llamalend, pathId: string): Promise<
     return _assembleTxOdosMemoized(this.constants.ALIASES.leverage_zap, pathId);
 }
 
-export const _getHiddenPools = memoize(
-    async () => {
-        const response = await fetch(`https://api.curve.finance/api/getHiddenPools`)
-
-        return (await response.json() as any).data
-    },
-    {
-        promise: true,
-        maxAge: 5 * 60 * 1000, // 5m
-    }
-)
-
 async function fetchJson(url: string): Promise<any> {
     const response = await fetch(url);
     return await response.json() ?? {};

package/src/index.ts

@@ -86,12 +86,10 @@ export function createLlamalend() {
         getGasPriceFromL2: getGasPriceFromL2.bind(llamalend),
         getGasInfoForL2: getGasInfoForL2.bind(llamalend),
 
-        // Core methods
-        fetchStats: llamalend.fetchStats.bind(llamalend),
-
         // Market lists
         mintMarkets: {
             getMarketList: llamalend.getMintMarketList.bind(llamalend),
+            fetchMintMarkets: llamalend.fetchMintMarkets.bind(llamalend),
         },
         lendMarkets: {
             fetchMarkets: llamalend.fetchLendMarkets.bind(llamalend),

package/src/lendMarkets/fetch/fetchLendMarkets.ts

@@ -87,14 +87,6 @@ export const fetchOneWayMarketsByBlockchain = async (llamalend: Llamalend, versi
     }
 
     registerMarkets(llamalend, names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges, COIN_DATA, version);
-
-    if (version === 'v2') {
-        llamalend.constants.ONE_WAY_MARKETS_V2 = await llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS_V2);
-    } else {
-        llamalend.constants.ONE_WAY_MARKETS = await llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS);
-    }
-
-    await llamalend.fetchStats(amms, controllers, vaults, borrowed_tokens, collateral_tokens, version);
 };
 
 export const fetchOneWayMarketsByAPI = async (llamalend: Llamalend, version: 'v1' | 'v2' = 'v1') => {
@@ -105,10 +97,4 @@ export const fetchOneWayMarketsByAPI = async (llamalend: Llamalend, version: 'v1
     }
 
     registerMarkets(llamalend, names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges, COIN_DATA, version);
-
-    if (version === 'v2') {
-        llamalend.constants.ONE_WAY_MARKETS_V2 = await llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS_V2);
-    } else {
-        llamalend.constants.ONE_WAY_MARKETS = await llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS);
-    }
 };

package/src/llamalend.ts

@@ -1,4 +1,4 @@
-import { type TransactionRequest, ethers, Contract, Networkish, BigNumberish, Numeric, AbstractProvider } from "ethers";
+import { type TransactionRequest, ethers, Contract, Networkish, BigNumberish, Numeric, AbstractProvider, BrowserProvider, Signer, JsonRpcProvider } from "ethers";
 import { Provider as MulticallProvider, Contract as MulticallContract, Call } from '@curvefi/ethcall';
 import {
     IChainId,
@@ -9,7 +9,6 @@ import {
     ICurveContract,
     IOneWayMarket,
     ICoin,
-
 } from "./interfaces.js";
 // OneWayMarket ABIs
 import OneWayLendingFactoryABI from "./constants/abis/OneWayLendingFactoryABI.json" with {type: 'json'};
@@ -26,10 +25,7 @@ import gasOracleBlobABI from './constants/abis/gas_oracle_optimism_blob.json' wi
 // crvUSD ABIs
 import llammaABI from "./constants/abis/crvUSD/llamma.json" with {type: 'json'};
 import controllerABI from "./constants/abis/crvUSD/controller.json" with {type: 'json'};
-import controllerV2ABI from "./constants/abis/crvUSD/controller_v2.json";
 import PegKeeper from "./constants/abis/crvUSD/PegKeeper.json" with {type: 'json'};
-import FactoryABI from "./constants/abis/crvUSD/Factory.json" with {type: 'json'};
-import MonetaryPolicy2ABI from "./constants/abis/crvUSD/MonetaryPolicy2.json" with {type: 'json'};
 import HealthCalculatorZapABI from "./constants/abis/crvUSD/HealthCalculatorZap.json" with {type: 'json'};
 import LeverageZapCrvUSDABI from "./constants/abis/crvUSD/LeverageZap.json" with {type: 'json'};
 import DeleverageZapABI from "./constants/abis/crvUSD/DeleverageZap.json" with {type: 'json'};
@@ -51,12 +47,35 @@ import {
 import {LLAMMAS} from "./constants/llammas.js";
 import {L2Networks} from "./constants/L2Networks.js";
 import {createCall, handleMultiCallResponse} from "./utils.js";
-import {cacheKey, cacheStats} from "./cache/index.js";
-import {_getMarketsData, _getHiddenPools} from "./external-api.js";
-import {extractDecimals} from "./constants/utils.js";
+import {_getMarketsData, _getCrvUsdMarketsData} from "./external-api.js";
 import {MintMarketTemplate} from "./mintMarkets";
 import {LendMarketTemplate} from "./lendMarkets";
 import {fetchOneWayMarketsByBlockchain, fetchOneWayMarketsByAPI} from "./lendMarkets/fetch/fetchLendMarkets.js";
+import {fetchMintMarketsByBlockchain, fetchMintMarketsByAPI} from "./mintMarkets/fetch/fetchMintMarkets.js";
+
+const memoizeByAddress = <T, Args extends unknown[]>(
+    factory: (address: string, abi: any, ...args: Args) => T
+): () => (address: string, abi: any, ...args: Args) => T => {
+    return () => {
+        const cache: Record<string, T> = {};
+        return (address: string, abi: any, ...args: Args): T => {
+            if (address in cache) {
+                return cache[address];
+            }
+            const result = factory(address, abi, ...args);
+            cache[address] = result;
+            return result;
+        };
+    };
+};
+
+const memoizedContract = memoizeByAddress(
+    (address, abi, provider: BrowserProvider | JsonRpcProvider | Signer) => new Contract(address, abi, provider)
+);
+
+const memoizedMulticallContract = memoizeByAddress(
+    (address, abi) => new MulticallContract(address, abi)
+);
 
 export const NETWORK_CONSTANTS: { [index: number]: any } = {
     1: {
@@ -190,52 +209,50 @@ class Llamalend implements ILlamalend {
             WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2".toLowerCase(),
         };
 
-        // JsonRpc provider
+        let signerPromise: Promise<ethers.Signer | null>;
+
         if (providerType.toLowerCase() === 'JsonRpc'.toLowerCase()) {
             providerSettings = providerSettings as { url: string, privateKey: string, batchMaxCount? : number };
 
             let jsonRpcApiProviderOptions;
-            if ( providerSettings.batchMaxCount ) {
-                jsonRpcApiProviderOptions = {
-                    batchMaxCount: providerSettings.batchMaxCount,
-                };
+            if (providerSettings.batchMaxCount) {
+                jsonRpcApiProviderOptions = { batchMaxCount: providerSettings.batchMaxCount };
             }
 
-            if (providerSettings.url) {
-                this.provider = new ethers.JsonRpcProvider(providerSettings.url, undefined, jsonRpcApiProviderOptions);
-            } else {
-                this.provider = new ethers.JsonRpcProvider('http://localhost:8545/', undefined, jsonRpcApiProviderOptions);
-            }
+            this.provider = new ethers.JsonRpcProvider(
+                providerSettings.url || 'http://localhost:8545/',
+                undefined,
+                jsonRpcApiProviderOptions
+            );
 
             if (providerSettings.privateKey) {
-                this.signer = new ethers.Wallet(providerSettings.privateKey, this.provider);
+                signerPromise = Promise.resolve(new ethers.Wallet(providerSettings.privateKey, this.provider));
             } else if (!providerSettings.url?.startsWith("https://rpc.gnosischain.com")) {
-                try {
-                    this.signer = await this.provider.getSigner();
-                } catch {
-                    this.signer = null;
-                }
+                signerPromise = this.provider.getSigner().catch(() => null);
+            } else {
+                signerPromise = Promise.resolve(null);
             }
-            // Web3 provider
         } else if (providerType.toLowerCase() === 'Web3'.toLowerCase()) {
             providerSettings = providerSettings as { externalProvider: ethers.Eip1193Provider };
             this.provider = new ethers.BrowserProvider(providerSettings.externalProvider);
-            this.signer = await this.provider.getSigner();
-            // Infura provider
+            signerPromise = this.provider.getSigner();
         } else if (providerType.toLowerCase() === 'Infura'.toLowerCase()) {
             providerSettings = providerSettings as { network?: Networkish, apiKey?: string };
             this.provider = new ethers.InfuraProvider(providerSettings.network, providerSettings.apiKey);
-            this.signer = null;
-            // Alchemy provider
+            signerPromise = Promise.resolve(null);
         } else if (providerType.toLowerCase() === 'Alchemy'.toLowerCase()) {
             providerSettings = providerSettings as { network?: Networkish, apiKey?: string };
             this.provider = new ethers.AlchemyProvider(providerSettings.network, providerSettings.apiKey);
-            this.signer = null;
+            signerPromise = Promise.resolve(null);
         } else {
             throw Error('Wrong providerType');
         }
 
-        const network = await this.provider.getNetwork();
+        const [signer, network] = await Promise.all([
+            signerPromise,
+            this.provider.getNetwork(),
+        ]);
+        this.signer = signer;
         this.chainId = Number(network.chainId) === 133 || Number(network.chainId) === 31337 ? 1 : Number(network.chainId) as IChainId;
         console.log("CURVE-LLAMALEND-JS IS CONNECTED TO NETWORK:", { name: network.name.toUpperCase(), chainId: Number(this.chainId) });
 
@@ -264,8 +281,6 @@ class Llamalend implements ILlamalend {
         }
 
         this.feeData = { gasPrice: options.gasPrice, maxFeePerGas: options.maxFeePerGas, maxPriorityFeePerGas: options.maxPriorityFeePerGas };
-        await this.updateFeeData();
-
         // oneWayMarkets contracts
         this.setContract(this.constants.ALIASES['one_way_factory'], OneWayLendingFactoryABI);
         if(this.constants.ALIASES['one_way_factory_v2'] && this.constants.ALIASES['one_way_factory_v2'] !== this.constants.ZERO_ADDRESS) {
@@ -292,119 +307,8 @@ class Llamalend implements ILlamalend {
             }
         }
 
-        // crvUSD contracts
-        this.setContract(this.crvUsdAddress, ERC20ABI);
-        if(this.chainId === 1) {
-            this.setContract(this.constants.COINS.crvusd.toLowerCase(), ERC20ABI);
-            for (const llamma of Object.values(this.constants.LLAMMAS)) {
-                this.setContract(llamma.amm_address, llammaABI);
-                this.setContract(llamma.controller_address, controllerABI);
-                const monetary_policy_address = await this.contracts[llamma.controller_address].contract.monetary_policy(this.constantOptions);
-                llamma.monetary_policy_address = monetary_policy_address.toLowerCase();
-                this.setContract(llamma.monetary_policy_address, llamma.monetary_policy_abi);
-                if (llamma.collateral_address === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee") {
-                    this.setContract(this.constants.WETH, ERC20ABI);
-                } else {
-                    this.setContract(llamma.collateral_address, ERC20ABI);
-                }
-                this.setContract(llamma.leverage_zap, LeverageZapCrvUSDABI);
-                this.setContract(llamma.deleverage_zap, DeleverageZapABI);
-                if (llamma.health_calculator_zap) this.setContract(llamma.health_calculator_zap, HealthCalculatorZapABI);
-            }
-            for (const pegKeeper of this.constants.PEG_KEEPERS) {
-                this.setContract(pegKeeper, PegKeeper);
-            }
-        }
-
-        // TODO Put it in a separate method
-        // Fetch new llammas
-        if(this.chainId === 1) {
-            this.setContract(this.constants.FACTORY, FactoryABI);
-            const factoryContract = this.contracts[this.constants.FACTORY].contract;
-            const factoryMulticallContract = this.contracts[this.constants.FACTORY].multicallContract;
-
-            const N1 = Object.keys(this.constants.LLAMMAS).length;
-            const N2 = await factoryContract.n_collaterals(this.constantOptions);
-            let calls = [];
-            for (let i = N1; i < N2; i++) {
-                calls.push(
-                    factoryMulticallContract.collaterals(i),
-                    factoryMulticallContract.amms(i),
-                    factoryMulticallContract.controllers(i)
-                );
-            }
-            const res: string[] = (await this.multicallProvider.all(calls) as string[]).map((c) => c.toLowerCase());
-            const collaterals = res.filter((a, i) => i % 3 == 0) as string[];
-            const amms = res.filter((a, i) => i % 3 == 1) as string[];
-            const controllers = res.filter((a, i) => i % 3 == 2) as string[];
-
-            if (collaterals.length > 0) {
-                for (const collateral of collaterals) this.setContract(collateral, ERC20ABI);
-
-                calls = [];
-                for (const collateral of collaterals) {
-                    calls.push(
-                        this.contracts[collateral].multicallContract.symbol(),
-                        this.contracts[collateral].multicallContract.decimals()
-                    )
-                }
-                const res = (await this.multicallProvider.all(calls)).map((x) => {
-                    if (typeof x === "string") return x.toLowerCase();
-                    return x;
-                });
-
-                calls = [];
-
-                for(const amm of amms) {
-                    this.setContract(amm, llammaABI);
-                    calls.push(
-                        this.contracts[amm].multicallContract.A()
-                    )
-                }
-
-                const AParams = (await this.multicallProvider.all(calls)).map((x) => {
-                    return Number(x)
-                });
-
-                for (let i = 0; i < collaterals.length; i++) {
-                    const is_eth = collaterals[i] === this.constants.WETH;
-                    const [collateral_symbol, collateral_decimals] = res.splice(0, 2) as [string, number];
-
-                    if (i >= collaterals.length - 3) {
-                        this.setContract(controllers[i], controllerV2ABI);
-                    } else {
-                        this.setContract(controllers[i], controllerABI);
-                    }
-
-                    const monetary_policy_address = (await this.contracts[controllers[i]].contract.monetary_policy(this.constantOptions)).toLowerCase();
-                    this.setContract(monetary_policy_address, MonetaryPolicy2ABI);
-                    const _llammaId: string = is_eth ? "eth" : collateral_symbol.toLowerCase();
-                    let llammaId = _llammaId
-                    let j = 2;
-                    while (llammaId in this.constants.LLAMMAS) llammaId = _llammaId + j++;
-                    this.constants.LLAMMAS[llammaId] = {
-                        amm_address: amms[i],
-                        controller_address: controllers[i],
-                        monetary_policy_address,
-                        collateral_address: is_eth ? "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" : collaterals[i],
-                        leverage_zap: this.constants.ALIASES.leverage_zap,
-                        deleverage_zap: "0x0000000000000000000000000000000000000000",
-                        collateral_symbol: is_eth ? "ETH" : collateral_symbol,
-                        collateral_decimals,
-                        min_bands: 4,
-                        max_bands: 50,
-                        default_bands: 10,
-                        A: AParams[i],
-                        monetary_policy_abi: MonetaryPolicy2ABI,
-                        is_deleverage_supported: true,
-                        index: N1 + i,
-                    }
-                }
-            }
-        }
 
         this.constants.DECIMALS = {
-            ...extractDecimals(this.constants.LLAMMAS),
             [this.crvUsdAddress]: 18,
             [this.constants.ALIASES.crv]: 18,
             [this.constants.ALIASES.crvUSD]: 18,
@@ -445,25 +349,85 @@ class Llamalend implements ILlamalend {
                 AbstractProvider.prototype.estimateGas = AbstractProvider.prototype.originalEstimate as (_tx: TransactionRequest) => Promise<bigint>;
             }
         }
+
     }
 
-    setContract(address: string, abi: any): void {
+    initContract = memoizedContract()
+    initMulticallContract = memoizedMulticallContract()
+
+    setContract(address: string | undefined, abi: any): void {
         if (address === this.constants.ZERO_ADDRESS || address === undefined) return;
-        this.contracts[address] = {
-            contract: new Contract(address, abi, this.signer || this.provider),
-            multicallContract: new MulticallContract(address, abi),
-            address: address,
-            abi: abi,
+
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const llamalendInstance = this;
+
+        const proxyHandler: ProxyHandler<any> = {
+            get: function(target: any, name: string) {
+                if(name === 'contract') {
+                    return llamalendInstance.initContract(target['address'], target['abi'], llamalendInstance.signer || llamalendInstance.provider)
+                } else if(name === 'multicallContract') {
+                    return llamalendInstance.initMulticallContract(target['address'], target['abi'])
+                } else {
+                    return target[name];
+                }
+            },
         }
+
+        const coreContract = {
+            address,
+            abi,
+        }
+
+        this.contracts[address] = new Proxy(coreContract, proxyHandler)
     }
 
     setCustomFeeData(customFeeData: { gasPrice?: number, maxFeePerGas?: number, maxPriorityFeePerGas?: number }): void {
         this.feeData = { ...this.feeData, ...customFeeData };
     }
 
-    async _filterHiddenMarkets(markets: IDict<IOneWayMarket>): Promise<IDict<IOneWayMarket>> {
-        const hiddenMarkets = (await _getHiddenPools() as any)[this.constants.NETWORK_NAME] || [];
-        return Object.fromEntries(Object.entries(markets).filter(([id]) => !hiddenMarkets.includes(id))) as IDict<IOneWayMarket>;
+    async _setupMintMarketContracts(useApi = true): Promise<void> {
+        this.setContract(this.crvUsdAddress, ERC20ABI);
+        if (this.chainId !== 1) return;
+
+        this.setContract(this.constants.COINS.crvusd.toLowerCase(), ERC20ABI);
+
+        const llammas = Object.values(this.constants.LLAMMAS);
+        for (const llamma of llammas) {
+            this.setContract(llamma.amm_address, llammaABI);
+            this.setContract(llamma.controller_address, controllerABI);
+        }
+
+        if (useApi) {
+            const apiData = await _getCrvUsdMarketsData();
+            const monetaryPolicyMap = new Map(
+                apiData.map((m) => [m.address.toLowerCase(), m.monetary_policy_address.toLowerCase()])
+            );
+            for (const llamma of llammas) {
+                const fresh = monetaryPolicyMap.get(llamma.controller_address);
+                if (fresh) llamma.monetary_policy_address = fresh;
+            }
+        } else {
+            const monetaryPolicies = (await this.multicallProvider.all(
+                llammas.map((l) => this.contracts[l.controller_address].multicallContract.monetary_policy())
+            ) as string[]).map((a) => a.toLowerCase());
+            llammas.forEach((llamma, i) => { llamma.monetary_policy_address = monetaryPolicies[i]; });
+        }
+
+        for (const llamma of llammas) {
+            this.setContract(llamma.monetary_policy_address, llamma.monetary_policy_abi);
+            if (llamma.collateral_address === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee") {
+                this.setContract(this.constants.WETH, ERC20ABI);
+            } else {
+                this.setContract(llamma.collateral_address, ERC20ABI);
+            }
+            this.setContract(llamma.leverage_zap, LeverageZapCrvUSDABI);
+            this.setContract(llamma.deleverage_zap, DeleverageZapABI);
+            if (llamma.health_calculator_zap) this.setContract(llamma.health_calculator_zap, HealthCalculatorZapABI);
+        }
+
+        for (const pegKeeper of this.constants.PEG_KEEPERS) {
+            this.setContract(pegKeeper, PegKeeper);
+        }
     }
 
     getLendMarketList = () => Object.keys({...this.constants.ONE_WAY_MARKETS, ...this.constants.ONE_WAY_MARKETS_V2});
@@ -482,6 +446,13 @@ class Llamalend implements ILlamalend {
         }
     }
 
+    fetchMintMarkets = async ({ useApi = true }: { useApi?: boolean } = {}): Promise<void> => {
+        await Promise.all([
+            this._setupMintMarketContracts(useApi),
+            useApi ? fetchMintMarketsByAPI(this) : fetchMintMarketsByBlockchain(this),
+        ]);
+    }
+
     getCoins = async (collateral_tokens: string[], borrowed_tokens: string[], useApi = false): Promise<IDict<ICoin>> => {
         const coins = new Set([...collateral_tokens, ...borrowed_tokens]);
         const COINS_DATA: IDict<ICoin> = {};
@@ -539,54 +510,6 @@ class Llamalend implements ILlamalend {
         return COINS_DATA;
     }
 
-
-    fetchStats = async (amms: string[], controllers: string[], vaults: string[], borrowed_tokens: string[], collateral_tokens: string[], version: 'v1' | 'v2' = 'v1') => {
-        cacheStats.clear();
-
-        const marketCount = controllers.length;
-
-        const calls: Call[] = [];
-
-        for (let i = 0; i < marketCount; i++) {
-            calls.push(createCall(this.contracts[controllers[i]], 'total_debt', []));
-            calls.push(createCall(this.contracts[vaults[i]], 'totalAssets', []));
-            calls.push(createCall(this.contracts[borrowed_tokens[i]], 'balanceOf', [controllers[i]]));
-            calls.push(createCall(this.contracts[amms[i]], 'rate', []));
-            calls.push(createCall(this.contracts[borrowed_tokens[i]], 'balanceOf', [amms[i]]));
-
-            if (version === 'v1') {
-                calls.push(createCall(this.contracts[amms[i]], 'admin_fees_x', []));
-                calls.push(createCall(this.contracts[amms[i]], 'admin_fees_y', []));
-            }
-            
-            calls.push(createCall(this.contracts[collateral_tokens[i]], 'balanceOf', [amms[i]]));
-        }
-
-        const res = await this.multicallProvider.all(calls);
-
-        for (let i = 0; i < marketCount; i++) {
-            if (version === 'v1') {
-                cacheStats.set(cacheKey(controllers[i], 'total_debt'), res[(i * 8) + 0]);
-                cacheStats.set(cacheKey(vaults[i], 'totalAssets', controllers[i]), res[(i * 8) + 1]);
-                cacheStats.set(cacheKey(borrowed_tokens[i], 'balanceOf', controllers[i]), res[(i * 8) + 2]);
-                cacheStats.set(cacheKey(amms[i], 'rate'), res[(i * 8) + 3]);
-                cacheStats.set(cacheKey(borrowed_tokens[i], 'balanceOf', amms[i]), res[(i * 8) + 4]);
-                cacheStats.set(cacheKey(amms[i], 'admin_fees_x'), res[(i * 8) + 5]);
-                cacheStats.set(cacheKey(amms[i], 'admin_fees_y'), res[(i * 8) + 6]);
-                cacheStats.set(cacheKey(collateral_tokens[i], 'balanceOf', amms[i]), res[(i * 8) + 7]);
-            } else {
-                cacheStats.set(cacheKey(controllers[i], 'total_debt'), res[(i * 6) + 0]);
-                cacheStats.set(cacheKey(vaults[i], 'totalAssets', controllers[i]), res[(i * 6) + 1]);
-                cacheStats.set(cacheKey(borrowed_tokens[i], 'balanceOf', controllers[i]), res[(i * 6) + 2]);
-                cacheStats.set(cacheKey(amms[i], 'rate'), res[(i * 6) + 3]);
-                cacheStats.set(cacheKey(borrowed_tokens[i], 'balanceOf', amms[i]), res[(i * 6) + 4]);
-                cacheStats.set(cacheKey(amms[i], 'admin_fees_x'), BigInt(0)); // Always 0 for v2
-                cacheStats.set(cacheKey(amms[i], 'admin_fees_y'), BigInt(0)); // Always 0 for v2
-                cacheStats.set(cacheKey(collateral_tokens[i], 'balanceOf', amms[i]), res[(i * 6) + 5]);
-            }
-        }
-    };
-
     formatUnits(value: BigNumberish, unit?: string | Numeric): string {
         return ethers.formatUnits(value, unit);
     }