@curvefi/llamalend-api 1.0.2

package/lib/llamalend.js

@@ -0,0 +1,878 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { ethers, Contract, AbstractProvider } from "ethers";
+import { Provider as MulticallProvider, Contract as MulticallContract } from '@curvefi/ethcall';
+// OneWayMarket ABIs
+import OneWayLendingFactoryABI from "./constants/abis/OneWayLendingFactoryABI.json" assert { type: 'json' };
+import ERC20ABI from './constants/abis/ERC20.json' assert { type: 'json' };
+import ERC4626ABI from './constants/abis/ERC4626.json' assert { type: 'json' };
+import LlammaABI from './constants/abis/Llamma.json' assert { type: 'json' };
+import ControllerABI from './constants/abis/Controller.json' assert { type: 'json' };
+import MonetaryPolicyABI from './constants/abis/MonetaryPolicy.json' assert { type: 'json' };
+import VaultABI from './constants/abis/Vault.json' assert { type: 'json' };
+import GaugeABI from './constants/abis/GaugeV5.json' assert { type: 'json' };
+import SidechainGaugeABI from './constants/abis/SidechainGauge.json' assert { type: 'json' };
+import GaugeControllerABI from './constants/abis/GaugeController.json' assert { type: 'json' };
+import GaugeFactoryMainnetABI from './constants/abis/GaugeFactoryMainnet.json' assert { type: 'json' };
+import GaugeFactorySidechainABI from './constants/abis/GaugeFactorySidechain.json' assert { type: 'json' };
+import MinterABI from './constants/abis/Minter.json' assert { type: 'json' };
+import LeverageZapABI from './constants/abis/LeverageZap.json' assert { type: 'json' };
+import gasOracleABI from './constants/abis/gas_oracle_optimism.json' assert { type: 'json' };
+import gasOracleBlobABI from './constants/abis/gas_oracle_optimism_blob.json' assert { type: 'json' };
+// crvUSD ABIs
+import llammaABI from "./constants/abis/crvUSD/llamma.json" assert { type: 'json' };
+import controllerABI from "./constants/abis/crvUSD/controller.json" assert { type: 'json' };
+import PegKeeper from "./constants/abis/crvUSD/PegKeeper.json" assert { type: 'json' };
+import FactoryABI from "./constants/abis/crvUSD/Factory.json" assert { type: 'json' };
+import MonetaryPolicy2ABI from "./constants/abis/crvUSD/MonetaryPolicy2.json" assert { type: 'json' };
+import HealthCalculatorZapABI from "./constants/abis/crvUSD/HealthCalculatorZap.json" assert { type: 'json' };
+import LeverageZapCrvUSDABI from "./constants/abis/crvUSD/LeverageZap.json" assert { type: 'json' };
+import DeleverageZapABI from "./constants/abis/crvUSD/DeleverageZap.json" assert { type: 'json' };
+import { ALIASES_ETHEREUM, ALIASES_OPTIMISM, ALIASES_POLYGON, ALIASES_FANTOM, ALIASES_AVALANCHE, ALIASES_ARBITRUM, ALIASES_XDAI, ALIASES_MOONBEAM, ALIASES_AURORA, ALIASES_KAVA, ALIASES_CELO, ALIASES_ZKSYNC, ALIASES_BASE, ALIASES_BSC, ALIASES_FRAXTAL, ALIASES_SONIC, } from "./constants/aliases.js";
+import { COINS_ETHEREUM, COINS_OPTIMISM, COINS_POLYGON, COINS_FANTOM, COINS_AVALANCHE, COINS_ARBITRUM, COINS_XDAI, COINS_MOONBEAM, COINS_AURORA, COINS_KAVA, COINS_CELO, COINS_ZKSYNC, COINS_BASE, COINS_BSC, COINS_FRAXTAL, COINS_SONIC, } from "./constants/coins.js";
+import { LLAMMAS } from "./constants/llammas";
+import { L2Networks } from "./constants/L2Networks.js";
+import { createCall, handleMultiCallResponse } from "./utils.js";
+import { cacheKey, cacheStats } from "./cache/index.js";
+import { _getMarketsData } from "./external-api.js";
+import { extractDecimals } from "./constants/utils.js";
+export var NETWORK_CONSTANTS = {
+    1: {
+        NAME: 'ethereum',
+        ALIASES: ALIASES_ETHEREUM,
+        COINS: COINS_ETHEREUM,
+        EXCLUDED_PROTOCOLS_1INCH: "CURVE_V2_LLAMMA",
+    },
+    10: {
+        NAME: 'optimism',
+        ALIASES: ALIASES_OPTIMISM,
+        COINS: COINS_OPTIMISM,
+    },
+    56: {
+        NAME: 'bsc',
+        ALIASES: ALIASES_BSC,
+        COINS: COINS_BSC,
+    },
+    100: {
+        NAME: 'xdai',
+        ALIASES: ALIASES_XDAI,
+        COINS: COINS_XDAI,
+    },
+    137: {
+        NAME: 'polygon',
+        ALIASES: ALIASES_POLYGON,
+        COINS: COINS_POLYGON,
+    },
+    146: {
+        NAME: 'sonic',
+        ALIASES: ALIASES_SONIC,
+        COINS: COINS_SONIC,
+    },
+    250: {
+        NAME: 'fantom',
+        ALIASES: ALIASES_FANTOM,
+        COINS: COINS_FANTOM,
+    },
+    252: {
+        NAME: 'fraxtal',
+        ALIASES: ALIASES_FRAXTAL,
+        COINS: COINS_FRAXTAL,
+    },
+    324: {
+        NAME: 'zksync',
+        ALIASES: ALIASES_ZKSYNC,
+        COINS: COINS_ZKSYNC,
+    },
+    1284: {
+        NAME: 'moonbeam',
+        ALIASES: ALIASES_MOONBEAM,
+        COINS: COINS_MOONBEAM,
+    },
+    2222: {
+        NAME: 'kava',
+        ALIASES: ALIASES_KAVA,
+        COINS: COINS_KAVA,
+    },
+    8453: {
+        NAME: 'base',
+        ALIASES: ALIASES_BASE,
+        COINS: COINS_BASE,
+    },
+    42161: {
+        NAME: 'arbitrum',
+        ALIASES: ALIASES_ARBITRUM,
+        COINS: COINS_ARBITRUM,
+        EXCLUDED_PROTOCOLS_1INCH: "",
+    },
+    42220: {
+        NAME: 'celo',
+        ALIASES: ALIASES_CELO,
+        COINS: COINS_CELO,
+    },
+    43114: {
+        NAME: 'avalanche',
+        ALIASES: ALIASES_AVALANCHE,
+        COINS: COINS_AVALANCHE,
+    },
+    1313161554: {
+        NAME: 'aurora',
+        ALIASES: ALIASES_AURORA,
+        COINS: COINS_AURORA,
+    },
+};
+var Llamalend = /** @class */ (function () {
+    function Llamalend() {
+        var _this = this;
+        this.getLendMarketList = function () { return Object.keys(_this.constants.ONE_WAY_MARKETS); };
+        this.getMintMarketList = function () { return Object.keys(_this.constants.LLAMMAS); };
+        this.getFactoryMarketData = function () { return __awaiter(_this, void 0, void 0, function () {
+            var factory, factoryContract, markets_count, callsMap, calls, _loop_1, i, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        factory = this.contracts[this.constants.ALIASES['one_way_factory']];
+                        factoryContract = this.contracts[this.constants.ALIASES['one_way_factory']].contract;
+                        return [4 /*yield*/, factoryContract.market_count()];
+                    case 1:
+                        markets_count = _a.sent();
+                        callsMap = ['names', 'amms', 'controllers', 'borrowed_tokens', 'collateral_tokens', 'monetary_policies', 'vaults', 'gauges'];
+                        calls = [];
+                        _loop_1 = function (i) {
+                            callsMap.forEach(function (item) {
+                                calls.push(createCall(factory, item, [i]));
+                            });
+                        };
+                        for (i = 0; i < markets_count; i++) {
+                            _loop_1(i);
+                        }
+                        return [4 /*yield*/, this.multicallProvider.all(calls)];
+                    case 2:
+                        res = (_a.sent()).map(function (addr) { return addr.toLowerCase(); });
+                        return [2 /*return*/, handleMultiCallResponse(callsMap, res)];
+                }
+            });
+        }); };
+        this.getFactoryMarketDataByAPI = function () { return __awaiter(_this, void 0, void 0, function () {
+            var apiData, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _getMarketsData(this.constants.NETWORK_NAME)];
+                    case 1:
+                        apiData = (_a.sent()).lendingVaultData;
+                        result = {
+                            names: [],
+                            amms: [],
+                            controllers: [],
+                            borrowed_tokens: [],
+                            collateral_tokens: [],
+                            monetary_policies: [],
+                            vaults: [],
+                            gauges: [],
+                        };
+                        apiData.forEach(function (market) {
+                            var _a;
+                            result.names.push(market.name);
+                            result.amms.push(market.ammAddress.toLowerCase());
+                            result.controllers.push(market.controllerAddress.toLowerCase());
+                            result.borrowed_tokens.push(market.assets.borrowed.address.toLowerCase());
+                            result.collateral_tokens.push(market.assets.collateral.address.toLowerCase());
+                            result.monetary_policies.push(market.monetaryPolicyAddress.toLowerCase());
+                            result.vaults.push(market.address.toLowerCase());
+                            result.gauges.push(((_a = market.gaugeAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || _this.constants.ZERO_ADDRESS);
+                        });
+                        return [2 /*return*/, result];
+                }
+            });
+        }); };
+        this.getCoins = function (collateral_tokens, borrowed_tokens, useApi) {
+            if (useApi === void 0) { useApi = false; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var coins, COINS_DATA, apiData, calls_1, callsMap_1, res, _a, name_1, decimals_1, symbol_1;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            coins = new Set(__spreadArray(__spreadArray([], collateral_tokens, true), borrowed_tokens, true));
+                            COINS_DATA = {};
+                            if (!useApi) return [3 /*break*/, 2];
+                            return [4 /*yield*/, _getMarketsData(this.constants.NETWORK_NAME)];
+                        case 1:
+                            apiData = (_b.sent()).lendingVaultData;
+                            apiData.forEach(function (market) {
+                                var borrowedCoin = market.assets.borrowed;
+                                var collateralCoin = market.assets.collateral;
+                                if (coins.has(borrowedCoin.address)) {
+                                    _this.setContract(borrowedCoin.address, ERC20ABI);
+                                    COINS_DATA[borrowedCoin.address] = {
+                                        address: borrowedCoin.address,
+                                        decimals: borrowedCoin.decimals,
+                                        name: borrowedCoin.symbol,
+                                        symbol: borrowedCoin.symbol,
+                                    };
+                                }
+                                if (coins.has(collateralCoin.address)) {
+                                    _this.setContract(collateralCoin.address, ERC20ABI);
+                                    COINS_DATA[collateralCoin.address] = {
+                                        address: collateralCoin.address,
+                                        decimals: collateralCoin.decimals,
+                                        name: collateralCoin.symbol,
+                                        symbol: collateralCoin.symbol,
+                                    };
+                                }
+                            });
+                            return [3 /*break*/, 4];
+                        case 2:
+                            calls_1 = [];
+                            callsMap_1 = ['name', 'decimals', 'symbol'];
+                            coins.forEach(function (coin) {
+                                _this.setContract(coin, ERC20ABI);
+                                callsMap_1.forEach(function (item) {
+                                    calls_1.push(createCall(_this.contracts[coin], item, []));
+                                });
+                            });
+                            return [4 /*yield*/, this.multicallProvider.all(calls_1)];
+                        case 3:
+                            res = _b.sent();
+                            _a = handleMultiCallResponse(callsMap_1, res), name_1 = _a.name, decimals_1 = _a.decimals, symbol_1 = _a.symbol;
+                            Array.from(coins).forEach(function (coin, index) {
+                                COINS_DATA[coin] = {
+                                    address: coin,
+                                    decimals: Number(decimals_1[index]),
+                                    name: name_1[index],
+                                    symbol: symbol_1[index],
+                                };
+                            });
+                            _b.label = 4;
+                        case 4: return [2 /*return*/, COINS_DATA];
+                    }
+                });
+            });
+        };
+        this.fetchStats = function (amms, controllers, vaults, borrowed_tokens, collateral_tokens) { return __awaiter(_this, void 0, void 0, function () {
+            var marketCount, calls, i, res, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cacheStats.clear();
+                        marketCount = controllers.length;
+                        calls = [];
+                        for (i = 0; i < marketCount; i++) {
+                            calls.push(createCall(this.contracts[controllers[i]], 'total_debt', []));
+                            calls.push(createCall(this.contracts[vaults[i]], 'totalAssets', [controllers[i]]));
+                            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]]));
+                            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]]));
+                        }
+                        return [4 /*yield*/, this.multicallProvider.all(calls)];
+                    case 1:
+                        res = _a.sent();
+                        for (i = 0; i < marketCount; i++) {
+                            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]);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this.fetchLendMarkets = function (useAPI) {
+            if (useAPI === void 0) { useAPI = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!useAPI) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this._fetchOneWayMarketsByAPI()];
+                        case 1:
+                            _a.sent();
+                            return [3 /*break*/, 4];
+                        case 2: return [4 /*yield*/, this._fetchOneWayMarketsByBlockchain()];
+                        case 3:
+                            _a.sent();
+                            _a.label = 4;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        this._fetchOneWayMarketsByBlockchain = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _a, names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges, COIN_DATA, c;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getFactoryMarketData()];
+                    case 1:
+                        _a = _b.sent(), names = _a.names, amms = _a.amms, controllers = _a.controllers, borrowed_tokens = _a.borrowed_tokens, collateral_tokens = _a.collateral_tokens, monetary_policies = _a.monetary_policies, vaults = _a.vaults, gauges = _a.gauges;
+                        return [4 /*yield*/, this.getCoins(collateral_tokens, borrowed_tokens)];
+                    case 2:
+                        COIN_DATA = _b.sent();
+                        for (c in COIN_DATA) {
+                            this.constants.DECIMALS[c] = COIN_DATA[c].decimals;
+                        }
+                        amms.forEach(function (amm, index) {
+                            _this.setContract(amm, LlammaABI);
+                            _this.setContract(controllers[index], ControllerABI);
+                            _this.setContract(monetary_policies[index], MonetaryPolicyABI);
+                            _this.setContract(vaults[index], VaultABI);
+                            _this.setContract(gauges[index], _this.chainId === 1 ? GaugeABI : SidechainGaugeABI);
+                            COIN_DATA[vaults[index]] = {
+                                address: vaults[index],
+                                decimals: 18,
+                                name: "Curve Vault for " + COIN_DATA[borrowed_tokens[index]].name,
+                                symbol: "cv" + COIN_DATA[borrowed_tokens[index]].symbol,
+                            };
+                            COIN_DATA[gauges[index]] = {
+                                address: gauges[index],
+                                decimals: 18,
+                                name: "Curve.fi " + COIN_DATA[borrowed_tokens[index]].name + " Gauge Deposit",
+                                symbol: "cv" + COIN_DATA[borrowed_tokens[index]].symbol + "-gauge",
+                            };
+                            _this.constants.DECIMALS[vaults[index]] = 18;
+                            _this.constants.DECIMALS[gauges[index]] = 18;
+                            _this.constants.ONE_WAY_MARKETS["one-way-market-".concat(index)] = {
+                                name: names[index],
+                                addresses: {
+                                    amm: amms[index],
+                                    controller: controllers[index],
+                                    borrowed_token: borrowed_tokens[index],
+                                    collateral_token: collateral_tokens[index],
+                                    monetary_policy: monetary_policies[index],
+                                    vault: vaults[index],
+                                    gauge: gauges[index],
+                                },
+                                borrowed_token: COIN_DATA[borrowed_tokens[index]],
+                                collateral_token: COIN_DATA[collateral_tokens[index]],
+                            };
+                        });
+                        return [4 /*yield*/, this.fetchStats(amms, controllers, vaults, borrowed_tokens, collateral_tokens)];
+                    case 3:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this._fetchOneWayMarketsByAPI = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _a, names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges, COIN_DATA, c;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getFactoryMarketDataByAPI()];
+                    case 1:
+                        _a = _b.sent(), names = _a.names, amms = _a.amms, controllers = _a.controllers, borrowed_tokens = _a.borrowed_tokens, collateral_tokens = _a.collateral_tokens, monetary_policies = _a.monetary_policies, vaults = _a.vaults, gauges = _a.gauges;
+                        return [4 /*yield*/, this.getCoins(collateral_tokens, borrowed_tokens, true)];
+                    case 2:
+                        COIN_DATA = _b.sent();
+                        for (c in COIN_DATA) {
+                            this.constants.DECIMALS[c] = COIN_DATA[c].decimals;
+                        }
+                        amms.forEach(function (amm, index) {
+                            _this.setContract(amms[index], LlammaABI);
+                            _this.setContract(controllers[index], ControllerABI);
+                            _this.setContract(monetary_policies[index], MonetaryPolicyABI);
+                            _this.setContract(vaults[index], VaultABI);
+                            if (gauges[index]) {
+                                _this.setContract(gauges[index], _this.chainId === 1 ? GaugeABI : SidechainGaugeABI);
+                            }
+                            COIN_DATA[vaults[index]] = {
+                                address: vaults[index],
+                                decimals: 18,
+                                name: "Curve Vault for " + COIN_DATA[borrowed_tokens[index]].name,
+                                symbol: "cv" + COIN_DATA[borrowed_tokens[index]].symbol,
+                            };
+                            COIN_DATA[gauges[index]] = {
+                                address: gauges[index],
+                                decimals: 18,
+                                name: "Curve.fi " + COIN_DATA[borrowed_tokens[index]].name + " Gauge Deposit",
+                                symbol: "cv" + COIN_DATA[borrowed_tokens[index]].symbol + "-gauge",
+                            };
+                            _this.constants.DECIMALS[vaults[index]] = 18;
+                            _this.constants.DECIMALS[gauges[index]] = 18;
+                            _this.constants.ONE_WAY_MARKETS["one-way-market-".concat(index)] = {
+                                name: names[index],
+                                addresses: {
+                                    amm: amms[index],
+                                    controller: controllers[index],
+                                    borrowed_token: borrowed_tokens[index],
+                                    collateral_token: collateral_tokens[index],
+                                    monetary_policy: monetary_policies[index],
+                                    vault: vaults[index],
+                                    gauge: gauges[index],
+                                },
+                                borrowed_token: COIN_DATA[borrowed_tokens[index]],
+                                collateral_token: COIN_DATA[collateral_tokens[index]],
+                            };
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this.address = '00000'; //COINS.lending.toLowerCase();
+        // @ts-ignore
+        this.provider = null;
+        this.signer = null;
+        this.signerAddress = "";
+        this.chainId = 1;
+        // @ts-ignore
+        this.multicallProvider = null;
+        this.contracts = {};
+        this.feeData = {};
+        this.constantOptions = { gasLimit: 12000000 };
+        this.options = {};
+        this.constants = {
+            ONE_WAY_MARKETS: {},
+            LLAMMAS: LLAMMAS,
+            COINS: {},
+            DECIMALS: {},
+            NETWORK_NAME: 'ethereum',
+            ALIASES: {},
+            ZERO_ADDRESS: '0x000',
+            EXCLUDED_PROTOCOLS_1INCH: "",
+            FACTORY: "0xC9332fdCB1C491Dcc683bAe86Fe3cb70360738BC".toLowerCase(),
+            PEG_KEEPERS: [
+                '0x9201da0d97caaaff53f01b2fb56767c7072de340'.toLowerCase(),
+                '0xfb726f57d251ab5c731e5c64ed4f5f94351ef9f3'.toLowerCase(),
+                '0x3fa20eaa107de08b38a8734063d605d5842fe09c'.toLowerCase(),
+                '0x0a05ff644878b908ef8eb29542aa88c07d9797d3'.toLowerCase(),
+                '0x503E1Bf274e7a6c64152395aE8eB57ec391F91F8'.toLowerCase(),
+            ],
+            WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2".toLowerCase(),
+        };
+    }
+    Llamalend.prototype.init = function (providerType, providerSettings, options // gasPrice in Gwei
+    ) {
+        var _a;
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var jsonRpcApiProviderOptions, _b, e_1, _c, network, _d, err_1, _i, _e, llamma, monetary_policy_address, _f, _g, pegKeeper, factoryContract, factoryMulticallContract, N1, N2, calls, i, res, collaterals, amms, controllers, _h, collaterals_1, collateral, _j, collaterals_2, collateral, res_1, i, is_eth, _k, collateral_symbol, collateral_decimals, monetary_policy_address, _llammaId, llammaId, j, lendingInstance_1, originalEstimate_1, oldEstimate, newEstimate;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
+                    case 0:
+                        // @ts-ignore
+                        this.provider = null;
+                        // @ts-ignore
+                        this.signer = null;
+                        this.signerAddress = "";
+                        this.chainId = 1;
+                        // @ts-ignore
+                        this.multicallProvider = null;
+                        this.contracts = {};
+                        this.feeData = {};
+                        this.constantOptions = { gasLimit: 12000000 };
+                        this.options = {};
+                        this.constants = {
+                            ONE_WAY_MARKETS: {},
+                            LLAMMAS: LLAMMAS,
+                            COINS: {},
+                            DECIMALS: {},
+                            NETWORK_NAME: 'ethereum',
+                            ALIASES: {},
+                            ZERO_ADDRESS: ethers.ZeroAddress,
+                            EXCLUDED_PROTOCOLS_1INCH: "",
+                            FACTORY: "0xC9332fdCB1C491Dcc683bAe86Fe3cb70360738BC".toLowerCase(),
+                            PEG_KEEPERS: [
+                                '0x9201da0d97caaaff53f01b2fb56767c7072de340'.toLowerCase(),
+                                '0xfb726f57d251ab5c731e5c64ed4f5f94351ef9f3'.toLowerCase(),
+                                '0x3fa20eaa107de08b38a8734063d605d5842fe09c'.toLowerCase(),
+                                '0x0a05ff644878b908ef8eb29542aa88c07d9797d3'.toLowerCase(),
+                                '0x503E1Bf274e7a6c64152395aE8eB57ec391F91F8'.toLowerCase(),
+                            ],
+                            WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2".toLowerCase(),
+                        };
+                        if (!(providerType.toLowerCase() === 'JsonRpc'.toLowerCase())) return [3 /*break*/, 6];
+                        providerSettings = providerSettings;
+                        jsonRpcApiProviderOptions = void 0;
+                        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);
+                        }
+                        if (!providerSettings.privateKey) return [3 /*break*/, 1];
+                        this.signer = new ethers.Wallet(providerSettings.privateKey, this.provider);
+                        return [3 /*break*/, 5];
+                    case 1:
+                        if (!!((_a = providerSettings.url) === null || _a === void 0 ? void 0 : _a.startsWith("https://rpc.gnosischain.com"))) return [3 /*break*/, 5];
+                        _l.label = 2;
+                    case 2:
+                        _l.trys.push([2, 4, , 5]);
+                        _b = this;
+                        return [4 /*yield*/, this.provider.getSigner()];
+                    case 3:
+                        _b.signer = _l.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_1 = _l.sent();
+                        this.signer = null;
+                        return [3 /*break*/, 5];
+                    case 5: return [3 /*break*/, 9];
+                    case 6:
+                        if (!(providerType.toLowerCase() === 'Web3'.toLowerCase())) return [3 /*break*/, 8];
+                        providerSettings = providerSettings;
+                        this.provider = new ethers.BrowserProvider(providerSettings.externalProvider);
+                        _c = this;
+                        return [4 /*yield*/, this.provider.getSigner()];
+                    case 7:
+                        _c.signer = _l.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        if (providerType.toLowerCase() === 'Infura'.toLowerCase()) {
+                            providerSettings = providerSettings;
+                            this.provider = new ethers.InfuraProvider(providerSettings.network, providerSettings.apiKey);
+                            this.signer = null;
+                            // Alchemy provider
+                        }
+                        else if (providerType.toLowerCase() === 'Alchemy'.toLowerCase()) {
+                            providerSettings = providerSettings;
+                            this.provider = new ethers.AlchemyProvider(providerSettings.network, providerSettings.apiKey);
+                            this.signer = null;
+                        }
+                        else {
+                            throw Error('Wrong providerType');
+                        }
+                        _l.label = 9;
+                    case 9: return [4 /*yield*/, this.provider.getNetwork()];
+                    case 10:
+                        network = _l.sent();
+                        this.chainId = Number(network.chainId) === 133 || Number(network.chainId) === 31337 ? 1 : Number(network.chainId);
+                        console.log("CURVE-LENDING-JS IS CONNECTED TO NETWORK:", { name: network.name.toUpperCase(), chainId: Number(this.chainId) });
+                        if (this.chainId === 42161) {
+                            this.constantOptions = { gasLimit: 1125899906842624 }; // https://arbiscan.io/chart/gaslimit
+                        }
+                        this.constants.NETWORK_NAME = NETWORK_CONSTANTS[this.chainId].NAME;
+                        this.constants.ALIASES = NETWORK_CONSTANTS[this.chainId].ALIASES;
+                        this.constants.COINS = NETWORK_CONSTANTS[this.chainId].COINS;
+                        this.constants.EXCLUDED_PROTOCOLS_1INCH = NETWORK_CONSTANTS[this.chainId].EXCLUDED_PROTOCOLS_1INCH;
+                        this.setContract(this.constants.ALIASES.crv, ERC20ABI);
+                        this.setContract(this.constants.ALIASES.crvUSD, ERC20ABI);
+                        this.setContract(this.constants.ALIASES.st_crvUSD, ERC4626ABI);
+                        this.constants.DECIMALS[this.constants.ALIASES.crv] = 18;
+                        this.constants.DECIMALS[this.constants.ALIASES.crvUSD] = 18;
+                        this.constants.DECIMALS[this.constants.ALIASES.st_crvUSD] = 18;
+                        this.multicallProvider = new MulticallProvider(this.chainId, this.provider);
+                        if (!this.signer) return [3 /*break*/, 15];
+                        _l.label = 11;
+                    case 11:
+                        _l.trys.push([11, 13, , 14]);
+                        _d = this;
+                        return [4 /*yield*/, this.signer.getAddress()];
+                    case 12:
+                        _d.signerAddress = _l.sent();
+                        return [3 /*break*/, 14];
+                    case 13:
+                        err_1 = _l.sent();
+                        this.signer = null;
+                        return [3 /*break*/, 14];
+                    case 14: return [3 /*break*/, 16];
+                    case 15:
+                        this.signerAddress = '';
+                        _l.label = 16;
+                    case 16:
+                        this.feeData = { gasPrice: options.gasPrice, maxFeePerGas: options.maxFeePerGas, maxPriorityFeePerGas: options.maxPriorityFeePerGas };
+                        return [4 /*yield*/, this.updateFeeData()];
+                    case 17:
+                        _l.sent();
+                        // oneWayMarkets contracts
+                        this.setContract(this.constants.ALIASES['one_way_factory'], OneWayLendingFactoryABI);
+                        this.setContract(this.constants.ALIASES['gauge_controller'], GaugeControllerABI);
+                        this.setContract(this.constants.ALIASES['leverage_zap'], LeverageZapABI);
+                        if (this.chainId === 1) {
+                            this.setContract(this.constants.ALIASES.minter, MinterABI);
+                            this.setContract(this.constants.ALIASES.gauge_factory, GaugeFactoryMainnetABI);
+                        }
+                        else {
+                            this.constants.ALIASES.minter = this.constants.ALIASES.gauge_factory;
+                            this.setContract(this.constants.ALIASES.gauge_factory, GaugeFactorySidechainABI);
+                        }
+                        if (!(this.chainId === 1)) return [3 /*break*/, 22];
+                        this.setContract(this.constants.COINS.crvusd.toLowerCase(), ERC20ABI);
+                        _i = 0, _e = Object.values(this.constants.LLAMMAS);
+                        _l.label = 18;
+                    case 18:
+                        if (!(_i < _e.length)) return [3 /*break*/, 21];
+                        llamma = _e[_i];
+                        this.setContract(llamma.amm_address, llammaABI);
+                        this.setContract(llamma.controller_address, controllerABI);
+                        return [4 /*yield*/, this.contracts[llamma.controller_address].contract.monetary_policy(this.constantOptions)];
+                    case 19:
+                        monetary_policy_address = _l.sent();
+                        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);
+                        _l.label = 20;
+                    case 20:
+                        _i++;
+                        return [3 /*break*/, 18];
+                    case 21:
+                        for (_f = 0, _g = this.constants.PEG_KEEPERS; _f < _g.length; _f++) {
+                            pegKeeper = _g[_f];
+                            this.setContract(pegKeeper, PegKeeper);
+                        }
+                        _l.label = 22;
+                    case 22:
+                        // TODO Put it in a separate method
+                        // Fetch new llammas
+                        this.setContract(this.constants.FACTORY, FactoryABI);
+                        factoryContract = this.contracts[this.constants.FACTORY].contract;
+                        factoryMulticallContract = this.contracts[this.constants.FACTORY].multicallContract;
+                        N1 = Object.keys(this.constants.LLAMMAS).length;
+                        return [4 /*yield*/, factoryContract.n_collaterals(this.constantOptions)];
+                    case 23:
+                        N2 = _l.sent();
+                        calls = [];
+                        for (i = N1; i < N2; i++) {
+                            calls.push(factoryMulticallContract.collaterals(i), factoryMulticallContract.amms(i), factoryMulticallContract.controllers(i));
+                        }
+                        return [4 /*yield*/, this.multicallProvider.all(calls)];
+                    case 24:
+                        res = (_l.sent()).map(function (c) { return c.toLowerCase(); });
+                        collaterals = res.filter(function (a, i) { return i % 3 == 0; });
+                        amms = res.filter(function (a, i) { return i % 3 == 1; });
+                        controllers = res.filter(function (a, i) { return i % 3 == 2; });
+                        if (!(collaterals.length > 0)) return [3 /*break*/, 29];
+                        for (_h = 0, collaterals_1 = collaterals; _h < collaterals_1.length; _h++) {
+                            collateral = collaterals_1[_h];
+                            this.setContract(collateral, ERC20ABI);
+                        }
+                        calls = [];
+                        for (_j = 0, collaterals_2 = collaterals; _j < collaterals_2.length; _j++) {
+                            collateral = collaterals_2[_j];
+                            calls.push(this.contracts[collateral].multicallContract.symbol(), this.contracts[collateral].multicallContract.decimals());
+                        }
+                        return [4 /*yield*/, this.multicallProvider.all(calls)];
+                    case 25:
+                        res_1 = (_l.sent()).map(function (x) {
+                            if (typeof x === "string")
+                                return x.toLowerCase();
+                            return x;
+                        });
+                        i = 0;
+                        _l.label = 26;
+                    case 26:
+                        if (!(i < collaterals.length)) return [3 /*break*/, 29];
+                        is_eth = collaterals[i] === this.constants.WETH;
+                        _k = res_1.splice(0, 2), collateral_symbol = _k[0], collateral_decimals = _k[1];
+                        this.setContract(amms[i], llammaABI);
+                        this.setContract(controllers[i], controllerABI);
+                        return [4 /*yield*/, this.contracts[controllers[i]].contract.monetary_policy(this.constantOptions)];
+                    case 27:
+                        monetary_policy_address = (_l.sent()).toLowerCase();
+                        this.setContract(monetary_policy_address, MonetaryPolicy2ABI);
+                        _llammaId = is_eth ? "eth" : collateral_symbol.toLowerCase();
+                        llammaId = _llammaId;
+                        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: monetary_policy_address,
+                            collateral_address: is_eth ? "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" : collaterals[i],
+                            leverage_zap: "0x0000000000000000000000000000000000000000",
+                            deleverage_zap: "0x0000000000000000000000000000000000000000",
+                            collateral_symbol: is_eth ? "ETH" : collateral_symbol,
+                            collateral_decimals: collateral_decimals,
+                            min_bands: 4,
+                            max_bands: 50,
+                            default_bands: 10,
+                            A: 100,
+                            monetary_policy_abi: MonetaryPolicy2ABI,
+                        };
+                        _l.label = 28;
+                    case 28:
+                        i++;
+                        return [3 /*break*/, 26];
+                    case 29:
+                        this.constants.DECIMALS = extractDecimals(this.constants.LLAMMAS);
+                        this.constants.DECIMALS[this.address] = 18;
+                        if (L2Networks.includes(this.chainId)) {
+                            lendingInstance_1 = this;
+                            lendingInstance_1.setContract(lendingInstance_1.constants.ALIASES.gas_oracle, gasOracleABI);
+                            lendingInstance_1.setContract(lendingInstance_1.constants.ALIASES.gas_oracle_blob, gasOracleBlobABI);
+                            // @ts-ignore
+                            if (AbstractProvider.prototype.originalEstimate) {
+                                // @ts-ignore
+                                AbstractProvider.prototype.estimateGas = AbstractProvider.prototype.originalEstimate;
+                            }
+                            originalEstimate_1 = AbstractProvider.prototype.estimateGas;
+                            oldEstimate = function (arg) {
+                                return __awaiter(this, void 0, void 0, function () {
+                                    var originalEstimateFunc, gas;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                originalEstimateFunc = originalEstimate_1.bind(this);
+                                                return [4 /*yield*/, originalEstimateFunc(arg)];
+                                            case 1:
+                                                gas = _a.sent();
+                                                return [2 /*return*/, gas];
+                                        }
+                                    });
+                                });
+                            };
+                            newEstimate = function (arg) {
+                                return __awaiter(this, void 0, void 0, function () {
+                                    var L2EstimateGas, L1GasUsed, L1Fee, L2GasUsed;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                L2EstimateGas = originalEstimate_1.bind(this);
+                                                return [4 /*yield*/, lendingInstance_1.contracts[lendingInstance_1.constants.ALIASES.gas_oracle_blob].contract.getL1GasUsed(arg.data)];
+                                            case 1:
+                                                L1GasUsed = _a.sent();
+                                                return [4 /*yield*/, lendingInstance_1.contracts[lendingInstance_1.constants.ALIASES.gas_oracle_blob].contract.getL1Fee(arg.data)];
+                                            case 2:
+                                                L1Fee = _a.sent();
+                                                lendingInstance_1.L1WeightedGasPrice = Number(L1Fee) / Number(L1GasUsed);
+                                                return [4 /*yield*/, L2EstimateGas(arg)];
+                                            case 3:
+                                                L2GasUsed = _a.sent();
+                                                return [2 /*return*/, [L2GasUsed, L1GasUsed]];
+                                        }
+                                    });
+                                });
+                            };
+                            // @ts-ignore
+                            AbstractProvider.prototype.estimateGas = newEstimate;
+                            // @ts-ignore
+                            AbstractProvider.prototype.originalEstimate = oldEstimate;
+                        }
+                        else {
+                            // @ts-ignore
+                            if (AbstractProvider.prototype.originalEstimate) {
+                                // @ts-ignore
+                                AbstractProvider.prototype.estimateGas = AbstractProvider.prototype.originalEstimate;
+                            }
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Llamalend.prototype.setContract = function (address, abi) {
+        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,
+        };
+    };
+    Llamalend.prototype.setCustomFeeData = function (customFeeData) {
+        this.feeData = __assign(__assign({}, this.feeData), customFeeData);
+    };
+    Llamalend.prototype.formatUnits = function (value, unit) {
+        return ethers.formatUnits(value, unit);
+    };
+    Llamalend.prototype.parseUnits = function (value, unit) {
+        return ethers.parseUnits(value, unit);
+    };
+    Llamalend.prototype.updateFeeData = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var feeData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.provider.getFeeData()];
+                    case 1:
+                        feeData = _a.sent();
+                        if (feeData.maxFeePerGas === null || feeData.maxPriorityFeePerGas === null) {
+                            delete this.options.maxFeePerGas;
+                            delete this.options.maxPriorityFeePerGas;
+                            this.options.gasPrice = this.feeData.gasPrice !== undefined ?
+                                this.parseUnits(this.feeData.gasPrice.toString(), "gwei") :
+                                (feeData.gasPrice || this.parseUnits("20", "gwei"));
+                        }
+                        else {
+                            delete this.options.gasPrice;
+                            this.options.maxFeePerGas = this.feeData.maxFeePerGas !== undefined ?
+                                this.parseUnits(this.feeData.maxFeePerGas.toString(), "gwei") :
+                                feeData.maxFeePerGas;
+                            this.options.maxPriorityFeePerGas = this.feeData.maxPriorityFeePerGas !== undefined ?
+                                this.parseUnits(this.feeData.maxPriorityFeePerGas.toString(), "gwei") :
+                                feeData.maxPriorityFeePerGas;
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Llamalend;
+}());
+export var llamalend = new Llamalend();