@curvefi/llamalend-api 1.0.2

package/lib/utils.js

@@ -0,0 +1,661 @@
+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 axios from "axios";
+import { ethers } from "ethers";
+import BigNumber from 'bignumber.js';
+import { _getUsdPricesFromApi } from "./external-api.js";
+import { llamalend } from "./llamalend.js";
+import { L2Networks } from "./constants/L2Networks.js";
+import memoize from "memoizee";
+export var MAX_ALLOWANCE = BigInt("115792089237316195423570985008687907853269984665640564039457584007913129639935"); // 2**256 - 1
+export var MAX_ACTIVE_BAND = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819967"); // 2**255 - 1
+// Common
+export var createCall = function (contract, name, params) {
+    var _abi = contract.abi;
+    var _name = name.split('-')[0];
+    var func = _abi.find(function (f) { return f.name === _name; });
+    var inputs = (func === null || func === void 0 ? void 0 : func.inputs) || [];
+    var outputs = (func === null || func === void 0 ? void 0 : func.outputs) || [];
+    return {
+        contract: {
+            address: contract.address,
+        },
+        name: _name,
+        inputs: inputs,
+        outputs: outputs,
+        params: params,
+    };
+};
+// Formatting numbers
+export var _cutZeros = function (strn) {
+    return strn.replace(/0+$/gi, '').replace(/\.$/gi, '');
+};
+export var checkNumber = function (n) {
+    if (Number(n) !== Number(n))
+        throw Error("".concat(n, " is not a number")); // NaN
+    return n;
+};
+export var formatNumber = function (n, decimals) {
+    if (decimals === void 0) { decimals = 18; }
+    n = checkNumber(n);
+    var _a = String(n).split("."), integer = _a[0], fractional = _a[1];
+    return !fractional ? integer : integer + "." + fractional.slice(0, decimals);
+};
+export var formatUnits = function (value, unit) {
+    return ethers.formatUnits(value, unit);
+};
+export var parseUnits = function (n, decimals) {
+    if (decimals === void 0) { decimals = 18; }
+    return ethers.parseUnits(formatNumber(n, decimals), decimals);
+};
+// bignumber.js
+export var BN = function (val) { return new BigNumber(checkNumber(val)); };
+export var toBN = function (n, decimals) {
+    if (decimals === void 0) { decimals = 18; }
+    return BN(formatUnits(n, decimals));
+};
+export var toStringFromBN = function (bn, decimals) {
+    if (decimals === void 0) { decimals = 18; }
+    return bn.toFixed(decimals);
+};
+export var fromBN = function (bn, decimals) {
+    if (decimals === void 0) { decimals = 18; }
+    return parseUnits(toStringFromBN(bn, decimals), decimals);
+};
+// -----------------------------------------------------------------------------------------------
+export var ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export var isEth = function (address) { return address.toLowerCase() === ETH_ADDRESS.toLowerCase(); };
+export var getEthIndex = function (addresses) { return addresses.map(function (address) { return address.toLowerCase(); }).indexOf(ETH_ADDRESS.toLowerCase()); };
+export var _mulBy1_3 = function (n) { return n * parseUnits("130", 0) / parseUnits("100", 0); };
+export var smartNumber = function (abstractNumber) {
+    if (Array.isArray(abstractNumber)) {
+        return [Number(abstractNumber[0]), Number(abstractNumber[1])];
+    }
+    else {
+        return Number(abstractNumber);
+    }
+};
+export var DIGas = function (gas) {
+    if (Array.isArray(gas)) {
+        return gas[0];
+    }
+    else {
+        return gas;
+    }
+};
+export var getGasFromArray = function (gas) {
+    if (gas[1] === 0) {
+        return gas[0];
+    }
+    else {
+        return gas;
+    }
+};
+export var gasSum = function (gas, currentGas) {
+    if (Array.isArray(currentGas)) {
+        gas[0] = gas[0] + currentGas[0];
+        gas[1] = gas[1] + currentGas[1];
+    }
+    else {
+        gas[0] = gas[0] + currentGas;
+    }
+    return gas;
+};
+export var _getAddress = function (address) {
+    address = address || llamalend.signerAddress;
+    if (!address)
+        throw Error("Need to connect wallet or pass address into args");
+    return address;
+};
+export var handleMultiCallResponse = function (callsMap, response) {
+    var result = {};
+    var responseLength = callsMap.length;
+    var _loop_1 = function (i) {
+        result[callsMap[i]] = response.filter(function (a, j) { return j % responseLength === i; });
+    };
+    for (var i = 0; i < responseLength; i++) {
+        _loop_1(i);
+    }
+    return result;
+};
+// coins can be either addresses or symbols
+export var _getCoinAddressesNoCheck = function () {
+    var coins = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        coins[_i] = arguments[_i];
+    }
+    if (coins.length == 1 && Array.isArray(coins[0]))
+        coins = coins[0];
+    coins = coins;
+    return coins.map(function (c) { return c.toLowerCase(); }).map(function (c) { return llamalend.constants.COINS[c] || c; });
+};
+export var _getCoinAddresses = function (coins) {
+    var coinAddresses = _getCoinAddressesNoCheck(coins);
+    var availableAddresses = Object.keys(llamalend.constants.DECIMALS);
+    for (var _i = 0, coinAddresses_1 = coinAddresses; _i < coinAddresses_1.length; _i++) {
+        var coinAddr = coinAddresses_1[_i];
+        if (!availableAddresses.includes(coinAddr))
+            throw Error("Coin with address '".concat(coinAddr, "' is not available"));
+    }
+    return coinAddresses;
+};
+export var _getCoinDecimals = function (coinAddresses) {
+    return coinAddresses.map(function (coinAddr) { var _a; return (_a = llamalend.constants.DECIMALS[coinAddr.toLowerCase()]) !== null && _a !== void 0 ? _a : 18; });
+};
+// --- BALANCES ---
+export var _getBalances = function (coinAddresses, address) {
+    if (address === void 0) { address = ""; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _coinAddresses, ethIndex, contractCalls, _i, _coinAddresses_1, coinAddr, _balances, ethBalance;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    address = _getAddress(address);
+                    _coinAddresses = __spreadArray([], coinAddresses, true);
+                    ethIndex = getEthIndex(_coinAddresses);
+                    if (ethIndex !== -1) {
+                        _coinAddresses.splice(ethIndex, 1);
+                    }
+                    contractCalls = [];
+                    for (_i = 0, _coinAddresses_1 = _coinAddresses; _i < _coinAddresses_1.length; _i++) {
+                        coinAddr = _coinAddresses_1[_i];
+                        contractCalls.push(llamalend.contracts[coinAddr].multicallContract.balanceOf(address));
+                    }
+                    return [4 /*yield*/, llamalend.multicallProvider.all(contractCalls)];
+                case 1:
+                    _balances = _a.sent();
+                    if (!(ethIndex !== -1)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, llamalend.provider.getBalance(address)];
+                case 2:
+                    ethBalance = _a.sent();
+                    _balances.splice(ethIndex, 0, ethBalance);
+                    _a.label = 3;
+                case 3: return [2 /*return*/, _balances];
+            }
+        });
+    });
+};
+export var getBalances = function (coins, address) {
+    if (address === void 0) { address = ""; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var coinAddresses, decimals, _balances;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    coinAddresses = _getCoinAddresses(coins);
+                    decimals = _getCoinDecimals(coinAddresses);
+                    return [4 /*yield*/, _getBalances(coinAddresses, address)];
+                case 1:
+                    _balances = _a.sent();
+                    return [2 /*return*/, _balances.map(function (_b, i) { return formatUnits(_b, decimals[i]); })];
+            }
+        });
+    });
+};
+export var _getAllowance = memoize(function (coins, address, spender) { return __awaiter(void 0, void 0, void 0, function () {
+    var _coins, ethIndex, allowance, contractCalls;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _coins = __spreadArray([], coins, true);
+                ethIndex = getEthIndex(_coins);
+                if (ethIndex !== -1) {
+                    _coins.splice(ethIndex, 1);
+                }
+                if (!(_coins.length === 1)) return [3 /*break*/, 2];
+                return [4 /*yield*/, llamalend.contracts[_coins[0]].contract.allowance(address, spender, llamalend.constantOptions)];
+            case 1:
+                allowance = [_a.sent()];
+                return [3 /*break*/, 4];
+            case 2:
+                contractCalls = _coins.map(function (coinAddr) { return llamalend.contracts[coinAddr].multicallContract.allowance(address, spender); });
+                return [4 /*yield*/, llamalend.multicallProvider.all(contractCalls)];
+            case 3:
+                allowance = _a.sent();
+                _a.label = 4;
+            case 4:
+                if (ethIndex !== -1) {
+                    allowance.splice(ethIndex, 0, MAX_ALLOWANCE);
+                }
+                return [2 /*return*/, allowance];
+        }
+    });
+}); }, {
+    promise: true,
+    maxAge: 5 * 1000,
+    primitive: true,
+    length: 3,
+});
+// coins can be either addresses or symbols
+export var getAllowance = function (coins, address, spender) { return __awaiter(void 0, void 0, void 0, function () {
+    var coinAddresses, decimals, _allowance;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                coinAddresses = _getCoinAddresses(coins);
+                decimals = _getCoinDecimals(coinAddresses);
+                return [4 /*yield*/, _getAllowance(coinAddresses, address, spender)];
+            case 1:
+                _allowance = _a.sent();
+                return [2 /*return*/, _allowance.map(function (a, i) { return llamalend.formatUnits(a, decimals[i]); })];
+        }
+    });
+}); };
+// coins can be either addresses or symbols
+export var hasAllowance = function (coins, amounts, address, spender) { return __awaiter(void 0, void 0, void 0, function () {
+    var coinAddresses, decimals, _allowance, _amounts;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                coinAddresses = _getCoinAddresses(coins);
+                decimals = _getCoinDecimals(coinAddresses);
+                return [4 /*yield*/, _getAllowance(coinAddresses, address, spender)];
+            case 1:
+                _allowance = _a.sent();
+                _amounts = amounts.map(function (a, i) { return parseUnits(a, decimals[i]); });
+                return [2 /*return*/, _allowance.map(function (a, i) { return a >= _amounts[i]; }).reduce(function (a, b) { return a && b; })];
+        }
+    });
+}); };
+export var _ensureAllowance = function (coins, _amounts, spender, isMax) {
+    if (isMax === void 0) { isMax = true; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var address, _allowance, txHashes, i, contract, _approveAmount, gasLimit, _a, _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    address = llamalend.signerAddress;
+                    return [4 /*yield*/, _getAllowance(coins, address, spender)];
+                case 1:
+                    _allowance = _f.sent();
+                    txHashes = [];
+                    i = 0;
+                    _f.label = 2;
+                case 2:
+                    if (!(i < _allowance.length)) return [3 /*break*/, 7];
+                    if (!(_allowance[i] < _amounts[i])) return [3 /*break*/, 6];
+                    contract = llamalend.contracts[coins[i]].contract;
+                    _approveAmount = isMax ? MAX_ALLOWANCE : _amounts[i];
+                    return [4 /*yield*/, llamalend.updateFeeData()];
+                case 3:
+                    _f.sent();
+                    _a = _mulBy1_3;
+                    _c = DIGas;
+                    return [4 /*yield*/, contract.approve.estimateGas(spender, _approveAmount, llamalend.constantOptions)];
+                case 4:
+                    gasLimit = _a.apply(void 0, [_c.apply(void 0, [_f.sent()])]);
+                    _e = (_d = txHashes).push;
+                    return [4 /*yield*/, contract.approve(spender, _approveAmount, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                case 5:
+                    _e.apply(_d, [(_f.sent()).hash]);
+                    _f.label = 6;
+                case 6:
+                    i++;
+                    return [3 /*break*/, 2];
+                case 7: return [2 /*return*/, txHashes];
+            }
+        });
+    });
+};
+// coins can be either addresses or symbols
+export var ensureAllowanceEstimateGas = function (coins, amounts, spender, isMax) {
+    if (isMax === void 0) { isMax = true; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var coinAddresses, decimals, _amounts, _allowance, gas, i, contract, _approveAmount, currentGas, _a;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    coinAddresses = _getCoinAddresses(coins);
+                    decimals = _getCoinDecimals(coinAddresses);
+                    _amounts = amounts.map(function (a, i) { return parseUnits(a, decimals[i]); });
+                    return [4 /*yield*/, _getAllowance(coinAddresses, llamalend.signerAddress, spender)];
+                case 1:
+                    _allowance = _c.sent();
+                    gas = [0, 0];
+                    i = 0;
+                    _c.label = 2;
+                case 2:
+                    if (!(i < _allowance.length)) return [3 /*break*/, 5];
+                    if (!(_allowance[i] < _amounts[i])) return [3 /*break*/, 4];
+                    contract = llamalend.contracts[coinAddresses[i]].contract;
+                    _approveAmount = isMax ? MAX_ALLOWANCE : _amounts[i];
+                    _a = smartNumber;
+                    return [4 /*yield*/, contract.approve.estimateGas(spender, _approveAmount, llamalend.constantOptions)];
+                case 3:
+                    currentGas = _a.apply(void 0, [_c.sent()]);
+                    gas = gasSum(gas, currentGas);
+                    _c.label = 4;
+                case 4:
+                    i++;
+                    return [3 /*break*/, 2];
+                case 5: return [2 /*return*/, getGasFromArray(gas)];
+            }
+        });
+    });
+};
+// coins can be either addresses or symbols
+export var ensureAllowance = function (coins, amounts, spender, isMax) {
+    if (isMax === void 0) { isMax = true; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var coinAddresses, decimals, _amounts;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    coinAddresses = _getCoinAddresses(coins);
+                    decimals = _getCoinDecimals(coinAddresses);
+                    _amounts = amounts.map(function (a, i) { return parseUnits(a, decimals[i]); });
+                    return [4 /*yield*/, _ensureAllowance(coinAddresses, _amounts, spender, isMax)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+};
+var _usdRatesCache = {};
+export var _getUsdRate = function (assetId) { return __awaiter(void 0, void 0, void 0, function () {
+    var pricesFromApi, chainName, nativeTokenName, url, response;
+    var _a, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                if (llamalend.chainId === 1 && assetId.toLowerCase() === '0x8762db106b2c2a0bccb3a80d1ed41273552616e8')
+                    return [2 /*return*/, 0]; // RSR
+                return [4 /*yield*/, _getUsdPricesFromApi()];
+            case 1:
+                pricesFromApi = _d.sent();
+                if (assetId.toLowerCase() in pricesFromApi)
+                    return [2 /*return*/, pricesFromApi[assetId.toLowerCase()]];
+                if (assetId === 'USD' || (llamalend.chainId === 137 && (assetId.toLowerCase() === llamalend.constants.COINS.am3crv.toLowerCase())))
+                    return [2 /*return*/, 1];
+                chainName = {
+                    1: 'ethereum',
+                    10: 'optimistic-ethereum',
+                    56: "binance-smart-chain",
+                    100: 'xdai',
+                    137: 'polygon-pos',
+                    156: 'sonic',
+                    196: 'x-layer',
+                    250: 'fantom',
+                    252: 'fraxtal',
+                    324: 'zksync',
+                    1284: 'moonbeam',
+                    2222: 'kava',
+                    5000: 'mantle',
+                    8453: 'base',
+                    42220: 'celo',
+                    43114: 'avalanche',
+                    42161: 'arbitrum-one',
+                    1313161554: 'aurora',
+                }[llamalend.chainId];
+                nativeTokenName = {
+                    1: 'ethereum',
+                    10: 'ethereum',
+                    56: 'binancecoin',
+                    100: 'xdai',
+                    137: 'matic-network',
+                    156: 'sonic-3',
+                    196: 'okb',
+                    250: 'fantom',
+                    252: 'frax-ether',
+                    324: 'ethereum',
+                    1284: 'moonbeam',
+                    2222: 'kava',
+                    5000: 'mantle',
+                    8453: 'ethereum',
+                    42220: 'celo',
+                    43114: 'avalanche-2',
+                    42161: 'ethereum',
+                    1313161554: 'ethereum',
+                }[llamalend.chainId];
+                if (chainName === undefined) {
+                    throw Error('curve object is not initialized');
+                }
+                assetId = {
+                    'CRV': 'curve-dao-token',
+                    'EUR': 'stasis-eurs',
+                    'BTC': 'bitcoin',
+                    'ETH': 'ethereum',
+                    'LINK': 'link',
+                }[assetId.toUpperCase()] || assetId;
+                assetId = isEth(assetId) ? nativeTokenName : assetId.toLowerCase();
+                // No EURT on Coingecko Polygon
+                if (llamalend.chainId === 137 && assetId.toLowerCase() === llamalend.constants.COINS.eurt) {
+                    chainName = 'ethereum';
+                    assetId = '0xC581b735A1688071A1746c968e0798D642EDE491'.toLowerCase(); // EURT Ethereum
+                }
+                // CRV
+                if (assetId.toLowerCase() === llamalend.constants.ALIASES.crv) {
+                    assetId = 'curve-dao-token';
+                }
+                if (!((((_a = _usdRatesCache[assetId]) === null || _a === void 0 ? void 0 : _a.time) || 0) + 600000 < Date.now())) return [3 /*break*/, 3];
+                url = [nativeTokenName, 'ethereum', 'bitcoin', 'link', 'curve-dao-token', 'stasis-eurs'].includes(assetId.toLowerCase()) ?
+                    "https://api.coingecko.com/api/v3/simple/price?ids=".concat(assetId, "&vs_currencies=usd") :
+                    "https://api.coingecko.com/api/v3/simple/token_price/".concat(chainName, "?contract_addresses=").concat(assetId, "&vs_currencies=usd");
+                return [4 /*yield*/, axios.get(url)];
+            case 2:
+                response = _d.sent();
+                try {
+                    _usdRatesCache[assetId] = { 'rate': (_c = response.data[assetId]['usd']) !== null && _c !== void 0 ? _c : 0, 'time': Date.now() };
+                }
+                catch (err) { // TODO pay attention!
+                    _usdRatesCache[assetId] = { 'rate': 0, 'time': Date.now() };
+                }
+                _d.label = 3;
+            case 3: return [2 /*return*/, _usdRatesCache[assetId]['rate']];
+        }
+    });
+}); };
+export var getUsdRate = function (coin) { return __awaiter(void 0, void 0, void 0, function () {
+    var coinAddress;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                coinAddress = _getCoinAddressesNoCheck(coin)[0];
+                return [4 /*yield*/, _getUsdRate(coinAddress)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+export var getBaseFeeByLastBlock = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var provider, block, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                provider = llamalend.provider;
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, provider.getBlock('latest')];
+            case 2:
+                block = _a.sent();
+                if (!block) {
+                    return [2 /*return*/, 0.01];
+                }
+                return [2 /*return*/, Number(block.baseFeePerGas) / (Math.pow(10, 9))];
+            case 3:
+                error_1 = _a.sent();
+                throw new Error(error_1);
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+export var getGasPriceFromL1 = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (L2Networks.includes(llamalend.chainId) && llamalend.L1WeightedGasPrice) {
+            return [2 /*return*/, llamalend.L1WeightedGasPrice + 1e9]; // + 1 gwei
+        }
+        else {
+            throw Error("This method exists only for L2 networks");
+        }
+        return [2 /*return*/];
+    });
+}); };
+export var getGasPriceFromL2 = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var e_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(llamalend.chainId === 42161)) return [3 /*break*/, 5];
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, getBaseFeeByLastBlock()];
+            case 2: return [2 /*return*/, _a.sent()];
+            case 3:
+                e_1 = _a.sent();
+                throw Error(e_1);
+            case 4: return [3 /*break*/, 6];
+            case 5: throw Error("This method exists only for ARBITRUM network");
+            case 6: return [2 /*return*/];
+        }
+    });
+}); };
+export var getGasInfoForL2 = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var baseFee, e_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(llamalend.chainId === 42161)) return [3 /*break*/, 5];
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, getBaseFeeByLastBlock()];
+            case 2:
+                baseFee = _a.sent();
+                return [2 /*return*/, {
+                        maxFeePerGas: Number(((baseFee * 1.1) + 0.01).toFixed(2)),
+                        maxPriorityFeePerGas: 0.01,
+                    }];
+            case 3:
+                e_2 = _a.sent();
+                throw Error(e_2);
+            case 4: return [3 /*break*/, 6];
+            case 5: throw Error("This method exists only for ARBITRUM network");
+            case 6: return [2 /*return*/];
+        }
+    });
+}); };
+export var totalSupply = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var calls, _i, _a, llammaId, controllerAddress, controllerContract, _c, _d, pegKeeper, res, mintedBN, i, _e, _minted, _redeemed, pegKeepersBN, _f, res_1, _pegKeeperDebt;
+    return __generator(this, function (_g) {
+        switch (_g.label) {
+            case 0:
+                calls = [];
+                for (_i = 0, _a = llamalend.getMintMarketList(); _i < _a.length; _i++) {
+                    llammaId = _a[_i];
+                    controllerAddress = llamalend.constants.LLAMMAS[llammaId].controller_address;
+                    controllerContract = llamalend.contracts[controllerAddress].multicallContract;
+                    calls.push(controllerContract.minted(), controllerContract.redeemed());
+                }
+                for (_c = 0, _d = llamalend.constants.PEG_KEEPERS; _c < _d.length; _c++) {
+                    pegKeeper = _d[_c];
+                    calls.push(llamalend.contracts[pegKeeper].multicallContract.debt());
+                }
+                return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+            case 1:
+                res = _g.sent();
+                mintedBN = BN(0);
+                for (i = 0; i < llamalend.getMintMarketList().length; i++) {
+                    _e = res.splice(0, 2), _minted = _e[0], _redeemed = _e[1];
+                    mintedBN = toBN(_minted).minus(toBN(_redeemed)).plus(mintedBN);
+                }
+                pegKeepersBN = BN(0);
+                for (_f = 0, res_1 = res; _f < res_1.length; _f++) {
+                    _pegKeeperDebt = res_1[_f];
+                    pegKeepersBN = pegKeepersBN.plus(toBN(_pegKeeperDebt));
+                }
+                return [2 /*return*/, { total: mintedBN.plus(pegKeepersBN).toString(), minted: mintedBN.toString(), pegKeepersDebt: pegKeepersBN.toString() }];
+        }
+    });
+}); };
+export var getLsdApy = memoize(function (name) { return __awaiter(void 0, void 0, void 0, function () {
+    var response, data, params, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, axios.get('https://yields.llama.fi/pools')];
+            case 1:
+                response = _a.sent();
+                data = response.data;
+                params = {
+                    'wstETH': {
+                        project: 'lido',
+                        symbol: 'STETH',
+                    },
+                    'sfrxETH': {
+                        project: 'frax-ether',
+                        symbol: 'SFRXETH',
+                    },
+                };
+                result = data.find(function (_a) {
+                    var chain = _a.chain, project = _a.project, symbol = _a.symbol;
+                    return (chain === 'Ethereum' &&
+                        project === params[name].project &&
+                        symbol === params[name].symbol);
+                });
+                if (result) {
+                    return [2 /*return*/, {
+                            apy: result.apy,
+                            baseApy: result.apyBase,
+                            apyMean30d: result.apyMean30d,
+                        }];
+                }
+                throw new Error('Pool not found');
+        }
+    });
+}); }, {
+    promise: true,
+    maxAge: 60 * 1000, // 1m
+});