@curvefi/api 2.31.1 → 2.33.0

package/lib/utils.js

@@ -1,3 +1,59 @@
+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 { Contract } from 'ethers';
 import { Contract as MulticallContract } from "ethcall";
@@ -5,398 +61,648 @@ import BigNumber from 'bignumber.js';
 import { curve, NETWORK_CONSTANTS } from "./curve.js";
 import { _getFactoryAPYsAndVolumes, _getLegacyAPYsAndVolumes, _getPoolsFromApi, _getSubgraphData } from "./external-api.js";
 import ERC20Abi from './constants/abis/ERC20.json' assert { type: 'json' };
-export const ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-export const MAX_ALLOWANCE = (2n ** 256n) - 1n;
+export var ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+// export const MAX_ALLOWANCE = curve.parseUnits(new BigNumber(2).pow(256).minus(1).toFixed(), 0);
+export var MAX_ALLOWANCE = BigInt("115792089237316195423570985008687907853269984665640564039457584007913129639935"); // 2**256 - 1
 // Formatting numbers
-export const _cutZeros = (strn) => {
+export var _cutZeros = function (strn) {
     return strn.replace(/0+$/gi, '').replace(/\.$/gi, '');
 };
-export const checkNumber = (n) => {
+export var checkNumber = function (n) {
     if (Number(n) !== Number(n))
-        throw Error(`${n} is not a number`); // NaN
+        throw Error("".concat(n, " is not a number")); // NaN
     return n;
 };
-export const formatNumber = (n, decimals = 18) => {
+export var formatNumber = function (n, decimals) {
+    if (decimals === void 0) { decimals = 18; }
     if (Number(n) !== Number(n))
-        throw Error(`${n} is not a number`); // NaN
-    const [integer, fractional] = String(n).split(".");
+        throw Error("".concat(n, " is not a number")); // NaN
+    var _a = String(n).split("."), integer = _a[0], fractional = _a[1];
     return !fractional ? integer : integer + "." + fractional.slice(0, decimals);
 };
-export const parseUnits = (n, decimals = 18) => {
+export var parseUnits = function (n, decimals) {
+    if (decimals === void 0) { decimals = 18; }
     return curve.parseUnits(formatNumber(n, decimals), decimals);
 };
 // bignumber.js
-export const BN = (val) => new BigNumber(checkNumber(val));
-export const toBN = (n, decimals = 18) => {
+export var BN = function (val) { return new BigNumber(checkNumber(val)); };
+export var toBN = function (n, decimals) {
+    if (decimals === void 0) { decimals = 18; }
     return BN(curve.formatUnits(n, decimals));
 };
-export const toStringFromBN = (bn, decimals = 18) => {
+export var toStringFromBN = function (bn, decimals) {
+    if (decimals === void 0) { decimals = 18; }
     return bn.toFixed(decimals);
 };
-export const fromBN = (bn, decimals = 18) => {
+export var fromBN = function (bn, decimals) {
+    if (decimals === void 0) { decimals = 18; }
     return curve.parseUnits(toStringFromBN(bn, decimals), decimals);
 };
 // -------------------
-export const isEth = (address) => address.toLowerCase() === ETH_ADDRESS.toLowerCase();
-export const getEthIndex = (addresses) => addresses.map((address) => address.toLowerCase()).indexOf(ETH_ADDRESS.toLowerCase());
-export const mulBy1_3 = (n) => n * 130n / 100n;
+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 * curve.parseUnits("130", 0) / curve.parseUnits("100", 0); };
 // coins can be either addresses or symbols
-export const _getCoinAddressesNoCheck = (...coins) => {
+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((c) => c.toLowerCase()).map((c) => curve.constants.COINS[c] || c);
+    return coins.map(function (c) { return c.toLowerCase(); }).map(function (c) { return curve.constants.COINS[c] || c; });
 };
-export const _getCoinAddresses = (...coins) => {
-    const coinAddresses = _getCoinAddressesNoCheck(...coins);
-    const availableAddresses = [...Object.keys(curve.constants.DECIMALS), ...curve.constants.GAUGES];
-    for (const coinAddr of coinAddresses) {
+export var _getCoinAddresses = function () {
+    var coins = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        coins[_i] = arguments[_i];
+    }
+    var coinAddresses = _getCoinAddressesNoCheck.apply(void 0, coins);
+    var availableAddresses = __spreadArray(__spreadArray([], Object.keys(curve.constants.DECIMALS), true), curve.constants.GAUGES, true);
+    for (var _a = 0, coinAddresses_1 = coinAddresses; _a < coinAddresses_1.length; _a++) {
+        var coinAddr = coinAddresses_1[_a];
         if (!availableAddresses.includes(coinAddr))
-            throw Error(`Coin with address '${coinAddr}' is not available`);
+            throw Error("Coin with address '".concat(coinAddr, "' is not available"));
     }
     return coinAddresses;
 };
-export const _getCoinDecimals = (...coinAddresses) => {
+export var _getCoinDecimals = function () {
+    var coinAddresses = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        coinAddresses[_i] = arguments[_i];
+    }
     if (coinAddresses.length == 1 && Array.isArray(coinAddresses[0]))
         coinAddresses = coinAddresses[0];
     coinAddresses = coinAddresses;
-    return coinAddresses.map((coinAddr) => curve.constants.DECIMALS[coinAddr.toLowerCase()] ?? 18); // 18 for gauges
-};
-export const _getBalances = async (coins, addresses) => {
-    const coinAddresses = _getCoinAddresses(coins);
-    const decimals = _getCoinDecimals(coinAddresses);
-    const ethIndex = getEthIndex(coinAddresses);
-    if (ethIndex !== -1) {
-        coinAddresses.splice(ethIndex, 1);
-    }
-    const contractCalls = [];
-    for (const coinAddr of coinAddresses) {
-        contractCalls.push(...addresses.map((address) => curve.contracts[coinAddr].multicallContract.balanceOf(address)));
-    }
-    const _response = await curve.multicallProvider.all(contractCalls);
-    if (ethIndex !== -1) {
-        const ethBalances = [];
-        for (const address of addresses) {
-            ethBalances.push(await curve.provider.getBalance(address));
+    return coinAddresses.map(function (coinAddr) { var _a; return (_a = curve.constants.DECIMALS[coinAddr.toLowerCase()]) !== null && _a !== void 0 ? _a : 18; }); // 18 for gauges
+};
+export var _getBalances = function (coins, addresses) { return __awaiter(void 0, void 0, void 0, function () {
+    var coinAddresses, decimals, ethIndex, contractCalls, _loop_1, _i, coinAddresses_2, coinAddr, _response, ethBalances, _a, addresses_1, address, _b, _c, _balances, balances, _d, addresses_2, address;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                coinAddresses = _getCoinAddresses(coins);
+                decimals = _getCoinDecimals(coinAddresses);
+                ethIndex = getEthIndex(coinAddresses);
+                if (ethIndex !== -1) {
+                    coinAddresses.splice(ethIndex, 1);
+                }
+                contractCalls = [];
+                _loop_1 = function (coinAddr) {
+                    contractCalls.push.apply(contractCalls, addresses.map(function (address) { return curve.contracts[coinAddr].multicallContract.balanceOf(address); }));
+                };
+                for (_i = 0, coinAddresses_2 = coinAddresses; _i < coinAddresses_2.length; _i++) {
+                    coinAddr = coinAddresses_2[_i];
+                    _loop_1(coinAddr);
+                }
+                return [4 /*yield*/, curve.multicallProvider.all(contractCalls)];
+            case 1:
+                _response = _e.sent();
+                if (!(ethIndex !== -1)) return [3 /*break*/, 6];
+                ethBalances = [];
+                _a = 0, addresses_1 = addresses;
+                _e.label = 2;
+            case 2:
+                if (!(_a < addresses_1.length)) return [3 /*break*/, 5];
+                address = addresses_1[_a];
+                _c = (_b = ethBalances).push;
+                return [4 /*yield*/, curve.provider.getBalance(address)];
+            case 3:
+                _c.apply(_b, [_e.sent()]);
+                _e.label = 4;
+            case 4:
+                _a++;
+                return [3 /*break*/, 2];
+            case 5:
+                _response.splice.apply(_response, __spreadArray([ethIndex * addresses.length, 0], ethBalances, false));
+                _e.label = 6;
+            case 6:
+                _balances = {};
+                addresses.forEach(function (address, i) {
+                    _balances[address] = coins.map(function (_, j) { return _response[i + (j * addresses.length)]; });
+                });
+                balances = {};
+                for (_d = 0, addresses_2 = addresses; _d < addresses_2.length; _d++) {
+                    address = addresses_2[_d];
+                    balances[address] = _balances[address].map(function (b, i) { return curve.formatUnits(b, decimals[i]); });
+                }
+                return [2 /*return*/, balances];
         }
-        _response.splice(ethIndex * addresses.length, 0, ...ethBalances);
-    }
-    const _balances = {};
-    addresses.forEach((address, i) => {
-        _balances[address] = coins.map((_, j) => _response[i + (j * addresses.length)]);
     });
-    const balances = {};
-    for (const address of addresses) {
-        balances[address] = _balances[address].map((b, i) => curve.formatUnits(b, decimals[i]));
-    }
-    return balances;
-};
-export const _prepareAddresses = (addresses) => {
+}); };
+export var _prepareAddresses = function (addresses) {
     if (addresses.length == 1 && Array.isArray(addresses[0]))
         addresses = addresses[0];
     if (addresses.length === 0 && curve.signerAddress !== '')
         addresses = [curve.signerAddress];
     addresses = addresses;
-    return addresses.filter((val, idx, arr) => arr.indexOf(val) === idx);
+    return addresses.filter(function (val, idx, arr) { return arr.indexOf(val) === idx; });
 };
-export const getBalances = async (coins, ...addresses) => {
-    addresses = _prepareAddresses(addresses);
-    const balances = await _getBalances(coins, addresses);
-    return addresses.length === 1 ? balances[addresses[0]] : balances;
-};
-export const _getAllowance = async (coins, address, spender) => {
-    const _coins = [...coins];
-    const ethIndex = getEthIndex(_coins);
-    if (ethIndex !== -1) {
-        _coins.splice(ethIndex, 1);
-    }
-    let allowance;
-    if (_coins.length === 1) {
-        allowance = [await curve.contracts[_coins[0]].contract.allowance(address, spender, curve.constantOptions)];
+export var getBalances = function (coins) {
+    var addresses = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        addresses[_i - 1] = arguments[_i];
     }
-    else {
-        const contractCalls = _coins.map((coinAddr) => curve.contracts[coinAddr].multicallContract.allowance(address, spender));
-        allowance = await curve.multicallProvider.all(contractCalls);
-    }
-    if (ethIndex !== -1) {
-        allowance.splice(ethIndex, 0, MAX_ALLOWANCE);
-    }
-    return allowance;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var balances;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    addresses = _prepareAddresses(addresses);
+                    return [4 /*yield*/, _getBalances(coins, addresses)];
+                case 1:
+                    balances = _a.sent();
+                    return [2 /*return*/, addresses.length === 1 ? balances[addresses[0]] : balances];
+            }
+        });
+    });
 };
+export var _getAllowance = 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*/, curve.contracts[_coins[0]].contract.allowance(address, spender, curve.constantOptions)];
+            case 1:
+                allowance = [_a.sent()];
+                return [3 /*break*/, 4];
+            case 2:
+                contractCalls = _coins.map(function (coinAddr) { return curve.contracts[coinAddr].multicallContract.allowance(address, spender); });
+                return [4 /*yield*/, curve.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];
+        }
+    });
+}); };
 // coins can be either addresses or symbols
-export const getAllowance = async (coins, address, spender) => {
-    const coinAddresses = _getCoinAddresses(coins);
-    const decimals = _getCoinDecimals(coinAddresses);
-    const _allowance = await _getAllowance(coinAddresses, address, spender);
-    return _allowance.map((a, i) => curve.formatUnits(a, decimals[i]));
-};
+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 curve.formatUnits(a, decimals[i]); })];
+        }
+    });
+}); };
 // coins can be either addresses or symbols
-export const hasAllowance = async (coins, amounts, address, spender) => {
-    const coinAddresses = _getCoinAddresses(coins);
-    const decimals = _getCoinDecimals(coinAddresses);
-    const _allowance = await _getAllowance(coinAddresses, address, spender);
-    const _amounts = amounts.map((a, i) => parseUnits(a, decimals[i]));
-    return _allowance.map((a, i) => a >= _amounts[i]).reduce((a, b) => a && b);
-};
-export const _ensureAllowance = async (coins, amounts, spender, isMax = true) => {
-    const address = curve.signerAddress;
-    const allowance = await _getAllowance(coins, address, spender);
-    const txHashes = [];
-    for (let i = 0; i < allowance.length; i++) {
-        if (allowance[i] < amounts[i]) {
-            const contract = curve.contracts[coins[i]].contract;
-            const _approveAmount = isMax ? MAX_ALLOWANCE : amounts[i];
-            await curve.updateFeeData();
-            if (allowance[i] > 0n) {
-                const gasLimit = mulBy1_3(await contract.approve.estimateGas(spender, 0n, curve.constantOptions));
-                txHashes.push((await contract.approve(spender, 0n, { ...curve.options, gasLimit })).hash);
-            }
-            const gasLimit = mulBy1_3(await contract.approve.estimateGas(spender, _approveAmount, curve.constantOptions));
-            txHashes.push((await contract.approve(spender, _approveAmount, { ...curve.options, gasLimit })).hash);
+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; })];
         }
-    }
-    return txHashes;
+    });
+}); };
+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_1, _a, _b, _c, gasLimit, _d, _e, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    address = curve.signerAddress;
+                    return [4 /*yield*/, _getAllowance(coins, address, spender)];
+                case 1:
+                    allowance = _g.sent();
+                    txHashes = [];
+                    i = 0;
+                    _g.label = 2;
+                case 2:
+                    if (!(i < allowance.length)) return [3 /*break*/, 10];
+                    if (!(allowance[i] < amounts[i])) return [3 /*break*/, 9];
+                    contract = curve.contracts[coins[i]].contract;
+                    _approveAmount = isMax ? MAX_ALLOWANCE : amounts[i];
+                    return [4 /*yield*/, curve.updateFeeData()];
+                case 3:
+                    _g.sent();
+                    if (!(allowance[i] > curve.parseUnits("0"))) return [3 /*break*/, 6];
+                    _a = mulBy1_3;
+                    return [4 /*yield*/, contract.approve.estimateGas(spender, curve.parseUnits("0"), curve.constantOptions)];
+                case 4:
+                    gasLimit_1 = _a.apply(void 0, [_g.sent()]);
+                    _c = (_b = txHashes).push;
+                    return [4 /*yield*/, contract.approve(spender, curve.parseUnits("0"), __assign(__assign({}, curve.options), { gasLimit: gasLimit_1 }))];
+                case 5:
+                    _c.apply(_b, [(_g.sent()).hash]);
+                    _g.label = 6;
+                case 6:
+                    _d = mulBy1_3;
+                    return [4 /*yield*/, contract.approve.estimateGas(spender, _approveAmount, curve.constantOptions)];
+                case 7:
+                    gasLimit = _d.apply(void 0, [_g.sent()]);
+                    _f = (_e = txHashes).push;
+                    return [4 /*yield*/, contract.approve(spender, _approveAmount, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                case 8:
+                    _f.apply(_e, [(_g.sent()).hash]);
+                    _g.label = 9;
+                case 9:
+                    i++;
+                    return [3 /*break*/, 2];
+                case 10: return [2 /*return*/, txHashes];
+            }
+        });
+    });
 };
 // coins can be either addresses or symbols
-export const ensureAllowanceEstimateGas = async (coins, amounts, spender, isMax = true) => {
-    const coinAddresses = _getCoinAddresses(coins);
-    const decimals = _getCoinDecimals(coinAddresses);
-    const _amounts = amounts.map((a, i) => parseUnits(a, decimals[i]));
-    const address = curve.signerAddress;
-    const allowance = await _getAllowance(coinAddresses, address, spender);
-    let gas = 0;
-    for (let i = 0; i < allowance.length; i++) {
-        if (allowance[i] < _amounts[i]) {
-            const contract = curve.contracts[coinAddresses[i]].contract;
-            const _approveAmount = isMax ? MAX_ALLOWANCE : _amounts[i];
-            if (allowance[i] > 0n) {
-                gas += Number(await contract.approve.estimateGas(spender, 0n, curve.constantOptions));
+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, address, allowance, gas, i, contract, _approveAmount, _a, _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    coinAddresses = _getCoinAddresses(coins);
+                    decimals = _getCoinDecimals(coinAddresses);
+                    _amounts = amounts.map(function (a, i) { return parseUnits(a, decimals[i]); });
+                    address = curve.signerAddress;
+                    return [4 /*yield*/, _getAllowance(coinAddresses, address, spender)];
+                case 1:
+                    allowance = _e.sent();
+                    gas = 0;
+                    i = 0;
+                    _e.label = 2;
+                case 2:
+                    if (!(i < allowance.length)) return [3 /*break*/, 7];
+                    if (!(allowance[i] < _amounts[i])) return [3 /*break*/, 6];
+                    contract = curve.contracts[coinAddresses[i]].contract;
+                    _approveAmount = isMax ? MAX_ALLOWANCE : _amounts[i];
+                    if (!(allowance[i] > curve.parseUnits("0"))) return [3 /*break*/, 4];
+                    _a = gas;
+                    _b = Number;
+                    return [4 /*yield*/, contract.approve.estimateGas(spender, curve.parseUnits("0"), curve.constantOptions)];
+                case 3:
+                    gas = _a + _b.apply(void 0, [_e.sent()]);
+                    _e.label = 4;
+                case 4:
+                    _c = gas;
+                    _d = Number;
+                    return [4 /*yield*/, contract.approve.estimateGas(spender, _approveAmount, curve.constantOptions)];
+                case 5:
+                    gas = _c + _d.apply(void 0, [_e.sent()]);
+                    _e.label = 6;
+                case 6:
+                    i++;
+                    return [3 /*break*/, 2];
+                case 7: return [2 /*return*/, gas];
             }
-            gas += Number(await contract.approve.estimateGas(spender, _approveAmount, curve.constantOptions));
-        }
-    }
-    return gas;
+        });
+    });
 };
 // coins can be either addresses or symbols
-export const ensureAllowance = async (coins, amounts, spender, isMax = true) => {
-    const coinAddresses = _getCoinAddresses(coins);
-    const decimals = _getCoinDecimals(coinAddresses);
-    const _amounts = amounts.map((a, i) => parseUnits(a, decimals[i]));
-    return await _ensureAllowance(coinAddresses, _amounts, spender, isMax);
-};
-export const getPoolNameBySwapAddress = (swapAddress) => {
-    const poolsData = { ...curve.constants.POOLS_DATA, ...curve.constants.FACTORY_POOLS_DATA, ...curve.constants.CRYPTO_FACTORY_POOLS_DATA };
-    return Object.entries(poolsData).filter(([_, poolData]) => poolData.swap_address.toLowerCase() === swapAddress.toLowerCase())[0][0];
+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()];
+            }
+        });
+    });
 };
-const _getTokenAddressBySwapAddress = (swapAddress) => {
-    const poolsData = { ...curve.constants.POOLS_DATA, ...curve.constants.FACTORY_POOLS_DATA, ...curve.constants.CRYPTO_FACTORY_POOLS_DATA };
-    const res = Object.entries(poolsData).filter(([_, poolData]) => poolData.swap_address.toLowerCase() === swapAddress.toLowerCase());
+export var getPoolNameBySwapAddress = function (swapAddress) {
+    var poolsData = __assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA);
+    return Object.entries(poolsData).filter(function (_a) {
+        var _ = _a[0], poolData = _a[1];
+        return poolData.swap_address.toLowerCase() === swapAddress.toLowerCase();
+    })[0][0];
+};
+var _getTokenAddressBySwapAddress = function (swapAddress) {
+    var poolsData = __assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA);
+    var res = Object.entries(poolsData).filter(function (_a) {
+        var _ = _a[0], poolData = _a[1];
+        return poolData.swap_address.toLowerCase() === swapAddress.toLowerCase();
+    });
     if (res.length === 0)
         return "";
     return res[0][1].token_address;
 };
-export const _getUsdPricesFromApi = async () => {
-    const network = curve.constants.NETWORK_NAME;
-    const promises = [
-        _getPoolsFromApi(network, "main"),
-        _getPoolsFromApi(network, "crypto"),
-        _getPoolsFromApi(network, "factory"),
-        _getPoolsFromApi(network, "factory-crypto"),
-    ];
-    const allTypesExtendedPoolData = await Promise.all(promises);
-    const priceDict = {};
-    for (const extendedPoolData of allTypesExtendedPoolData) {
-        for (const pool of extendedPoolData.poolData) {
-            const lpTokenAddress = pool.lpTokenAddress ?? pool.address;
-            const totalSupply = pool.totalSupply / (10 ** 18);
-            priceDict[lpTokenAddress.toLowerCase()] = pool.usdTotal && totalSupply ? pool.usdTotal / totalSupply : 0;
-            for (const coin of pool.coins) {
-                if (typeof coin.usdPrice === "number")
-                    priceDict[coin.address.toLowerCase()] = coin.usdPrice;
-            }
-            for (const coin of pool.gaugeRewards ?? []) {
-                if (typeof coin.tokenPrice === "number")
-                    priceDict[coin.tokenAddress.toLowerCase()] = coin.tokenPrice;
-            }
-        }
-    }
-    return priceDict;
-};
-export const _getCrvApyFromApi = async () => {
-    const network = curve.constants.NETWORK_NAME;
-    const promises = [
-        _getPoolsFromApi(network, "main"),
-        _getPoolsFromApi(network, "crypto"),
-        _getPoolsFromApi(network, "factory"),
-        _getPoolsFromApi(network, "factory-crypto"),
-    ];
-    const allTypesExtendedPoolData = await Promise.all(promises);
-    const apyDict = {};
-    for (const extendedPoolData of allTypesExtendedPoolData) {
-        for (const pool of extendedPoolData.poolData) {
-            if (pool.gaugeAddress) {
-                if (!pool.gaugeCrvApy) {
-                    apyDict[pool.gaugeAddress.toLowerCase()] = [0, 0];
+export var _getUsdPricesFromApi = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var network, promises, allTypesExtendedPoolData, priceDict, _i, allTypesExtendedPoolData_1, extendedPoolData, _a, _b, pool, lpTokenAddress, totalSupply, _c, _d, coin, _e, _f, coin;
+    var _g, _h;
+    return __generator(this, function (_j) {
+        switch (_j.label) {
+            case 0:
+                network = curve.constants.NETWORK_NAME;
+                promises = [
+                    _getPoolsFromApi(network, "main"),
+                    _getPoolsFromApi(network, "crypto"),
+                    _getPoolsFromApi(network, "factory"),
+                    _getPoolsFromApi(network, "factory-crypto"),
+                ];
+                return [4 /*yield*/, Promise.all(promises)];
+            case 1:
+                allTypesExtendedPoolData = _j.sent();
+                priceDict = {};
+                for (_i = 0, allTypesExtendedPoolData_1 = allTypesExtendedPoolData; _i < allTypesExtendedPoolData_1.length; _i++) {
+                    extendedPoolData = allTypesExtendedPoolData_1[_i];
+                    for (_a = 0, _b = extendedPoolData.poolData; _a < _b.length; _a++) {
+                        pool = _b[_a];
+                        lpTokenAddress = (_g = pool.lpTokenAddress) !== null && _g !== void 0 ? _g : pool.address;
+                        totalSupply = pool.totalSupply / (Math.pow(10, 18));
+                        priceDict[lpTokenAddress.toLowerCase()] = pool.usdTotal && totalSupply ? pool.usdTotal / totalSupply : 0;
+                        for (_c = 0, _d = pool.coins; _c < _d.length; _c++) {
+                            coin = _d[_c];
+                            if (typeof coin.usdPrice === "number")
+                                priceDict[coin.address.toLowerCase()] = coin.usdPrice;
+                        }
+                        for (_e = 0, _f = (_h = pool.gaugeRewards) !== null && _h !== void 0 ? _h : []; _e < _f.length; _e++) {
+                            coin = _f[_e];
+                            if (typeof coin.tokenPrice === "number")
+                                priceDict[coin.tokenAddress.toLowerCase()] = coin.tokenPrice;
+                        }
+                    }
                 }
-                else {
-                    apyDict[pool.gaugeAddress.toLowerCase()] = [pool.gaugeCrvApy[0] ?? 0, pool.gaugeCrvApy[1] ?? 0];
+                return [2 /*return*/, priceDict];
+        }
+    });
+}); };
+export var _getCrvApyFromApi = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var network, promises, allTypesExtendedPoolData, apyDict, _i, allTypesExtendedPoolData_2, extendedPoolData, _a, _b, pool;
+    var _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                network = curve.constants.NETWORK_NAME;
+                promises = [
+                    _getPoolsFromApi(network, "main"),
+                    _getPoolsFromApi(network, "crypto"),
+                    _getPoolsFromApi(network, "factory"),
+                    _getPoolsFromApi(network, "factory-crypto"),
+                ];
+                return [4 /*yield*/, Promise.all(promises)];
+            case 1:
+                allTypesExtendedPoolData = _e.sent();
+                apyDict = {};
+                for (_i = 0, allTypesExtendedPoolData_2 = allTypesExtendedPoolData; _i < allTypesExtendedPoolData_2.length; _i++) {
+                    extendedPoolData = allTypesExtendedPoolData_2[_i];
+                    for (_a = 0, _b = extendedPoolData.poolData; _a < _b.length; _a++) {
+                        pool = _b[_a];
+                        if (pool.gaugeAddress) {
+                            if (!pool.gaugeCrvApy) {
+                                apyDict[pool.gaugeAddress.toLowerCase()] = [0, 0];
+                            }
+                            else {
+                                apyDict[pool.gaugeAddress.toLowerCase()] = [(_c = pool.gaugeCrvApy[0]) !== null && _c !== void 0 ? _c : 0, (_d = pool.gaugeCrvApy[1]) !== null && _d !== void 0 ? _d : 0];
+                            }
+                        }
+                    }
                 }
-            }
+                return [2 /*return*/, apyDict];
         }
-    }
-    return apyDict;
-};
-export const _getRewardsFromApi = async () => {
-    const network = curve.constants.NETWORK_NAME;
-    const promises = [
-        _getPoolsFromApi(network, "main"),
-        _getPoolsFromApi(network, "crypto"),
-        _getPoolsFromApi(network, "factory"),
-        _getPoolsFromApi(network, "factory-crypto"),
-    ];
-    const allTypesExtendedPoolData = await Promise.all(promises);
-    const rewardsDict = {};
-    for (const extendedPoolData of allTypesExtendedPoolData) {
-        for (const pool of extendedPoolData.poolData) {
-            if (pool.gaugeAddress) {
-                rewardsDict[pool.gaugeAddress.toLowerCase()] = pool.gaugeRewards;
-            }
+    });
+}); };
+export var _getRewardsFromApi = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var network, promises, allTypesExtendedPoolData, rewardsDict, _i, allTypesExtendedPoolData_3, extendedPoolData, _a, _b, pool;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                network = curve.constants.NETWORK_NAME;
+                promises = [
+                    _getPoolsFromApi(network, "main"),
+                    _getPoolsFromApi(network, "crypto"),
+                    _getPoolsFromApi(network, "factory"),
+                    _getPoolsFromApi(network, "factory-crypto"),
+                ];
+                return [4 /*yield*/, Promise.all(promises)];
+            case 1:
+                allTypesExtendedPoolData = _c.sent();
+                rewardsDict = {};
+                for (_i = 0, allTypesExtendedPoolData_3 = allTypesExtendedPoolData; _i < allTypesExtendedPoolData_3.length; _i++) {
+                    extendedPoolData = allTypesExtendedPoolData_3[_i];
+                    for (_a = 0, _b = extendedPoolData.poolData; _a < _b.length; _a++) {
+                        pool = _b[_a];
+                        if (pool.gaugeAddress) {
+                            rewardsDict[pool.gaugeAddress.toLowerCase()] = pool.gaugeRewards;
+                        }
+                    }
+                }
+                return [2 /*return*/, rewardsDict];
         }
-    }
-    return rewardsDict;
-};
-const _usdRatesCache = {};
-export const _getUsdRate = async (assetId) => {
-    if (curve.chainId === 1 && assetId.toLowerCase() === '0x8762db106b2c2a0bccb3a80d1ed41273552616e8')
-        return 0; // RSR
-    const pricesFromApi = await _getUsdPricesFromApi();
-    if (assetId.toLowerCase() in pricesFromApi)
-        return pricesFromApi[assetId.toLowerCase()];
-    if (assetId === 'USD' || (curve.chainId === 137 && (assetId.toLowerCase() === curve.constants.COINS.am3crv.toLowerCase())))
-        return 1;
-    let chainName = {
-        1: 'ethereum',
-        10: 'optimistic-ethereum',
-        100: 'xdai',
-        137: 'polygon-pos',
-        250: 'fantom',
-        1284: 'moonbeam',
-        2222: 'kava',
-        42220: 'celo',
-        43114: 'avalanche',
-        42161: 'arbitrum-one',
-        1313161554: 'aurora',
-    }[curve.chainId];
-    const nativeTokenName = {
-        1: 'ethereum',
-        10: 'ethereum',
-        100: 'xdai',
-        137: 'matic-network',
-        250: 'fantom',
-        1284: 'moonbeam',
-        2222: 'kava',
-        42220: 'celo',
-        43114: 'avalanche-2',
-        42161: 'ethereum',
-        1313161554: 'ethereum',
-    }[curve.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 (curve.chainId === 137 && assetId.toLowerCase() === curve.constants.COINS.eurt) {
-        chainName = 'ethereum';
-        assetId = '0xC581b735A1688071A1746c968e0798D642EDE491'.toLowerCase(); // EURT Ethereum
-    }
-    // CRV
-    if (assetId.toLowerCase() === curve.constants.ALIASES.crv) {
-        assetId = 'curve-dao-token';
-    }
-    if ((_usdRatesCache[assetId]?.time || 0) + 600000 < Date.now()) {
-        const url = [nativeTokenName, 'ethereum', 'bitcoin', 'link', 'curve-dao-token', 'stasis-eurs'].includes(assetId.toLowerCase()) ?
-            `https://api.coingecko.com/api/v3/simple/price?ids=${assetId}&vs_currencies=usd` :
-            `https://api.coingecko.com/api/v3/simple/token_price/${chainName}?contract_addresses=${assetId}&vs_currencies=usd`;
-        const response = await axios.get(url);
-        try {
-            _usdRatesCache[assetId] = { 'rate': response.data[assetId]['usd'] ?? 0, 'time': Date.now() };
+    });
+}); };
+var _usdRatesCache = {};
+export var _getUsdRate = function (assetId) { return __awaiter(void 0, void 0, void 0, function () {
+    var pricesFromApi, chainName, nativeTokenName, url, response;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (curve.chainId === 1 && assetId.toLowerCase() === '0x8762db106b2c2a0bccb3a80d1ed41273552616e8')
+                    return [2 /*return*/, 0]; // RSR
+                return [4 /*yield*/, _getUsdPricesFromApi()];
+            case 1:
+                pricesFromApi = _c.sent();
+                if (assetId.toLowerCase() in pricesFromApi)
+                    return [2 /*return*/, pricesFromApi[assetId.toLowerCase()]];
+                if (assetId === 'USD' || (curve.chainId === 137 && (assetId.toLowerCase() === curve.constants.COINS.am3crv.toLowerCase())))
+                    return [2 /*return*/, 1];
+                chainName = {
+                    1: 'ethereum',
+                    10: 'optimistic-ethereum',
+                    100: 'xdai',
+                    137: 'polygon-pos',
+                    250: 'fantom',
+                    1284: 'moonbeam',
+                    2222: 'kava',
+                    42220: 'celo',
+                    43114: 'avalanche',
+                    42161: 'arbitrum-one',
+                    1313161554: 'aurora',
+                }[curve.chainId];
+                nativeTokenName = {
+                    1: 'ethereum',
+                    10: 'ethereum',
+                    100: 'xdai',
+                    137: 'matic-network',
+                    250: 'fantom',
+                    1284: 'moonbeam',
+                    2222: 'kava',
+                    42220: 'celo',
+                    43114: 'avalanche-2',
+                    42161: 'ethereum',
+                    1313161554: 'ethereum',
+                }[curve.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 (curve.chainId === 137 && assetId.toLowerCase() === curve.constants.COINS.eurt) {
+                    chainName = 'ethereum';
+                    assetId = '0xC581b735A1688071A1746c968e0798D642EDE491'.toLowerCase(); // EURT Ethereum
+                }
+                // CRV
+                if (assetId.toLowerCase() === curve.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 = _c.sent();
+                try {
+                    _usdRatesCache[assetId] = { 'rate': (_b = response.data[assetId]['usd']) !== null && _b !== void 0 ? _b : 0, 'time': Date.now() };
+                }
+                catch (err) { // TODO pay attention!
+                    _usdRatesCache[assetId] = { 'rate': 0, 'time': Date.now() };
+                }
+                _c.label = 3;
+            case 3: return [2 /*return*/, _usdRatesCache[assetId]['rate']];
         }
-        catch (err) { // TODO pay attention!
-            _usdRatesCache[assetId] = { 'rate': 0, 'time': Date.now() };
+    });
+}); };
+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()];
         }
-    }
-    return _usdRatesCache[assetId]['rate'];
-};
-export const getUsdRate = async (coin) => {
-    const [coinAddress] = _getCoinAddressesNoCheck(coin);
-    return await _getUsdRate(coinAddress);
-};
-const _getNetworkName = (network = curve.chainId) => {
+    });
+}); };
+var _getNetworkName = function (network) {
+    if (network === void 0) { network = curve.chainId; }
     if (typeof network === "number" && NETWORK_CONSTANTS[network]) {
         return NETWORK_CONSTANTS[network].NAME;
     }
-    else if (typeof network === "string" && Object.values(NETWORK_CONSTANTS).map((n) => n.NAME).includes(network)) {
+    else if (typeof network === "string" && Object.values(NETWORK_CONSTANTS).map(function (n) { return n.NAME; }).includes(network)) {
         return network;
     }
     else {
-        throw Error(`Wrong network name or id: ${network}`);
+        throw Error("Wrong network name or id: ".concat(network));
     }
 };
-const _getChainId = (network = curve.chainId) => {
+var _getChainId = function (network) {
+    if (network === void 0) { network = curve.chainId; }
     if (typeof network === "number" && NETWORK_CONSTANTS[network]) {
         return network;
     }
-    else if (typeof network === "string" && Object.values(NETWORK_CONSTANTS).map((n) => n.NAME).includes(network)) {
-        const idx = Object.values(NETWORK_CONSTANTS).map((n) => n.NAME).indexOf(network);
+    else if (typeof network === "string" && Object.values(NETWORK_CONSTANTS).map(function (n) { return n.NAME; }).includes(network)) {
+        var idx = Object.values(NETWORK_CONSTANTS).map(function (n) { return n.NAME; }).indexOf(network);
         return Number(Object.keys(NETWORK_CONSTANTS)[idx]);
     }
     else {
-        throw Error(`Wrong network name or id: ${network}`);
+        throw Error("Wrong network name or id: ".concat(network));
     }
 };
-export const getTVL = async (network = curve.chainId) => {
-    network = _getNetworkName(network);
-    const promises = [
-        _getPoolsFromApi(network, "main"),
-        _getPoolsFromApi(network, "crypto"),
-        _getPoolsFromApi(network, "factory"),
-        _getPoolsFromApi(network, "factory-crypto"),
-    ];
-    const allTypesExtendedPoolData = await Promise.all(promises);
-    return allTypesExtendedPoolData.reduce((sum, data) => sum + (data.tvl ?? data.tvlAll ?? 0), 0);
+export var getTVL = function (network) {
+    if (network === void 0) { network = curve.chainId; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var promises, allTypesExtendedPoolData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    network = _getNetworkName(network);
+                    promises = [
+                        _getPoolsFromApi(network, "main"),
+                        _getPoolsFromApi(network, "crypto"),
+                        _getPoolsFromApi(network, "factory"),
+                        _getPoolsFromApi(network, "factory-crypto"),
+                    ];
+                    return [4 /*yield*/, Promise.all(promises)];
+                case 1:
+                    allTypesExtendedPoolData = _a.sent();
+                    return [2 /*return*/, allTypesExtendedPoolData.reduce(function (sum, data) { var _a, _b; return sum + ((_b = (_a = data.tvl) !== null && _a !== void 0 ? _a : data.tvlAll) !== null && _b !== void 0 ? _b : 0); }, 0)];
+            }
+        });
+    });
 };
-export const getVolume = async (network = curve.chainId) => {
-    network = _getNetworkName(network);
-    if (["moonbeam", "kava", "celo", "aurora"].includes(network)) {
-        const chainId = _getChainId(network);
-        if (curve.chainId !== chainId)
-            throw Error("To get volume for Moonbeam, Kava, Celo or Aurora connect to the network first");
-        const [mainPoolsData, factoryPoolsData] = await Promise.all([
-            _getLegacyAPYsAndVolumes(network),
-            _getFactoryAPYsAndVolumes(network),
-        ]);
-        let volume = 0;
-        for (const id in mainPoolsData) {
-            volume += mainPoolsData[id].volume ?? 0;
-        }
-        for (const pool of factoryPoolsData) {
-            const lpToken = _getTokenAddressBySwapAddress(pool.poolAddress);
-            const lpPrice = lpToken ? await _getUsdRate(lpToken) : 0;
-            volume += pool.volume * lpPrice;
-        }
-        return { totalVolume: volume, cryptoVolume: 0, cryptoShare: 0 };
-    }
-    const { totalVolume, cryptoVolume, cryptoShare } = await _getSubgraphData(network);
-    return { totalVolume, cryptoVolume, cryptoShare };
+export var getVolume = function (network) {
+    if (network === void 0) { network = curve.chainId; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var chainId, _a, mainPoolsData, factoryPoolsData, volume, id, _i, factoryPoolsData_1, pool, lpToken, lpPrice, _b, _c, totalVolume, cryptoVolume, cryptoShare;
+        var _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    network = _getNetworkName(network);
+                    if (!["moonbeam", "kava", "celo", "aurora"].includes(network)) return [3 /*break*/, 8];
+                    chainId = _getChainId(network);
+                    if (curve.chainId !== chainId)
+                        throw Error("To get volume for Moonbeam, Kava, Celo or Aurora connect to the network first");
+                    return [4 /*yield*/, Promise.all([
+                            _getLegacyAPYsAndVolumes(network),
+                            _getFactoryAPYsAndVolumes(network),
+                        ])];
+                case 1:
+                    _a = _e.sent(), mainPoolsData = _a[0], factoryPoolsData = _a[1];
+                    volume = 0;
+                    for (id in mainPoolsData) {
+                        volume += (_d = mainPoolsData[id].volume) !== null && _d !== void 0 ? _d : 0;
+                    }
+                    _i = 0, factoryPoolsData_1 = factoryPoolsData;
+                    _e.label = 2;
+                case 2:
+                    if (!(_i < factoryPoolsData_1.length)) return [3 /*break*/, 7];
+                    pool = factoryPoolsData_1[_i];
+                    lpToken = _getTokenAddressBySwapAddress(pool.poolAddress);
+                    if (!lpToken) return [3 /*break*/, 4];
+                    return [4 /*yield*/, _getUsdRate(lpToken)];
+                case 3:
+                    _b = _e.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    _b = 0;
+                    _e.label = 5;
+                case 5:
+                    lpPrice = _b;
+                    volume += pool.volume * lpPrice;
+                    _e.label = 6;
+                case 6:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 7: return [2 /*return*/, { totalVolume: volume, cryptoVolume: 0, cryptoShare: 0 }];
+                case 8: return [4 /*yield*/, _getSubgraphData(network)];
+                case 9:
+                    _c = _e.sent(), totalVolume = _c.totalVolume, cryptoVolume = _c.cryptoVolume, cryptoShare = _c.cryptoShare;
+                    return [2 /*return*/, { totalVolume: totalVolume, cryptoVolume: cryptoVolume, cryptoShare: cryptoShare }];
+            }
+        });
+    });
 };
-export const _setContracts = (address, abi) => {
+export var _setContracts = function (address, abi) {
     curve.contracts[address] = {
         contract: new Contract(address, abi, curve.signer || curve.provider),
         multicallContract: new MulticallContract(address, abi),
@@ -405,51 +711,66 @@ export const _setContracts = (address, abi) => {
 // Find k for which x * k = target_x or y * k = target_y
 // k = max(target_x / x, target_y / y)
 // small_x = x * k
-export const _get_small_x = (_x, _y, x_decimals, y_decimals) => {
-    const target_x = BN(10 ** (x_decimals > 5 ? x_decimals - 3 : x_decimals));
-    const target_y = BN(10 ** (y_decimals > 5 ? y_decimals - 3 : y_decimals));
-    const x_int_BN = toBN(_x, 0);
-    const y_int_BN = toBN(_y, 0);
-    const k = BigNumber.max(target_x.div(x_int_BN), target_y.div(y_int_BN));
-    return BigNumber.min(x_int_BN.times(k), BN(10 ** x_decimals));
-};
-export const _get_price_impact = (_x, _y, _small_x, _small_y, x_decimals, y_decimals) => {
-    const x_BN = toBN(_x, x_decimals);
-    const y_BN = toBN(_y, y_decimals);
-    const small_x_BN = toBN(_small_x, x_decimals);
-    const small_y_BN = toBN(_small_y, y_decimals);
-    const rateBN = y_BN.div(x_BN);
-    const smallRateBN = small_y_BN.div(small_x_BN);
+export var _get_small_x = function (_x, _y, x_decimals, y_decimals) {
+    var target_x = BN(Math.pow(10, (x_decimals > 5 ? x_decimals - 3 : x_decimals)));
+    var target_y = BN(Math.pow(10, (y_decimals > 5 ? y_decimals - 3 : y_decimals)));
+    var x_int_BN = toBN(_x, 0);
+    var y_int_BN = toBN(_y, 0);
+    var k = BigNumber.max(target_x.div(x_int_BN), target_y.div(y_int_BN));
+    return BigNumber.min(x_int_BN.times(k), BN(Math.pow(10, x_decimals)));
+};
+export var _get_price_impact = function (_x, _y, _small_x, _small_y, x_decimals, y_decimals) {
+    var x_BN = toBN(_x, x_decimals);
+    var y_BN = toBN(_y, y_decimals);
+    var small_x_BN = toBN(_small_x, x_decimals);
+    var small_y_BN = toBN(_small_y, y_decimals);
+    var rateBN = y_BN.div(x_BN);
+    var smallRateBN = small_y_BN.div(small_x_BN);
     if (rateBN.gt(smallRateBN))
         return BN(0);
     return BN(1).minus(rateBN.div(smallRateBN)).times(100);
 };
-export const getCoinsData = async (...coins) => {
-    if (coins.length == 1 && Array.isArray(coins[0]))
-        coins = coins[0];
-    coins = coins;
-    const coinAddresses = _getCoinAddressesNoCheck(coins);
-    console.log(coinAddresses);
-    const ethIndex = getEthIndex(coinAddresses);
-    if (ethIndex !== -1) {
-        coinAddresses.splice(ethIndex, 1);
+export var getCoinsData = function () {
+    var coins = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        coins[_i] = arguments[_i];
     }
-    const contractCalls = [];
-    for (const coinAddr of coinAddresses) {
-        const coinContract = new MulticallContract(coinAddr, ERC20Abi);
-        contractCalls.push(coinContract.name(), coinContract.symbol(), coinContract.decimals());
-    }
-    const _response = await curve.multicallProvider.all(contractCalls);
-    if (ethIndex !== -1) {
-        _response.splice(ethIndex * 2, 0, ...['Ethereum', 'ETH', 18]);
-    }
-    const res = [];
-    coins.forEach((address, i) => {
-        res.push({
-            name: _response.shift(),
-            symbol: _response.shift(),
-            decimals: Number(curve.formatUnits(_response.shift(), 0)),
+    return __awaiter(void 0, void 0, void 0, function () {
+        var coinAddresses, ethIndex, contractCalls, _a, coinAddresses_3, coinAddr, coinContract, _response, res;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (coins.length == 1 && Array.isArray(coins[0]))
+                        coins = coins[0];
+                    coins = coins;
+                    coinAddresses = _getCoinAddressesNoCheck(coins);
+                    console.log(coinAddresses);
+                    ethIndex = getEthIndex(coinAddresses);
+                    if (ethIndex !== -1) {
+                        coinAddresses.splice(ethIndex, 1);
+                    }
+                    contractCalls = [];
+                    for (_a = 0, coinAddresses_3 = coinAddresses; _a < coinAddresses_3.length; _a++) {
+                        coinAddr = coinAddresses_3[_a];
+                        coinContract = new MulticallContract(coinAddr, ERC20Abi);
+                        contractCalls.push(coinContract.name(), coinContract.symbol(), coinContract.decimals());
+                    }
+                    return [4 /*yield*/, curve.multicallProvider.all(contractCalls)];
+                case 1:
+                    _response = _b.sent();
+                    if (ethIndex !== -1) {
+                        _response.splice.apply(_response, __spreadArray([ethIndex * 2, 0], ['Ethereum', 'ETH', 18], false));
+                    }
+                    res = [];
+                    coins.forEach(function (address, i) {
+                        res.push({
+                            name: _response.shift(),
+                            symbol: _response.shift(),
+                            decimals: Number(curve.formatUnits(_response.shift(), 0)),
+                        });
+                    });
+                    return [2 /*return*/, res];
+            }
         });
     });
-    return res;
 };