@curvefi/api 2.31.0 → 2.31.1

package/lib/pools/PoolTemplate.js

@@ -1,1120 +1,737 @@
-"use strict";
-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;
+import memoize from "memoizee";
+import { _getPoolsFromApi, _getSubgraphData, _getFactoryAPYsAndVolumes, _getLegacyAPYsAndVolumes } from '../external-api.js';
+import { _getCoinAddresses, _getBalances, _prepareAddresses, _ensureAllowance, _getUsdRate, hasAllowance, ensureAllowance, ensureAllowanceEstimateGas, BN, toBN, toStringFromBN, parseUnits, getEthIndex, fromBN, _cutZeros, _setContracts, _get_small_x, _get_price_impact, checkNumber, _getCrvApyFromApi, _getRewardsFromApi, mulBy1_3, } from '../utils.js';
+import { curve as _curve, curve } from "../curve.js";
+import ERC20Abi from '../constants/abis/ERC20.json' assert { type: 'json' };
+const DAY = 86400;
+const WEEK = 7 * DAY;
+const MONTH = 30 * DAY;
+const YEAR = 365 * DAY;
+export class PoolTemplate {
+    constructor(id) {
+        this.statsParameters = async () => {
+            const multicallContract = curve.contracts[this.address].multicallContract;
+            const lpMulticallContract = curve.contracts[this.lpToken].multicallContract;
+            const calls = [
+                multicallContract.get_virtual_price(),
+                multicallContract.fee(),
+                multicallContract.admin_fee(),
+                multicallContract.A(),
+                lpMulticallContract.totalSupply(),
+            ];
+            if (this.isCrypto) {
+                calls.push(multicallContract.gamma());
+                if (this.wrappedCoins.length === 2) {
+                    calls.push(multicallContract.price_oracle());
+                    calls.push(multicallContract.price_scale());
+                }
+                else {
+                    for (let i = 0; i < this.wrappedCoins.length - 1; i++) {
+                        calls.push(multicallContract.price_oracle(i));
+                        calls.push(multicallContract.price_scale(i));
+                    }
+                }
             }
-            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));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PoolTemplate = void 0;
-var ethers_1 = require("ethers");
-var memoizee_1 = __importDefault(require("memoizee"));
-var external_api_1 = require("../external-api");
-var utils_1 = require("../utils");
-var curve_1 = require("../curve");
-var ERC20_json_1 = __importDefault(require("../constants/abis/ERC20.json"));
-var DAY = 86400;
-var WEEK = 7 * DAY;
-var MONTH = 30 * DAY;
-var YEAR = 365 * DAY;
-var PoolTemplate = /** @class */ (function () {
-    function PoolTemplate(id) {
-        var _this = this;
-        var _c, _d;
-        this.statsParameters = function () { return __awaiter(_this, void 0, void 0, function () {
-            var multicallContract, lpMulticallContract, calls, i, additionalCalls, _virtualPrice, _fee, _prices, _adminFee, _A, _lpTokenSupply, _gamma, e_1, _c, virtualPrice, fee, adminFee, A, lpTokenSupply, gamma, priceOracle, priceScale, prices, i, A_PRECISION, _d, _future_A, _initial_A, _future_A_time, _initial_A_time, _e, future_A, initial_A, future_A_time, initial_A_time;
-            var _f, _g, _h;
-            return __generator(this, function (_j) {
-                switch (_j.label) {
-                    case 0:
-                        multicallContract = curve_1.curve.contracts[this.address].multicallContract;
-                        lpMulticallContract = curve_1.curve.contracts[this.lpToken].multicallContract;
-                        calls = [
-                            multicallContract.get_virtual_price(),
-                            multicallContract.fee(),
-                            multicallContract.admin_fee(),
-                            multicallContract.A(),
-                            lpMulticallContract.totalSupply(),
-                        ];
-                        if (this.isCrypto) {
-                            calls.push(multicallContract.gamma());
-                            if (this.wrappedCoins.length === 2) {
-                                calls.push(multicallContract.price_oracle());
-                                calls.push(multicallContract.price_scale());
-                            }
-                            else {
-                                for (i = 0; i < this.wrappedCoins.length - 1; i++) {
-                                    calls.push(multicallContract.price_oracle(i));
-                                    calls.push(multicallContract.price_scale(i));
-                                }
-                            }
-                        }
-                        additionalCalls = this.isCrypto ? [] : [multicallContract.future_A()];
-                        if ('initial_A' in multicallContract) {
-                            additionalCalls.push(multicallContract.initial_A(), multicallContract.future_A_time(), multicallContract.initial_A_time());
-                        }
-                        _virtualPrice = ethers_1.ethers.BigNumber.from(0);
-                        _fee = ethers_1.ethers.BigNumber.from(0);
-                        _j.label = 1;
-                    case 1:
-                        _j.trys.push([1, 3, , 8]);
-                        return [4 /*yield*/, curve_1.curve.multicallProvider.all(calls)];
-                    case 2:
-                        _f = (_j.sent()), _virtualPrice = _f[0], _fee = _f[1], _adminFee = _f[2], _A = _f[3], _lpTokenSupply = _f[4], _gamma = _f[5], _prices = _f.slice(6);
-                        return [3 /*break*/, 8];
-                    case 3:
-                        e_1 = _j.sent();
-                        calls.shift();
-                        if (!this.isCrypto) return [3 /*break*/, 5];
-                        calls.shift();
-                        return [4 /*yield*/, curve_1.curve.multicallProvider.all(calls)];
-                    case 4:
-                        _g = (_j.sent()), _adminFee = _g[0], _A = _g[1], _lpTokenSupply = _g[2], _gamma = _g[3], _prices = _g.slice(4);
-                        return [3 /*break*/, 7];
-                    case 5: return [4 /*yield*/, curve_1.curve.multicallProvider.all(calls)];
-                    case 6:
-                        _h = (_j.sent()), _fee = _h[0], _adminFee = _h[1], _A = _h[2], _lpTokenSupply = _h[3], _gamma = _h[4], _prices = _h.slice(5);
-                        _j.label = 7;
-                    case 7: return [3 /*break*/, 8];
-                    case 8:
-                        _c = [
-                            ethers_1.ethers.utils.formatUnits(_virtualPrice),
-                            ethers_1.ethers.utils.formatUnits(_fee, 8),
-                            ethers_1.ethers.utils.formatUnits(_adminFee.mul(_fee)),
-                            ethers_1.ethers.utils.formatUnits(_A, 0),
-                            ethers_1.ethers.utils.formatUnits(_lpTokenSupply),
-                            _gamma ? ethers_1.ethers.utils.formatUnits(_gamma) : _gamma,
-                        ], virtualPrice = _c[0], fee = _c[1], adminFee = _c[2], A = _c[3], lpTokenSupply = _c[4], gamma = _c[5];
-                        if (this.isCrypto) {
-                            prices = _prices.map(function (_p) { return ethers_1.ethers.utils.formatUnits(_p); });
-                            priceOracle = [];
-                            priceScale = [];
-                            for (i = 0; i < this.wrappedCoins.length - 1; i++) {
-                                priceOracle.push(prices.shift());
-                                priceScale.push(prices.shift());
-                            }
-                        }
-                        A_PRECISION = curve_1.curve.chainId === 1 && ['compound', 'usdt', 'y', 'busd', 'susd', 'pax', 'ren', 'sbtc', 'hbtc', '3pool'].includes(this.id) ? 1 : 100;
-                        return [4 /*yield*/, curve_1.curve.multicallProvider.all(additionalCalls)];
-                    case 9:
-                        _d = _j.sent(), _future_A = _d[0], _initial_A = _d[1], _future_A_time = _d[2], _initial_A_time = _d[3];
-                        _e = [
-                            _future_A ? String(Number(ethers_1.ethers.utils.formatUnits(_future_A, 0)) / A_PRECISION) : undefined,
-                            _initial_A ? String(Number(ethers_1.ethers.utils.formatUnits(_initial_A, 0)) / A_PRECISION) : undefined,
-                            _future_A_time ? Number(ethers_1.ethers.utils.formatUnits(_future_A_time, 0)) * 1000 : undefined,
-                            _initial_A_time ? Number(ethers_1.ethers.utils.formatUnits(_initial_A_time, 0)) * 1000 : undefined,
-                        ], future_A = _e[0], initial_A = _e[1], future_A_time = _e[2], initial_A_time = _e[3];
-                        return [2 /*return*/, { lpTokenSupply: lpTokenSupply, virtualPrice: virtualPrice, fee: fee, adminFee: adminFee, A: A, future_A: future_A, initial_A: initial_A, future_A_time: future_A_time, initial_A_time: initial_A_time, gamma: gamma, priceOracle: priceOracle, priceScale: priceScale }];
+            const additionalCalls = this.isCrypto ? [] : [multicallContract.future_A()];
+            if ('initial_A' in multicallContract) {
+                additionalCalls.push(multicallContract.initial_A(), multicallContract.future_A_time(), multicallContract.initial_A_time());
+            }
+            let _virtualPrice = 0n;
+            let _fee = 0n;
+            let _prices, _adminFee, _A, _lpTokenSupply, _gamma;
+            try {
+                [_virtualPrice, _fee, _adminFee, _A, _lpTokenSupply, _gamma, ..._prices] = await curve.multicallProvider.all(calls);
+            }
+            catch (e) { // Empty pool
+                calls.shift();
+                if (this.isCrypto) {
+                    calls.shift();
+                    [_adminFee, _A, _lpTokenSupply, _gamma, ..._prices] = await curve.multicallProvider.all(calls);
                 }
-            });
-        }); };
-        this.statsTotalLiquidity = function (useApi) {
-            if (useApi === void 0) { useApi = true; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var network, poolType, poolsData, totalLiquidity_1, balances, promises, _i, _c, addr, prices, totalLiquidity;
-                var _this = this;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            if (!useApi) return [3 /*break*/, 2];
-                            network = curve_1.curve.constants.NETWORK_NAME;
-                            poolType = !this.isFactory && !this.isCrypto ? "main" :
-                                !this.isFactory ? "crypto" :
-                                    !(this.isCrypto && this.isFactory) ? "factory" :
-                                        "factory-crypto";
-                            return [4 /*yield*/, (0, external_api_1._getPoolsFromApi)(network, poolType)];
-                        case 1:
-                            poolsData = (_d.sent()).poolData;
-                            try {
-                                totalLiquidity_1 = poolsData.filter(function (data) { return data.address.toLowerCase() === _this.address.toLowerCase(); })[0].usdTotal;
-                                return [2 /*return*/, String(totalLiquidity_1)];
-                            }
-                            catch (err) {
-                                console.log(this.id, err.message);
-                            }
-                            _d.label = 2;
-                        case 2: return [4 /*yield*/, this.statsUnderlyingBalances()];
-                        case 3:
-                            balances = _d.sent();
-                            promises = [];
-                            for (_i = 0, _c = this.underlyingCoinAddresses; _i < _c.length; _i++) {
-                                addr = _c[_i];
-                                promises.push((0, utils_1._getUsdRate)(addr));
-                            }
-                            return [4 /*yield*/, Promise.all(promises)];
-                        case 4:
-                            prices = _d.sent();
-                            totalLiquidity = balances.reduce(function (liquidity, b, i) { return liquidity + (Number(b) * prices[i]); }, 0);
-                            return [2 /*return*/, totalLiquidity.toFixed(8)];
-                    }
-                });
-            });
+                else {
+                    [_fee, _adminFee, _A, _lpTokenSupply, _gamma, ..._prices] = await curve.multicallProvider.all(calls);
+                }
+            }
+            const [virtualPrice, fee, adminFee, A, lpTokenSupply, gamma] = [
+                curve.formatUnits(_virtualPrice),
+                curve.formatUnits(_fee, 8),
+                curve.formatUnits(_adminFee * _fee),
+                curve.formatUnits(_A, 0),
+                curve.formatUnits(_lpTokenSupply),
+                _gamma ? curve.formatUnits(_gamma) : undefined,
+            ];
+            let priceOracle, priceScale;
+            if (this.isCrypto) {
+                const prices = _prices.map((_p) => curve.formatUnits(_p));
+                priceOracle = [];
+                priceScale = [];
+                for (let i = 0; i < this.wrappedCoins.length - 1; i++) {
+                    priceOracle.push(prices.shift());
+                    priceScale.push(prices.shift());
+                }
+            }
+            const A_PRECISION = curve.chainId === 1 && ['compound', 'usdt', 'y', 'busd', 'susd', 'pax', 'ren', 'sbtc', 'hbtc', '3pool'].includes(this.id) ? 1 : 100;
+            const [_future_A, _initial_A, _future_A_time, _initial_A_time] = await curve.multicallProvider.all(additionalCalls);
+            const [future_A, initial_A, future_A_time, initial_A_time] = [
+                _future_A ? String(Number(curve.formatUnits(_future_A, 0)) / A_PRECISION) : undefined,
+                _initial_A ? String(Number(curve.formatUnits(_initial_A, 0)) / A_PRECISION) : undefined,
+                _future_A_time ? Number(curve.formatUnits(_future_A_time, 0)) * 1000 : undefined,
+                _initial_A_time ? Number(curve.formatUnits(_initial_A_time, 0)) * 1000 : undefined,
+            ];
+            return { lpTokenSupply, virtualPrice, fee, adminFee, A, future_A, initial_A, future_A_time, initial_A_time, gamma, priceOracle, priceScale };
         };
-        this.statsVolume = function () { return __awaiter(_this, void 0, void 0, function () {
-            var _c, mainPoolsData, factoryPoolsData, poolData_1, lpPrice, network, poolsData, poolData;
-            var _this = this;
-            var _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        if (![1284, 2222, 42220, 1313161554].includes(curve_1.curve.chainId)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, Promise.all([
-                                (0, external_api_1._getLegacyAPYsAndVolumes)(curve_1.curve.constants.NETWORK_NAME),
-                                (0, external_api_1._getFactoryAPYsAndVolumes)(curve_1.curve.constants.NETWORK_NAME),
-                            ])];
-                    case 1:
-                        _c = _e.sent(), mainPoolsData = _c[0], factoryPoolsData = _c[1];
-                        if (this.id in mainPoolsData) {
-                            return [2 /*return*/, ((_d = mainPoolsData[this.id].volume) !== null && _d !== void 0 ? _d : 0).toString()];
-                        }
-                        poolData_1 = factoryPoolsData.find(function (d) { return d.poolAddress.toLowerCase() === _this.address; });
-                        if (!poolData_1)
-                            throw Error("Can't get Volume for ".concat(this.name, " (id: ").concat(this.id, ")"));
-                        return [4 /*yield*/, (0, utils_1._getUsdRate)(this.lpToken)];
-                    case 2:
-                        lpPrice = _e.sent();
-                        return [2 /*return*/, (poolData_1.volume * lpPrice).toString()];
-                    case 3:
-                        network = curve_1.curve.constants.NETWORK_NAME;
-                        return [4 /*yield*/, (0, external_api_1._getSubgraphData)(network)];
-                    case 4:
-                        poolsData = (_e.sent()).poolsData;
-                        poolData = poolsData.find(function (d) { return d.address.toLowerCase() === _this.address; });
-                        if (!poolData)
-                            throw Error("Can't get Volume for ".concat(this.name, " (id: ").concat(this.id, ")"));
-                        return [2 /*return*/, poolData.volumeUSD.toString()];
+        this.statsTotalLiquidity = async (useApi = true) => {
+            if (useApi) {
+                const network = curve.constants.NETWORK_NAME;
+                const poolType = !this.isFactory && !this.isCrypto ? "main" :
+                    !this.isFactory ? "crypto" :
+                        !(this.isCrypto && this.isFactory) ? "factory" :
+                            "factory-crypto";
+                const poolsData = (await _getPoolsFromApi(network, poolType)).poolData;
+                try {
+                    const totalLiquidity = poolsData.filter((data) => data.address.toLowerCase() === this.address.toLowerCase())[0].usdTotal;
+                    return String(totalLiquidity);
+                }
+                catch (err) {
+                    console.log(this.id, err.message);
                 }
-            });
-        }); };
-        this.statsBaseApy = function () { return __awaiter(_this, void 0, void 0, function () {
-            var _c, mainPoolsData, factoryPoolsData, poolData_2, network, poolsData, poolData;
-            var _this = this;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (![1284, 2222, 42220, 1313161554].includes(curve_1.curve.chainId)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, Promise.all([
-                                (0, external_api_1._getLegacyAPYsAndVolumes)(curve_1.curve.constants.NETWORK_NAME),
-                                (0, external_api_1._getFactoryAPYsAndVolumes)(curve_1.curve.constants.NETWORK_NAME),
-                            ])];
-                    case 1:
-                        _c = _d.sent(), mainPoolsData = _c[0], factoryPoolsData = _c[1];
-                        if (this.id in mainPoolsData) {
-                            return [2 /*return*/, {
-                                    day: mainPoolsData[this.id].apy.day.toString(),
-                                    week: mainPoolsData[this.id].apy.week.toString(),
-                                }];
-                        }
-                        poolData_2 = factoryPoolsData.find(function (d) { return d.poolAddress.toLowerCase() === _this.address; });
-                        if (!poolData_2)
-                            throw Error("Can't get base APY for ".concat(this.name, " (id: ").concat(this.id, ")"));
-                        return [2 /*return*/, {
-                                day: poolData_2.apy.toString(),
-                                week: poolData_2.apy.toString(),
-                            }];
-                    case 2:
-                        network = curve_1.curve.constants.NETWORK_NAME;
-                        return [4 /*yield*/, (0, external_api_1._getSubgraphData)(network)];
-                    case 3:
-                        poolsData = (_d.sent()).poolsData;
-                        poolData = poolsData.find(function (d) { return d.address.toLowerCase() === _this.address; });
-                        if (!poolData)
-                            throw Error("Can't get base APY for ".concat(this.name, " (id: ").concat(this.id, ")"));
-                        return [2 /*return*/, {
-                                day: poolData.latestDailyApy.toString(),
-                                week: poolData.latestWeeklyApy.toString(),
-                            }];
+            }
+            const balances = await this.statsUnderlyingBalances();
+            const promises = [];
+            for (const addr of this.underlyingCoinAddresses) {
+                promises.push(_getUsdRate(addr));
+            }
+            const prices = await Promise.all(promises);
+            const totalLiquidity = balances.reduce((liquidity, b, i) => liquidity + (Number(b) * prices[i]), 0);
+            return totalLiquidity.toFixed(8);
+        };
+        this.statsVolume = async () => {
+            if ([1284, 2222, 42220, 1313161554].includes(curve.chainId)) { // Moonbeam || Kava || Celo || Aurora
+                const [mainPoolsData, factoryPoolsData] = await Promise.all([
+                    _getLegacyAPYsAndVolumes(curve.constants.NETWORK_NAME),
+                    _getFactoryAPYsAndVolumes(curve.constants.NETWORK_NAME),
+                ]);
+                if (this.id in mainPoolsData) {
+                    return (mainPoolsData[this.id].volume ?? 0).toString();
+                }
+                const poolData = factoryPoolsData.find((d) => d.poolAddress.toLowerCase() === this.address);
+                if (!poolData)
+                    throw Error(`Can't get Volume for ${this.name} (id: ${this.id})`);
+                const lpPrice = await _getUsdRate(this.lpToken);
+                return (poolData.volume * lpPrice).toString();
+            }
+            const network = curve.constants.NETWORK_NAME;
+            const poolsData = (await _getSubgraphData(network)).poolsData;
+            const poolData = poolsData.find((d) => d.address.toLowerCase() === this.address);
+            if (!poolData)
+                throw Error(`Can't get Volume for ${this.name} (id: ${this.id})`);
+            return poolData.volumeUSD.toString();
+        };
+        this.statsBaseApy = async () => {
+            if ([1284, 2222, 42220, 1313161554].includes(curve.chainId)) { // Moonbeam || Kava || Celo || Aurora
+                const [mainPoolsData, factoryPoolsData] = await Promise.all([
+                    _getLegacyAPYsAndVolumes(curve.constants.NETWORK_NAME),
+                    _getFactoryAPYsAndVolumes(curve.constants.NETWORK_NAME),
+                ]);
+                if (this.id in mainPoolsData) {
+                    return {
+                        day: mainPoolsData[this.id].apy.day.toString(),
+                        week: mainPoolsData[this.id].apy.week.toString(),
+                    };
+                }
+                const poolData = factoryPoolsData.find((d) => d.poolAddress.toLowerCase() === this.address);
+                if (!poolData)
+                    throw Error(`Can't get base APY for ${this.name} (id: ${this.id})`);
+                return {
+                    day: poolData.apy.toString(),
+                    week: poolData.apy.toString(),
+                };
+            }
+            const network = curve.constants.NETWORK_NAME;
+            const poolsData = (await _getSubgraphData(network)).poolsData;
+            const poolData = poolsData.find((d) => d.address.toLowerCase() === this.address);
+            if (!poolData)
+                throw Error(`Can't get base APY for ${this.name} (id: ${this.id})`);
+            return {
+                day: poolData.latestDailyApy.toString(),
+                week: poolData.latestWeeklyApy.toString(),
+            };
+        };
+        this.statsTokenApy = async (useApi = true) => {
+            if (this.rewardsOnly())
+                throw Error(`${this.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
+            const isDisabledChain = [1313161554].includes(curve.chainId); // Disable Aurora
+            if (useApi && !isDisabledChain) {
+                const crvAPYs = await _getCrvApyFromApi();
+                const poolCrvApy = crvAPYs[this.gauge] ?? [0, 0]; // new pools might be missing
+                return [poolCrvApy[0], poolCrvApy[1]];
+            }
+            const totalLiquidityUSD = await this.statsTotalLiquidity();
+            if (Number(totalLiquidityUSD) === 0)
+                return [0, 0];
+            let inflationRateBN, workingSupplyBN, totalSupplyBN;
+            if (curve.chainId !== 1) {
+                const gaugeContract = curve.contracts[this.gauge].multicallContract;
+                const lpTokenContract = curve.contracts[this.lpToken].multicallContract;
+                const crvContract = curve.contracts[curve.constants.ALIASES.crv].contract;
+                const currentWeek = Math.floor(Date.now() / 1000 / WEEK);
+                [inflationRateBN, workingSupplyBN, totalSupplyBN] = (await curve.multicallProvider.all([
+                    gaugeContract.inflation_rate(currentWeek),
+                    gaugeContract.working_supply(),
+                    lpTokenContract.totalSupply(),
+                ])).map((value) => toBN(value));
+                if (inflationRateBN.eq(0)) {
+                    inflationRateBN = toBN(await crvContract.balanceOf(this.gauge, curve.constantOptions)).div(WEEK);
                 }
-            });
-        }); };
-        this.statsTokenApy = function (useApi) {
-            if (useApi === void 0) { useApi = true; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var isDisabledChain, crvAPYs, poolCrvApy, totalLiquidityUSD, inflationRateBN, workingSupplyBN, totalSupplyBN, gaugeContract, lpTokenContract, crvContract, currentWeek, _c, gaugeContract, lpTokenContract, gaugeControllerContract, weightBN, rateBN, crvPrice, baseApyBN, boostedApyBN;
-                var _d, _e;
-                var _f;
-                return __generator(this, function (_g) {
-                    switch (_g.label) {
-                        case 0:
-                            if (this.rewardsOnly())
-                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
-                            isDisabledChain = [1313161554].includes(curve_1.curve.chainId);
-                            if (!(useApi && !isDisabledChain)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, (0, utils_1._getCrvApyFromApi)()];
-                        case 1:
-                            crvAPYs = _g.sent();
-                            poolCrvApy = (_f = crvAPYs[this.gauge]) !== null && _f !== void 0 ? _f : [0, 0];
-                            return [2 /*return*/, [poolCrvApy[0], poolCrvApy[1]]];
-                        case 2: return [4 /*yield*/, this.statsTotalLiquidity()];
-                        case 3:
-                            totalLiquidityUSD = _g.sent();
-                            if (Number(totalLiquidityUSD) === 0)
-                                return [2 /*return*/, [0, 0]];
-                            if (!(curve_1.curve.chainId !== 1)) return [3 /*break*/, 7];
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            lpTokenContract = curve_1.curve.contracts[this.lpToken].multicallContract;
-                            crvContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.crv].contract;
-                            currentWeek = Math.floor(Date.now() / 1000 / WEEK);
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                    gaugeContract.inflation_rate(currentWeek),
-                                    gaugeContract.working_supply(),
-                                    lpTokenContract.totalSupply(),
-                                ])];
-                        case 4:
-                            _d = (_g.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflationRateBN = _d[0], workingSupplyBN = _d[1], totalSupplyBN = _d[2];
-                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 6];
-                            _c = utils_1.toBN;
-                            return [4 /*yield*/, crvContract.balanceOf(this.gauge, curve_1.curve.constantOptions)];
-                        case 5:
-                            inflationRateBN = _c.apply(void 0, [_g.sent()]).div(WEEK);
-                            _g.label = 6;
-                        case 6: return [3 /*break*/, 9];
-                        case 7:
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            lpTokenContract = curve_1.curve.contracts[this.lpToken].multicallContract;
-                            gaugeControllerContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.gauge_controller].multicallContract;
-                            weightBN = void 0;
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                    gaugeContract.inflation_rate(),
-                                    gaugeControllerContract.gauge_relative_weight(this.gauge),
-                                    gaugeContract.working_supply(),
-                                    lpTokenContract.totalSupply(),
-                                ])];
-                        case 8:
-                            _e = (_g.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflationRateBN = _e[0], weightBN = _e[1], workingSupplyBN = _e[2], totalSupplyBN = _e[3];
-                            inflationRateBN = inflationRateBN.times(weightBN);
-                            _g.label = 9;
-                        case 9:
-                            if (inflationRateBN.eq(0))
-                                return [2 /*return*/, [0, 0]];
-                            rateBN = inflationRateBN.times(31536000).times(0.4).div(workingSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD));
-                            return [4 /*yield*/, (0, utils_1._getUsdRate)(curve_1.curve.constants.ALIASES.crv)];
-                        case 10:
-                            crvPrice = _g.sent();
-                            baseApyBN = rateBN.times(crvPrice);
-                            boostedApyBN = baseApyBN.times(2.5);
-                            return [2 /*return*/, [baseApyBN.times(100).toNumber(), boostedApyBN.times(100).toNumber()]];
-                    }
-                });
-            });
+            }
+            else {
+                const gaugeContract = curve.contracts[this.gauge].multicallContract;
+                const lpTokenContract = curve.contracts[this.lpToken].multicallContract;
+                const gaugeControllerContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
+                let weightBN;
+                [inflationRateBN, weightBN, workingSupplyBN, totalSupplyBN] = (await curve.multicallProvider.all([
+                    gaugeContract.inflation_rate(),
+                    gaugeControllerContract.gauge_relative_weight(this.gauge),
+                    gaugeContract.working_supply(),
+                    lpTokenContract.totalSupply(),
+                ])).map((value) => toBN(value));
+                inflationRateBN = inflationRateBN.times(weightBN);
+            }
+            if (inflationRateBN.eq(0))
+                return [0, 0];
+            const rateBN = inflationRateBN.times(31536000).times(0.4).div(workingSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD));
+            const crvPrice = await _getUsdRate(curve.constants.ALIASES.crv);
+            const baseApyBN = rateBN.times(crvPrice);
+            const boostedApyBN = baseApyBN.times(2.5);
+            return [baseApyBN.times(100).toNumber(), boostedApyBN.times(100).toNumber()];
         };
-        this.statsRewardsApy = function (useApi) {
-            if (useApi === void 0) { useApi = true; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var isDisabledChain, rewards, apy, rewardTokens, _i, rewardTokens_1, rewardToken, gaugeContract, lpTokenContract, rewardContract, totalLiquidityUSD, rewardRate, _c, rewardData, _stakedSupply, _totalSupply, stakedSupplyBN, totalSupplyBN, inflationBN, periodFinish, baseApy;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
-                                return [2 /*return*/, []];
-                            isDisabledChain = [1313161554].includes(curve_1.curve.chainId);
-                            if (!(curve_1.curve.chainId === 1 || (useApi && !isDisabledChain))) return [3 /*break*/, 2];
-                            return [4 /*yield*/, (0, utils_1._getRewardsFromApi)()];
-                        case 1:
-                            rewards = _d.sent();
-                            if (!rewards[this.gauge])
-                                return [2 /*return*/, []];
-                            return [2 /*return*/, rewards[this.gauge].map(function (r) { return ({ gaugeAddress: r.gaugeAddress, tokenAddress: r.tokenAddress, symbol: r.symbol, apy: r.apy }); })];
-                        case 2:
-                            apy = [];
-                            return [4 /*yield*/, this.rewardTokens(false)];
-                        case 3:
-                            rewardTokens = _d.sent();
-                            _i = 0, rewardTokens_1 = rewardTokens;
-                            _d.label = 4;
-                        case 4:
-                            if (!(_i < rewardTokens_1.length)) return [3 /*break*/, 9];
-                            rewardToken = rewardTokens_1[_i];
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            lpTokenContract = curve_1.curve.contracts[this.lpToken].multicallContract;
-                            rewardContract = curve_1.curve.contracts[this.sRewardContract || this.gauge].multicallContract;
-                            return [4 /*yield*/, this.statsTotalLiquidity()];
-                        case 5:
-                            totalLiquidityUSD = _d.sent();
-                            return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken.token)];
-                        case 6:
-                            rewardRate = _d.sent();
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                    rewardContract.reward_data(rewardToken.token),
-                                    gaugeContract.totalSupply(),
-                                    lpTokenContract.totalSupply(),
-                                ])];
-                        case 7:
-                            _c = _d.sent(), rewardData = _c[0], _stakedSupply = _c[1], _totalSupply = _c[2];
-                            stakedSupplyBN = (0, utils_1.toBN)(_stakedSupply);
-                            totalSupplyBN = (0, utils_1.toBN)(_totalSupply);
-                            inflationBN = (0, utils_1.toBN)(rewardData.rate, rewardToken.decimals);
-                            periodFinish = Number(ethers_1.ethers.utils.formatUnits(rewardData.period_finish, 0)) * 1000;
-                            baseApy = periodFinish > Date.now() ?
-                                inflationBN.times(31536000).times(rewardRate).div(stakedSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)) :
-                                (0, utils_1.BN)(0);
-                            apy.push({
-                                gaugeAddress: this.gauge,
-                                tokenAddress: rewardToken.token,
-                                symbol: rewardToken.symbol,
-                                apy: baseApy.times(100).toNumber(),
-                            });
-                            _d.label = 8;
-                        case 8:
-                            _i++;
-                            return [3 /*break*/, 4];
-                        case 9: return [2 /*return*/, apy];
-                    }
+        this.statsRewardsApy = async (useApi = true) => {
+            if (this.gauge === curve.constants.ZERO_ADDRESS)
+                return [];
+            const isDisabledChain = [1313161554].includes(curve.chainId); // Disable Aurora
+            if (curve.chainId === 1 || (useApi && !isDisabledChain)) {
+                const rewards = await _getRewardsFromApi();
+                if (!rewards[this.gauge])
+                    return [];
+                return rewards[this.gauge].map((r) => ({ gaugeAddress: r.gaugeAddress, tokenAddress: r.tokenAddress, symbol: r.symbol, apy: r.apy }));
+            }
+            const apy = [];
+            const rewardTokens = await this.rewardTokens(false);
+            for (const rewardToken of rewardTokens) {
+                const gaugeContract = curve.contracts[this.gauge].multicallContract;
+                const lpTokenContract = curve.contracts[this.lpToken].multicallContract;
+                const rewardContract = curve.contracts[this.sRewardContract || this.gauge].multicallContract;
+                const totalLiquidityUSD = await this.statsTotalLiquidity();
+                const rewardRate = await _getUsdRate(rewardToken.token);
+                const [rewardData, _stakedSupply, _totalSupply] = await curve.multicallProvider.all([
+                    rewardContract.reward_data(rewardToken.token),
+                    gaugeContract.totalSupply(),
+                    lpTokenContract.totalSupply(),
+                ]);
+                const stakedSupplyBN = toBN(_stakedSupply);
+                const totalSupplyBN = toBN(_totalSupply);
+                const inflationBN = toBN(rewardData.rate, rewardToken.decimals);
+                const periodFinish = Number(curve.formatUnits(rewardData.period_finish, 0)) * 1000;
+                const baseApy = periodFinish > Date.now() ?
+                    inflationBN.times(31536000).times(rewardRate).div(stakedSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)) :
+                    BN(0);
+                apy.push({
+                    gaugeAddress: this.gauge,
+                    tokenAddress: rewardToken.token,
+                    symbol: rewardToken.symbol,
+                    apy: baseApy.times(100).toNumber(),
                 });
-            });
+            }
+            return apy;
         };
-        this._calcLpTokenAmount = (0, memoizee_1.default)(function (_amounts, isDeposit, useUnderlying) {
-            if (isDeposit === void 0) { isDeposit = true; }
-            if (useUnderlying === void 0) { useUnderlying = true; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var _rates, e_2, lpContract, _lpTotalSupply, decimals_1, amounts, seedAmounts_1, N_coins, decimals_2, calcContractAddress, calcContract, poolContract, lpContract, calls, res, _c, _totalSupply, _fee, _lpTokenAmount, balances, _d, totalSupplyBN, feeBN, lpTokenAmountBN, balancesBN, amountsBN, feesBN, i, _fees, _lpTokenFee, e_3, lpContract, _lpTotalSupply, decimals_3, amounts_1, seedAmounts_2, _amounts18Decimals;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
-                        case 0:
-                            _rates = [];
-                            if (!(!this.isMeta && useUnderlying)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, this._getRates()];
-                        case 1:
-                            // For lending pools. For others rate = 1
-                            _rates = _e.sent();
-                            _amounts = _amounts.map(function (_amount, i) {
-                                return _amount.mul(ethers_1.ethers.BigNumber.from(10).pow(18)).div(_rates[i]);
-                            });
-                            _e.label = 2;
-                        case 2:
-                            if (!this.isCrypto) return [3 /*break*/, 8];
-                            _e.label = 3;
-                        case 3:
-                            _e.trys.push([3, 5, , 8]);
-                            return [4 /*yield*/, this._pureCalcLpTokenAmount(_amounts, isDeposit, useUnderlying)];
-                        case 4: return [2 /*return*/, _e.sent()];
-                        case 5:
-                            e_2 = _e.sent();
-                            lpContract = curve_1.curve.contracts[this.lpToken].contract;
-                            return [4 /*yield*/, lpContract.totalSupply(curve_1.curve.constantOptions)];
-                        case 6:
-                            _lpTotalSupply = _e.sent();
-                            if (_lpTotalSupply.gt(0))
-                                throw e_2; // Already seeded
-                            if (this.isMeta && useUnderlying)
-                                throw Error("Initial deposit for crypto meta pools must be in wrapped coins");
-                            decimals_1 = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
-                            amounts = _amounts.map(function (_a, i) { return ethers_1.ethers.utils.formatUnits(_a, decimals_1[i]); });
-                            return [4 /*yield*/, this.cryptoSeedAmounts(amounts[0])];
-                        case 7:
-                            seedAmounts_1 = _e.sent();
-                            amounts.forEach(function (a, i) {
-                                if (!(0, utils_1.BN)(a).eq((0, utils_1.BN)(seedAmounts_1[i])))
-                                    throw Error("Amounts must be = ".concat(seedAmounts_1));
-                            });
-                            return [2 /*return*/, (0, utils_1.parseUnits)(Math.sqrt(Number(amounts[0]) * Number(amounts[1])))];
-                        case 8:
-                            _e.trys.push([8, 11, , 16]);
-                            N_coins = this.isMeta && useUnderlying ? this.underlyingCoins.length : this.wrappedCoins.length;
-                            decimals_2 = this.isMeta && useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
-                            calcContractAddress = this.isMeta && useUnderlying ? this.zap : this.address;
-                            calcContract = curve_1.curve.contracts[calcContractAddress].multicallContract;
-                            poolContract = curve_1.curve.contracts[this.address].multicallContract;
-                            lpContract = curve_1.curve.contracts[this.lpToken].multicallContract;
-                            calls = [lpContract.totalSupply(), poolContract.fee()];
-                            // lpAmount before fees
-                            if (this.isMetaFactory && useUnderlying) {
-                                calls.push(calcContract.calc_token_amount(this.address, _amounts, isDeposit));
-                            }
-                            else if (calcContract["calc_token_amount(uint256[".concat(N_coins, "],bool)")]) {
-                                calls.push(calcContract.calc_token_amount(_amounts, isDeposit, curve_1.curve.constantOptions));
-                            }
-                            else {
-                                calls.push(calcContract.calc_token_amount(_amounts, curve_1.curve.constantOptions));
-                            }
-                            return [4 /*yield*/, Promise.all([
-                                    curve_1.curve.multicallProvider.all(calls),
-                                    this.isMeta && useUnderlying ? this.stats.underlyingBalances() : this.stats.wrappedBalances(),
-                                ])];
-                        case 9:
-                            res = _e.sent();
-                            _c = res[0], _totalSupply = _c[0], _fee = _c[1], _lpTokenAmount = _c[2];
-                            balances = res[1];
-                            _d = [(0, utils_1.toBN)(_totalSupply), (0, utils_1.toBN)(_fee, 10).times(N_coins).div(4 * (N_coins - 1)), (0, utils_1.toBN)(_lpTokenAmount)], totalSupplyBN = _d[0], feeBN = _d[1], lpTokenAmountBN = _d[2];
-                            balancesBN = balances.map(function (b) { return (0, utils_1.BN)(b); });
-                            amountsBN = _amounts.map(function (_a, i) { return (0, utils_1.toBN)(_a, decimals_2[i]); });
-                            feesBN = Array(N_coins).fill((0, utils_1.BN)(0));
-                            if (totalSupplyBN.gt(0)) {
-                                for (i = 0; i < N_coins; i++) {
-                                    feesBN[i] = balancesBN[i].times(lpTokenAmountBN).div(totalSupplyBN).minus(amountsBN[i]).times(feeBN);
-                                    if (feesBN[i].lt(0))
-                                        feesBN[i] = feesBN[i].times(-1);
-                                }
-                            }
-                            _fees = feesBN.map(function (fBN, i) { return (0, utils_1.fromBN)(fBN, decimals_2[i]); });
-                            return [4 /*yield*/, this._pureCalcLpTokenAmount(_fees, !isDeposit, this.isMeta && useUnderlying)];
-                        case 10:
-                            _lpTokenFee = _e.sent();
-                            if (isDeposit)
-                                _lpTokenFee = _lpTokenFee.mul(-1);
-                            return [2 /*return*/, _lpTokenAmount.add(_lpTokenFee)];
-                        case 11:
-                            e_3 = _e.sent();
-                            if (!isDeposit)
-                                throw e_3; // Seeding is only for deposit
-                            lpContract = curve_1.curve.contracts[this.lpToken].contract;
-                            return [4 /*yield*/, lpContract.totalSupply(curve_1.curve.constantOptions)];
-                        case 12:
-                            _lpTotalSupply = _e.sent();
-                            if (_lpTotalSupply.gt(0))
-                                throw e_3; // Already seeded
-                            decimals_3 = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
-                            amounts_1 = _amounts.map(function (_a, i) { return ethers_1.ethers.utils.formatUnits(_a, decimals_3[i]); });
-                            if (!(this.isMeta && useUnderlying)) return [3 /*break*/, 14];
-                            return [4 /*yield*/, this.metaUnderlyingSeedAmounts(amounts_1[0])];
-                        case 13:
-                            seedAmounts_2 = _e.sent();
-                            amounts_1.forEach(function (a, i) {
-                                if (!(0, utils_1.BN)(a).eq((0, utils_1.BN)(seedAmounts_2[i])))
-                                    throw Error("Amounts must be = ".concat(seedAmounts_2));
-                            });
-                            return [3 /*break*/, 15];
-                        case 14:
-                            if (_amounts[0].lte(0))
-                                throw Error("Initial deposit amounts must be >0");
-                            amounts_1.forEach(function (a) {
-                                if (a !== amounts_1[0])
-                                    throw Error("Initial deposit amounts must be equal");
-                            });
-                            _e.label = 15;
-                        case 15:
-                            _amounts18Decimals = amounts_1.map(function (a) { return (0, utils_1.parseUnits)(a); });
-                            return [2 /*return*/, _amounts18Decimals.reduce(function (_a, _b) { return _a.add(_b); })];
-                        case 16: return [2 /*return*/];
+        this._calcLpTokenAmount = memoize(async (_amounts, isDeposit = true, useUnderlying = true) => {
+            let _rates = [];
+            if (!this.isMeta && useUnderlying) {
+                // For lending pools. For others rate = 1
+                _rates = await this._getRates();
+                _amounts = _amounts.map((_amount, i) => _amount * (10n ** 18n) / _rates[i]);
+            }
+            if (this.isCrypto) {
+                try {
+                    return await this._pureCalcLpTokenAmount(_amounts, isDeposit, useUnderlying);
+                }
+                catch (e) {
+                    const lpContract = curve.contracts[this.lpToken].contract;
+                    const _lpTotalSupply = await lpContract.totalSupply(curve.constantOptions);
+                    if (_lpTotalSupply > 0n)
+                        throw e; // Already seeded
+                    if (this.isMeta && useUnderlying)
+                        throw Error("Initial deposit for crypto meta pools must be in wrapped coins");
+                    const decimals = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
+                    const amounts = _amounts.map((_a, i) => curve.formatUnits(_a, decimals[i]));
+                    const seedAmounts = await this.cryptoSeedAmounts(amounts[0]); // Checks N coins == 2 and amounts > 0
+                    amounts.forEach((a, i) => {
+                        if (!BN(a).eq(BN(seedAmounts[i])))
+                            throw Error(`Amounts must be = ${seedAmounts}`);
+                    });
+                    return parseUnits(Math.sqrt(Number(amounts[0]) * Number(amounts[1])));
+                }
+            }
+            try {
+                // --- Getting lpAmount before fees and pool params ---
+                const N_coins = this.isMeta && useUnderlying ? this.underlyingCoins.length : this.wrappedCoins.length;
+                const decimals = this.isMeta && useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
+                const calcContractAddress = this.isMeta && useUnderlying ? this.zap : this.address;
+                const calcContract = curve.contracts[calcContractAddress].multicallContract;
+                const poolContract = curve.contracts[this.address].multicallContract;
+                const lpContract = curve.contracts[this.lpToken].multicallContract;
+                // totalSupply and fee
+                const calls = [lpContract.totalSupply(), poolContract.fee()];
+                // lpAmount before fees
+                if (this.isMetaFactory && useUnderlying) {
+                    calls.push(calcContract.calc_token_amount(this.address, _amounts, isDeposit));
+                }
+                else if (calcContract[`calc_token_amount(uint256[${N_coins}],bool)`]) {
+                    calls.push(calcContract.calc_token_amount(_amounts, isDeposit, curve.constantOptions));
+                }
+                else {
+                    calls.push(calcContract.calc_token_amount(_amounts, curve.constantOptions));
+                }
+                const res = await Promise.all([
+                    curve.multicallProvider.all(calls),
+                    this.isMeta && useUnderlying ? this.stats.underlyingBalances() : this.stats.wrappedBalances(),
+                ]);
+                const [_totalSupply, _fee, _lpTokenAmount] = res[0];
+                const balances = res[1];
+                const [totalSupplyBN, feeBN, lpTokenAmountBN] = [toBN(_totalSupply), toBN(_fee, 10).times(N_coins).div(4 * (N_coins - 1)), toBN(_lpTokenAmount)];
+                const balancesBN = balances.map((b) => BN(b));
+                const amountsBN = _amounts.map((_a, i) => toBN(_a, decimals[i]));
+                // --- Calculating new amounts (old amounts minus fees) ---
+                // fees[i] = | expected1/total_supply * balances[i] - amounts[i] | * fee
+                const feesBN = Array(N_coins).fill(BN(0));
+                if (totalSupplyBN.gt(0)) {
+                    for (let i = 0; i < N_coins; i++) {
+                        feesBN[i] = balancesBN[i].times(lpTokenAmountBN).div(totalSupplyBN).minus(amountsBN[i]).times(feeBN);
+                        if (feesBN[i].lt(0))
+                            feesBN[i] = feesBN[i].times(-1);
                     }
-                });
-            });
+                }
+                const _fees = feesBN.map((fBN, i) => fromBN(fBN, decimals[i]));
+                // --- Getting final lpAmount ---
+                let _lpTokenFee = await this._pureCalcLpTokenAmount(_fees, !isDeposit, this.isMeta && useUnderlying);
+                if (isDeposit)
+                    _lpTokenFee = _lpTokenFee * (-1n);
+                return _lpTokenAmount + _lpTokenFee;
+            }
+            catch (e) { // Seeding
+                if (!isDeposit)
+                    throw e; // Seeding is only for deposit
+                const lpContract = curve.contracts[this.lpToken].contract;
+                const _lpTotalSupply = await lpContract.totalSupply(curve.constantOptions);
+                if (_lpTotalSupply > 0n)
+                    throw e; // Already seeded
+                const decimals = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
+                const amounts = _amounts.map((_a, i) => curve.formatUnits(_a, decimals[i]));
+                if (this.isMeta && useUnderlying) {
+                    const seedAmounts = this.metaUnderlyingSeedAmounts(amounts[0]); // Checks N coins == 2 and amounts > 0
+                    amounts.forEach((a, i) => {
+                        if (!BN(a).eq(BN(seedAmounts[i])))
+                            throw Error(`Amounts must be = ${seedAmounts}`);
+                    });
+                }
+                else {
+                    if (_amounts[0] <= 0n)
+                        throw Error("Initial deposit amounts must be >0");
+                    amounts.forEach((a) => {
+                        if (a !== amounts[0])
+                            throw Error("Initial deposit amounts must be equal");
+                    });
+                }
+                const _amounts18Decimals = amounts.map((a) => parseUnits(a));
+                return _amounts18Decimals.reduce((_a, _b) => _a + _b);
+            }
         }, {
             primitive: true,
             promise: true,
             maxAge: 60 * 1000, // 1m
         });
         // ---------------- CRV PROFIT, CLAIM, BOOSTING ----------------
-        this.crvProfit = function (address) {
-            if (address === void 0) { address = ""; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var inflationRateBN, workingSupplyBN, workingBalanceBN, gaugeContract, crvContract, currentWeek, _c, gaugeContract, gaugeControllerContract, weightBN, crvPrice, dailyIncome, weeklyIncome, monthlyIncome, annualIncome;
-                var _d, _e;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
-                        case 0:
-                            if (this.rewardsOnly())
-                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use rewardsProfit instead"));
-                            address = address || curve_1.curve.signerAddress;
-                            if (!address)
-                                throw Error("Need to connect wallet or pass address into args");
-                            if (!(curve_1.curve.chainId !== 1)) return [3 /*break*/, 4];
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            crvContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.crv].contract;
-                            currentWeek = Math.floor(Date.now() / 1000 / WEEK);
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                    gaugeContract.inflation_rate(currentWeek),
-                                    gaugeContract.working_balances(address),
-                                    gaugeContract.working_supply(),
-                                ])];
-                        case 1:
-                            _d = (_f.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflationRateBN = _d[0], workingBalanceBN = _d[1], workingSupplyBN = _d[2];
-                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 3];
-                            _c = utils_1.toBN;
-                            return [4 /*yield*/, crvContract.balanceOf(this.gauge, curve_1.curve.constantOptions)];
-                        case 2:
-                            inflationRateBN = _c.apply(void 0, [_f.sent()]).div(WEEK);
-                            _f.label = 3;
-                        case 3: return [3 /*break*/, 6];
-                        case 4:
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            gaugeControllerContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.gauge_controller].multicallContract;
-                            weightBN = void 0;
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                    gaugeContract.inflation_rate(),
-                                    gaugeControllerContract.gauge_relative_weight(this.gauge),
-                                    gaugeContract.working_balances(address),
-                                    gaugeContract.working_supply(),
-                                ])];
-                        case 5:
-                            _e = (_f.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflationRateBN = _e[0], weightBN = _e[1], workingBalanceBN = _e[2], workingSupplyBN = _e[3];
-                            inflationRateBN = inflationRateBN.times(weightBN);
-                            _f.label = 6;
-                        case 6: return [4 /*yield*/, (0, utils_1._getUsdRate)('CRV')];
-                        case 7:
-                            crvPrice = _f.sent();
-                            if (workingSupplyBN.eq(0))
-                                return [2 /*return*/, {
-                                        day: "0.0",
-                                        week: "0.0",
-                                        month: "0.0",
-                                        year: "0.0",
-                                        token: curve_1.curve.constants.ALIASES.crv,
-                                        symbol: 'CRV',
-                                        price: crvPrice,
-                                    }];
-                            dailyIncome = inflationRateBN.times(DAY).times(workingBalanceBN).div(workingSupplyBN);
-                            weeklyIncome = inflationRateBN.times(WEEK).times(workingBalanceBN).div(workingSupplyBN);
-                            monthlyIncome = inflationRateBN.times(MONTH).times(workingBalanceBN).div(workingSupplyBN);
-                            annualIncome = inflationRateBN.times(YEAR).times(workingBalanceBN).div(workingSupplyBN);
-                            return [2 /*return*/, {
-                                    day: dailyIncome.toString(),
-                                    week: weeklyIncome.toString(),
-                                    month: monthlyIncome.toString(),
-                                    year: annualIncome.toString(),
-                                    token: curve_1.curve.constants.ALIASES.crv,
-                                    symbol: 'CRV',
-                                    price: crvPrice,
-                                }];
-                    }
-                });
-            });
+        this.crvProfit = async (address = "") => {
+            if (this.rewardsOnly())
+                throw Error(`${this.name} has Rewards-Only Gauge. Use rewardsProfit instead`);
+            address = address || curve.signerAddress;
+            if (!address)
+                throw Error("Need to connect wallet or pass address into args");
+            let inflationRateBN, workingSupplyBN, workingBalanceBN;
+            if (curve.chainId !== 1) {
+                const gaugeContract = curve.contracts[this.gauge].multicallContract;
+                const crvContract = curve.contracts[curve.constants.ALIASES.crv].contract;
+                const currentWeek = Math.floor(Date.now() / 1000 / WEEK);
+                [inflationRateBN, workingBalanceBN, workingSupplyBN] = (await curve.multicallProvider.all([
+                    gaugeContract.inflation_rate(currentWeek),
+                    gaugeContract.working_balances(address),
+                    gaugeContract.working_supply(),
+                ])).map((value) => toBN(value));
+                if (inflationRateBN.eq(0)) {
+                    inflationRateBN = toBN(await crvContract.balanceOf(this.gauge, curve.constantOptions)).div(WEEK);
+                }
+            }
+            else {
+                const gaugeContract = curve.contracts[this.gauge].multicallContract;
+                const gaugeControllerContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
+                let weightBN;
+                [inflationRateBN, weightBN, workingBalanceBN, workingSupplyBN] = (await curve.multicallProvider.all([
+                    gaugeContract.inflation_rate(),
+                    gaugeControllerContract.gauge_relative_weight(this.gauge),
+                    gaugeContract.working_balances(address),
+                    gaugeContract.working_supply(),
+                ])).map((value) => toBN(value));
+                inflationRateBN = inflationRateBN.times(weightBN);
+            }
+            const crvPrice = await _getUsdRate('CRV');
+            if (workingSupplyBN.eq(0))
+                return {
+                    day: "0.0",
+                    week: "0.0",
+                    month: "0.0",
+                    year: "0.0",
+                    token: curve.constants.ALIASES.crv,
+                    symbol: 'CRV',
+                    price: crvPrice,
+                };
+            const dailyIncome = inflationRateBN.times(DAY).times(workingBalanceBN).div(workingSupplyBN);
+            const weeklyIncome = inflationRateBN.times(WEEK).times(workingBalanceBN).div(workingSupplyBN);
+            const monthlyIncome = inflationRateBN.times(MONTH).times(workingBalanceBN).div(workingSupplyBN);
+            const annualIncome = inflationRateBN.times(YEAR).times(workingBalanceBN).div(workingSupplyBN);
+            return {
+                day: dailyIncome.toString(),
+                week: weeklyIncome.toString(),
+                month: monthlyIncome.toString(),
+                year: annualIncome.toString(),
+                token: curve.constants.ALIASES.crv,
+                symbol: 'CRV',
+                price: crvPrice,
+            };
         };
-        this.boost = function (address) {
-            if (address === void 0) { address = ""; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var gaugeContract, _c, workingBalanceBN, balanceBN, boostBN;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            if (curve_1.curve.chainId !== 1)
-                                throw Error("Boosting is available only on Ethereum network");
-                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
-                                throw Error("".concat(this.name, " doesn't have gauge"));
-                            address = address || curve_1.curve.signerAddress;
-                            if (!address)
-                                throw Error("Need to connect wallet or pass address into args");
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                    gaugeContract.working_balances(address),
-                                    gaugeContract.balanceOf(address),
-                                ])];
-                        case 1:
-                            _c = (_d.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), workingBalanceBN = _c[0], balanceBN = _c[1];
-                            boostBN = workingBalanceBN.div(0.4).div(balanceBN);
-                            return [2 /*return*/, boostBN.toFixed(4).replace(/([0-9])0+$/, '$1')];
-                    }
-                });
-            });
+        this.boost = async (address = "") => {
+            if (curve.chainId !== 1)
+                throw Error("Boosting is available only on Ethereum network");
+            if (this.gauge === curve.constants.ZERO_ADDRESS)
+                throw Error(`${this.name} doesn't have gauge`);
+            address = address || curve.signerAddress;
+            if (!address)
+                throw Error("Need to connect wallet or pass address into args");
+            const gaugeContract = curve.contracts[this.gauge].multicallContract;
+            const [workingBalanceBN, balanceBN] = (await curve.multicallProvider.all([
+                gaugeContract.working_balances(address),
+                gaugeContract.balanceOf(address),
+            ])).map((value) => toBN(value));
+            const boostBN = workingBalanceBN.div(0.4).div(balanceBN);
+            return boostBN.toFixed(4).replace(/([0-9])0+$/, '$1');
         };
-        this.currentCrvApy = function (address) {
-            if (address === void 0) { address = ""; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var _c, baseApy, maxApy, boost;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            address = address || curve_1.curve.signerAddress;
-                            if (!address)
-                                throw Error("Need to connect wallet or pass address into args");
-                            return [4 /*yield*/, this.statsTokenApy()];
-                        case 1:
-                            _c = _d.sent(), baseApy = _c[0], maxApy = _c[1];
-                            if (curve_1.curve.chainId !== 1)
-                                return [2 /*return*/, baseApy];
-                            return [4 /*yield*/, this.boost(address)];
-                        case 2:
-                            boost = _d.sent();
-                            if (boost == "2.5")
-                                return [2 /*return*/, maxApy];
-                            if (boost === "NaN")
-                                return [2 /*return*/, NaN];
-                            return [2 /*return*/, (0, utils_1.BN)(baseApy).times((0, utils_1.BN)(boost)).toNumber()];
-                    }
-                });
-            });
+        this.currentCrvApy = async (address = "") => {
+            address = address || curve.signerAddress;
+            if (!address)
+                throw Error("Need to connect wallet or pass address into args");
+            const [baseApy, maxApy] = await this.statsTokenApy();
+            if (curve.chainId !== 1)
+                return baseApy;
+            const boost = await this.boost(address);
+            if (boost == "2.5")
+                return maxApy;
+            if (boost === "NaN")
+                return NaN;
+            return BN(baseApy).times(BN(boost)).toNumber();
         };
-        this.maxBoostedStake = function () {
-            var addresses = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                addresses[_i] = arguments[_i];
+        this.maxBoostedStake = async (...addresses) => {
+            if (curve.chainId !== 1)
+                throw Error("Boosting is available only on Ethereum network");
+            if (this.gauge === curve.constants.ZERO_ADDRESS)
+                throw Error(`${this.name} doesn't have gauge`);
+            if (addresses.length == 1 && Array.isArray(addresses[0]))
+                addresses = addresses[0];
+            if (addresses.length === 0 && curve.signerAddress !== '')
+                addresses = [curve.signerAddress];
+            if (addresses.length === 0)
+                throw Error("Need to connect wallet or pass addresses into args");
+            const votingEscrowContract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
+            const gaugeContract = curve.contracts[this.gauge].multicallContract;
+            const contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
+            addresses.forEach((account) => {
+                contractCalls.push(votingEscrowContract.balanceOf(account));
+            });
+            const _response = await curve.multicallProvider.all(contractCalls);
+            const responseBN = _response.map((value) => toBN(value));
+            const [veTotalSupplyBN, gaugeTotalSupplyBN] = responseBN.splice(0, 2);
+            const resultBN = {};
+            addresses.forEach((acct, i) => {
+                resultBN[acct] = responseBN[i].div(veTotalSupplyBN).times(gaugeTotalSupplyBN);
+            });
+            const result = {};
+            for (const entry of Object.entries(resultBN)) {
+                result[entry[0]] = toStringFromBN(entry[1]);
             }
-            return __awaiter(_this, void 0, void 0, function () {
-                var votingEscrowContract, gaugeContract, contractCalls, _response, responseBN, _c, veTotalSupplyBN, gaugeTotalSupplyBN, resultBN, result, _d, _e, entry;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
-                        case 0:
-                            if (curve_1.curve.chainId !== 1)
-                                throw Error("Boosting is available only on Ethereum network");
-                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
-                                throw Error("".concat(this.name, " doesn't have gauge"));
-                            if (addresses.length == 1 && Array.isArray(addresses[0]))
-                                addresses = addresses[0];
-                            if (addresses.length === 0 && curve_1.curve.signerAddress !== '')
-                                addresses = [curve_1.curve.signerAddress];
-                            if (addresses.length === 0)
-                                throw Error("Need to connect wallet or pass addresses into args");
-                            votingEscrowContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.voting_escrow].multicallContract;
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
-                            addresses.forEach(function (account) {
-                                contractCalls.push(votingEscrowContract.balanceOf(account));
-                            });
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
-                        case 1:
-                            _response = _f.sent();
-                            responseBN = _response.map(function (value) { return (0, utils_1.toBN)(value); });
-                            _c = responseBN.splice(0, 2), veTotalSupplyBN = _c[0], gaugeTotalSupplyBN = _c[1];
-                            resultBN = {};
-                            addresses.forEach(function (acct, i) {
-                                resultBN[acct] = responseBN[i].div(veTotalSupplyBN).times(gaugeTotalSupplyBN);
-                            });
-                            result = {};
-                            for (_d = 0, _e = Object.entries(resultBN); _d < _e.length; _d++) {
-                                entry = _e[_d];
-                                result[entry[0]] = (0, utils_1.toStringFromBN)(entry[1]);
-                            }
-                            return [2 /*return*/, addresses.length === 1 ? result[addresses[0]] : result];
-                    }
-                });
-            });
+            return addresses.length === 1 ? result[addresses[0]] : result;
         };
         // ---------------- REWARDS PROFIT, CLAIM ----------------
-        this.rewardTokens = (0, memoizee_1.default)(function (useApi) {
-            if (useApi === void 0) { useApi = true; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var rewards, gaugeContract, gaugeMulticallContract, rewardCount, _c, _d, _e, tokenCalls, i, tokens, tokenInfoCalls, _i, tokens_1, token, tokenMulticallContract, tokenInfo_1, i, rewardContract, method, token, tokenMulticallContract, res, symbol, decimals;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
-                        case 0:
-                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
-                                return [2 /*return*/, []];
-                            if (!useApi) return [3 /*break*/, 2];
-                            return [4 /*yield*/, (0, utils_1._getRewardsFromApi)()];
-                        case 1:
-                            rewards = _f.sent();
-                            if (!rewards[this.gauge])
-                                return [2 /*return*/, []];
-                            rewards[this.gauge].forEach(function (r) { return (0, utils_1._setContracts)(r.tokenAddress, ERC20_json_1.default); });
-                            return [2 /*return*/, rewards[this.gauge].map(function (r) { return ({ token: r.tokenAddress, symbol: r.symbol, decimals: r.decimals }); })];
-                        case 2:
-                            gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                            gaugeMulticallContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            if (!("reward_tokens(uint256)" in gaugeContract)) return [3 /*break*/, 7];
-                            rewardCount = 8;
-                            if (!("reward_count()" in gaugeContract)) return [3 /*break*/, 4];
-                            _c = Number;
-                            _e = (_d = ethers_1.ethers.utils).formatUnits;
-                            return [4 /*yield*/, gaugeContract.reward_count(curve_1.curve.constantOptions)];
-                        case 3:
-                            rewardCount = _c.apply(void 0, [_e.apply(_d, [_f.sent(), 0])]);
-                            _f.label = 4;
-                        case 4:
-                            tokenCalls = [];
-                            for (i = 0; i < rewardCount; i++) {
-                                tokenCalls.push(gaugeMulticallContract.reward_tokens(i));
-                            }
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all(tokenCalls)];
-                        case 5:
-                            tokens = (_f.sent())
-                                .filter(function (addr) { return addr !== ethers_1.ethers.constants.AddressZero; })
-                                .map(function (addr) { return addr.toLowerCase(); });
-                            tokenInfoCalls = [];
-                            for (_i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
-                                token = tokens_1[_i];
-                                (0, utils_1._setContracts)(token, ERC20_json_1.default);
-                                tokenMulticallContract = curve_1.curve.contracts[token].multicallContract;
-                                tokenInfoCalls.push(tokenMulticallContract.symbol(), tokenMulticallContract.decimals());
-                            }
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all(tokenInfoCalls)];
-                        case 6:
-                            tokenInfo_1 = _f.sent();
-                            for (i = 0; i < tokens.length; i++) {
-                                curve_1.curve.constants.DECIMALS[tokens[i]] = tokenInfo_1[(i * 2) + 1];
-                            }
-                            return [2 /*return*/, tokens.map(function (token, i) { return ({ token: token, symbol: tokenInfo_1[i * 2], decimals: tokenInfo_1[(i * 2) + 1] }); })];
-                        case 7:
-                            if (!('claimable_reward(address)' in gaugeContract)) return [3 /*break*/, 10];
-                            rewardContract = curve_1.curve.contracts[this.sRewardContract].contract;
-                            method = "snx()" in rewardContract ? "snx" : "rewardsToken" // susd, tbtc : dusd, musd, rsv, sbtc
-                            ;
-                            return [4 /*yield*/, rewardContract[method](curve_1.curve.constantOptions)];
-                        case 8:
-                            token = (_f.sent()).toLowerCase();
-                            (0, utils_1._setContracts)(token, ERC20_json_1.default);
-                            tokenMulticallContract = curve_1.curve.contracts[token].multicallContract;
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                    tokenMulticallContract.symbol(),
-                                    tokenMulticallContract.decimals(),
-                                ])];
-                        case 9:
-                            res = _f.sent();
-                            symbol = res[0];
-                            decimals = res[1];
-                            return [2 /*return*/, [{ token: token, symbol: symbol, decimals: decimals }]];
-                        case 10: return [2 /*return*/, []]; // gauge
-                    }
-                });
-            });
+        this.rewardTokens = memoize(async (useApi = true) => {
+            if (this.gauge === curve.constants.ZERO_ADDRESS)
+                return [];
+            if (useApi) {
+                const rewards = await _getRewardsFromApi();
+                if (!rewards[this.gauge])
+                    return [];
+                rewards[this.gauge].forEach((r) => _setContracts(r.tokenAddress, ERC20Abi));
+                return rewards[this.gauge].map((r) => ({ token: r.tokenAddress, symbol: r.symbol, decimals: r.decimals }));
+            }
+            const gaugeContract = curve.contracts[this.gauge].contract;
+            const gaugeMulticallContract = curve.contracts[this.gauge].multicallContract;
+            if ("reward_tokens(uint256)" in gaugeContract) {
+                let rewardCount = 8; // gauge_v2, gauge_v3, gauge_rewards_only, gauge_child
+                if ("reward_count()" in gaugeContract) { // gauge_v4, gauge_v5, gauge_factory
+                    rewardCount = Number(curve.formatUnits(await gaugeContract.reward_count(curve.constantOptions), 0));
+                }
+                const tokenCalls = [];
+                for (let i = 0; i < rewardCount; i++) {
+                    tokenCalls.push(gaugeMulticallContract.reward_tokens(i));
+                }
+                const tokens = (await curve.multicallProvider.all(tokenCalls))
+                    .filter((addr) => addr !== curve.constants.ZERO_ADDRESS)
+                    .map((addr) => addr.toLowerCase());
+                const tokenInfoCalls = [];
+                for (const token of tokens) {
+                    _setContracts(token, ERC20Abi);
+                    const tokenMulticallContract = curve.contracts[token].multicallContract;
+                    tokenInfoCalls.push(tokenMulticallContract.symbol(), tokenMulticallContract.decimals());
+                }
+                const tokenInfo = await curve.multicallProvider.all(tokenInfoCalls);
+                for (let i = 0; i < tokens.length; i++) {
+                    curve.constants.DECIMALS[tokens[i]] = tokenInfo[(i * 2) + 1];
+                }
+                return tokens.map((token, i) => ({ token, symbol: tokenInfo[i * 2], decimals: tokenInfo[(i * 2) + 1] }));
+            }
+            else if ('claimable_reward(address)' in gaugeContract) { // gauge_synthetix
+                const rewardContract = curve.contracts[this.sRewardContract].contract;
+                const method = "snx()" in rewardContract ? "snx" : "rewardsToken"; // susd, tbtc : dusd, musd, rsv, sbtc
+                const token = (await rewardContract[method](curve.constantOptions)).toLowerCase();
+                _setContracts(token, ERC20Abi);
+                const tokenMulticallContract = curve.contracts[token].multicallContract;
+                const res = await curve.multicallProvider.all([
+                    tokenMulticallContract.symbol(),
+                    tokenMulticallContract.decimals(),
+                ]);
+                const symbol = res[0];
+                const decimals = res[1];
+                return [{ token, symbol, decimals }];
+            }
+            return []; // gauge
         }, {
             promise: true,
             maxAge: 30 * 60 * 1000, // 30m
         });
-        this.rewardsProfit = function (address) {
-            if (address === void 0) { address = ""; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var rewardTokens, gaugeContract, result, calls, _i, rewardTokens_2, rewardToken, res, balanceBN, totalSupplyBN, _c, rewardTokens_3, rewardToken, _rewardData, periodFinish, inflationRateBN, tokenPrice, rewardToken, sRewardContract, _d, _inflationRate, _periodFinish, _balance, _totalSupply, periodFinish, inflationRateBN, balanceBN, totalSupplyBN, tokenPrice, _e, rewardTokens_4, rewardToken, tokenPrice;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
-                        case 0:
-                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
-                                throw Error("".concat(this.name, " doesn't have gauge"));
-                            address = address || curve_1.curve.signerAddress;
-                            if (!address)
-                                throw Error("Need to connect wallet or pass address into args");
-                            return [4 /*yield*/, this.rewardTokens()];
-                        case 1:
-                            rewardTokens = _f.sent();
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            result = [];
-                            if (!('reward_data(address)' in curve_1.curve.contracts[this.gauge].contract)) return [3 /*break*/, 7];
-                            calls = [gaugeContract.balanceOf(address), gaugeContract.totalSupply()];
-                            for (_i = 0, rewardTokens_2 = rewardTokens; _i < rewardTokens_2.length; _i++) {
-                                rewardToken = rewardTokens_2[_i];
-                                calls.push(gaugeContract.reward_data(rewardToken.token));
-                            }
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all(calls)];
-                        case 2:
-                            res = _f.sent();
-                            balanceBN = (0, utils_1.toBN)(res.shift());
-                            totalSupplyBN = (0, utils_1.toBN)(res.shift());
-                            _c = 0, rewardTokens_3 = rewardTokens;
-                            _f.label = 3;
-                        case 3:
-                            if (!(_c < rewardTokens_3.length)) return [3 /*break*/, 6];
-                            rewardToken = rewardTokens_3[_c];
-                            _rewardData = res.shift();
-                            periodFinish = Number(ethers_1.ethers.utils.formatUnits(_rewardData.period_finish, 0)) * 1000;
-                            inflationRateBN = periodFinish > Date.now() ? (0, utils_1.toBN)(_rewardData.rate, rewardToken.decimals) : (0, utils_1.BN)(0);
-                            return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken.token)];
-                        case 4:
-                            tokenPrice = _f.sent();
-                            result.push({
-                                day: inflationRateBN.times(DAY).times(balanceBN).div(totalSupplyBN).toString(),
-                                week: inflationRateBN.times(WEEK).times(balanceBN).div(totalSupplyBN).toString(),
-                                month: inflationRateBN.times(MONTH).times(balanceBN).div(totalSupplyBN).toString(),
-                                year: inflationRateBN.times(YEAR).times(balanceBN).div(totalSupplyBN).toString(),
-                                token: rewardToken.token,
-                                symbol: rewardToken.symbol,
-                                price: tokenPrice,
-                            });
-                            _f.label = 5;
-                        case 5:
-                            _c++;
-                            return [3 /*break*/, 3];
-                        case 6: return [3 /*break*/, 14];
-                        case 7:
-                            if (!(this.sRewardContract && "rewardRate()" in curve_1.curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1)) return [3 /*break*/, 10];
-                            rewardToken = rewardTokens[0];
-                            sRewardContract = curve_1.curve.contracts[this.sRewardContract].multicallContract;
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                    sRewardContract.rewardRate(),
-                                    sRewardContract.periodFinish(),
-                                    gaugeContract.balanceOf(address),
-                                    gaugeContract.totalSupply(),
-                                ])];
-                        case 8:
-                            _d = _f.sent(), _inflationRate = _d[0], _periodFinish = _d[1], _balance = _d[2], _totalSupply = _d[3];
-                            periodFinish = _periodFinish.toNumber() * 1000;
-                            inflationRateBN = periodFinish > Date.now() ? (0, utils_1.toBN)(_inflationRate, rewardToken.decimals) : (0, utils_1.BN)(0);
-                            balanceBN = (0, utils_1.toBN)(_balance);
-                            totalSupplyBN = (0, utils_1.toBN)(_totalSupply);
-                            return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken.token)];
-                        case 9:
-                            tokenPrice = _f.sent();
-                            result.push({
-                                day: inflationRateBN.times(DAY).times(balanceBN).div(totalSupplyBN).toString(),
-                                week: inflationRateBN.times(WEEK).times(balanceBN).div(totalSupplyBN).toString(),
-                                month: inflationRateBN.times(MONTH).times(balanceBN).div(totalSupplyBN).toString(),
-                                year: inflationRateBN.times(YEAR).times(balanceBN).div(totalSupplyBN).toString(),
-                                token: rewardToken.token,
-                                symbol: rewardToken.symbol,
-                                price: tokenPrice,
-                            });
-                            return [3 /*break*/, 14];
-                        case 10:
-                            if (!['aave', 'saave', 'ankreth'].includes(this.id)) return [3 /*break*/, 14];
-                            _e = 0, rewardTokens_4 = rewardTokens;
-                            _f.label = 11;
-                        case 11:
-                            if (!(_e < rewardTokens_4.length)) return [3 /*break*/, 14];
-                            rewardToken = rewardTokens_4[_e];
-                            return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken.token)];
-                        case 12:
-                            tokenPrice = _f.sent();
-                            result.push({
-                                day: "0",
-                                week: "0",
-                                month: "0",
-                                year: "0",
-                                token: rewardToken.token,
-                                symbol: rewardToken.symbol,
-                                price: tokenPrice,
-                            });
-                            _f.label = 13;
-                        case 13:
-                            _e++;
-                            return [3 /*break*/, 11];
-                        case 14: return [2 /*return*/, result];
-                    }
+        this.rewardsProfit = async (address = "") => {
+            if (this.gauge === curve.constants.ZERO_ADDRESS)
+                throw Error(`${this.name} doesn't have gauge`);
+            address = address || curve.signerAddress;
+            if (!address)
+                throw Error("Need to connect wallet or pass address into args");
+            const rewardTokens = await this.rewardTokens();
+            const gaugeContract = curve.contracts[this.gauge].multicallContract;
+            const result = [];
+            if ('reward_data(address)' in curve.contracts[this.gauge].contract) {
+                const calls = [gaugeContract.balanceOf(address), gaugeContract.totalSupply()];
+                for (const rewardToken of rewardTokens) {
+                    calls.push(gaugeContract.reward_data(rewardToken.token));
+                }
+                const res = await curve.multicallProvider.all(calls);
+                const balanceBN = toBN(res.shift());
+                const totalSupplyBN = toBN(res.shift());
+                for (const rewardToken of rewardTokens) {
+                    const _rewardData = res.shift();
+                    const periodFinish = Number(curve.formatUnits(_rewardData.period_finish, 0)) * 1000;
+                    const inflationRateBN = periodFinish > Date.now() ? toBN(_rewardData.rate, rewardToken.decimals) : BN(0);
+                    const tokenPrice = await _getUsdRate(rewardToken.token);
+                    result.push({
+                        day: inflationRateBN.times(DAY).times(balanceBN).div(totalSupplyBN).toString(),
+                        week: inflationRateBN.times(WEEK).times(balanceBN).div(totalSupplyBN).toString(),
+                        month: inflationRateBN.times(MONTH).times(balanceBN).div(totalSupplyBN).toString(),
+                        year: inflationRateBN.times(YEAR).times(balanceBN).div(totalSupplyBN).toString(),
+                        token: rewardToken.token,
+                        symbol: rewardToken.symbol,
+                        price: tokenPrice,
+                    });
+                }
+            }
+            else if (this.sRewardContract && "rewardRate()" in _curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1) {
+                const rewardToken = rewardTokens[0];
+                const sRewardContract = curve.contracts[this.sRewardContract].multicallContract;
+                const [_inflationRate, _periodFinish, _balance, _totalSupply] = await curve.multicallProvider.all([
+                    sRewardContract.rewardRate(),
+                    sRewardContract.periodFinish(),
+                    gaugeContract.balanceOf(address),
+                    gaugeContract.totalSupply(),
+                ]);
+                const periodFinish = Number(_periodFinish) * 1000;
+                const inflationRateBN = periodFinish > Date.now() ? toBN(_inflationRate, rewardToken.decimals) : BN(0);
+                const balanceBN = toBN(_balance);
+                const totalSupplyBN = toBN(_totalSupply);
+                const tokenPrice = await _getUsdRate(rewardToken.token);
+                result.push({
+                    day: inflationRateBN.times(DAY).times(balanceBN).div(totalSupplyBN).toString(),
+                    week: inflationRateBN.times(WEEK).times(balanceBN).div(totalSupplyBN).toString(),
+                    month: inflationRateBN.times(MONTH).times(balanceBN).div(totalSupplyBN).toString(),
+                    year: inflationRateBN.times(YEAR).times(balanceBN).div(totalSupplyBN).toString(),
+                    token: rewardToken.token,
+                    symbol: rewardToken.symbol,
+                    price: tokenPrice,
                 });
-            });
+            }
+            else if (['aave', 'saave', 'ankreth'].includes(this.id)) {
+                for (const rewardToken of rewardTokens) {
+                    const tokenPrice = await _getUsdRate(rewardToken.token);
+                    result.push({
+                        day: "0",
+                        week: "0",
+                        month: "0",
+                        year: "0",
+                        token: rewardToken.token,
+                        symbol: rewardToken.symbol,
+                        price: tokenPrice,
+                    });
+                }
+            }
+            return result;
         };
         // ---------------- ... ----------------
-        this.gaugeOptimalDeposits = function () {
-            var accounts = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                accounts[_i] = arguments[_i];
+        this.gaugeOptimalDeposits = async (...accounts) => {
+            if (this.gauge === curve.constants.ZERO_ADDRESS)
+                throw Error(`${this.name} doesn't have gauge`);
+            if (accounts.length == 1 && Array.isArray(accounts[0]))
+                accounts = accounts[0];
+            const votingEscrowContract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
+            const lpTokenContract = curve.contracts[this.lpToken].multicallContract;
+            const gaugeContract = curve.contracts[this.gauge].multicallContract;
+            const contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
+            accounts.forEach((account) => {
+                contractCalls.push(votingEscrowContract.balanceOf(account), lpTokenContract.balanceOf(account), gaugeContract.balanceOf(account));
+            });
+            const _response = await curve.multicallProvider.all(contractCalls);
+            const response = _response.map((value) => toBN(value));
+            const [veTotalSupply, gaugeTotalSupply] = response.splice(0, 2);
+            const votingPower = {};
+            let totalBalance = BN(0);
+            for (const acct of accounts) {
+                votingPower[acct] = response[0];
+                totalBalance = totalBalance.plus(response[1]).plus(response[2]);
+                response.splice(0, 3);
             }
-            return __awaiter(_this, void 0, void 0, function () {
-                var votingEscrowContract, lpTokenContract, gaugeContract, contractCalls, _response, response, _c, veTotalSupply, gaugeTotalSupply, votingPower, totalBalance, _d, accounts_1, acct, totalPower, optimalBN, _e, accounts_2, acct, amount, _f, accounts_3, acct, optimal, _g, _h, entry;
-                return __generator(this, function (_j) {
-                    switch (_j.label) {
-                        case 0:
-                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
-                                throw Error("".concat(this.name, " doesn't have gauge"));
-                            if (accounts.length == 1 && Array.isArray(accounts[0]))
-                                accounts = accounts[0];
-                            votingEscrowContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.voting_escrow].multicallContract;
-                            lpTokenContract = curve_1.curve.contracts[this.lpToken].multicallContract;
-                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
-                            accounts.forEach(function (account) {
-                                contractCalls.push(votingEscrowContract.balanceOf(account), lpTokenContract.balanceOf(account), gaugeContract.balanceOf(account));
-                            });
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
-                        case 1:
-                            _response = _j.sent();
-                            response = _response.map(function (value) { return (0, utils_1.toBN)(value); });
-                            _c = response.splice(0, 2), veTotalSupply = _c[0], gaugeTotalSupply = _c[1];
-                            votingPower = {};
-                            totalBalance = (0, utils_1.BN)(0);
-                            for (_d = 0, accounts_1 = accounts; _d < accounts_1.length; _d++) {
-                                acct = accounts_1[_d];
-                                votingPower[acct] = response[0];
-                                totalBalance = totalBalance.plus(response[1]).plus(response[2]);
-                                response.splice(0, 3);
-                            }
-                            totalPower = Object.values(votingPower).reduce(function (sum, item) { return sum.plus(item); });
-                            optimalBN = Object.fromEntries(accounts.map(function (acc) { return [acc, (0, utils_1.BN)(0)]; }));
-                            if (totalBalance.lt(gaugeTotalSupply.times(totalPower).div(veTotalSupply))) {
-                                for (_e = 0, accounts_2 = accounts; _e < accounts_2.length; _e++) {
-                                    acct = accounts_2[_e];
-                                    amount = gaugeTotalSupply.times(votingPower[acct]).div(veTotalSupply).lt(totalBalance) ?
-                                        gaugeTotalSupply.times(votingPower[acct]).div(veTotalSupply) : totalBalance;
-                                    optimalBN[acct] = amount;
-                                    totalBalance = totalBalance.minus(amount);
-                                    if (totalBalance.lte(0)) {
-                                        break;
-                                    }
-                                }
-                            }
-                            else {
-                                if (totalPower.lt(0)) {
-                                    for (_f = 0, accounts_3 = accounts; _f < accounts_3.length; _f++) {
-                                        acct = accounts_3[_f];
-                                        optimalBN[acct] = totalBalance.times(votingPower[acct]).div(totalPower);
-                                    }
-                                }
-                                optimalBN[accounts[0]] = optimalBN[accounts[0]].plus(totalBalance.minus(Object.values(optimalBN).reduce(function (sum, item) { return sum.plus(item); })));
-                            }
-                            optimal = {};
-                            for (_g = 0, _h = Object.entries(optimalBN); _g < _h.length; _g++) {
-                                entry = _h[_g];
-                                optimal[entry[0]] = (0, utils_1.toStringFromBN)(entry[1]);
-                            }
-                            return [2 /*return*/, optimal];
+            const totalPower = Object.values(votingPower).reduce((sum, item) => sum.plus(item));
+            // @ts-ignore
+            const optimalBN = Object.fromEntries(accounts.map((acc) => [acc, BN(0)]));
+            if (totalBalance.lt(gaugeTotalSupply.times(totalPower).div(veTotalSupply))) {
+                for (const acct of accounts) {
+                    // min(voting, lp)
+                    const amount = gaugeTotalSupply.times(votingPower[acct]).div(veTotalSupply).lt(totalBalance) ?
+                        gaugeTotalSupply.times(votingPower[acct]).div(veTotalSupply) : totalBalance;
+                    optimalBN[acct] = amount;
+                    totalBalance = totalBalance.minus(amount);
+                    if (totalBalance.lte(0)) {
+                        break;
                     }
-                });
-            });
+                }
+            }
+            else {
+                if (totalPower.lt(0)) {
+                    for (const acct of accounts) {
+                        optimalBN[acct] = totalBalance.times(votingPower[acct]).div(totalPower);
+                    }
+                }
+                optimalBN[accounts[0]] = optimalBN[accounts[0]].plus(totalBalance.minus(Object.values(optimalBN).reduce((sum, item) => sum.plus(item))));
+            }
+            const optimal = {};
+            for (const entry of Object.entries(optimalBN)) {
+                optimal[entry[0]] = toStringFromBN(entry[1]);
+            }
+            return optimal;
         };
-        this._getCoinIdx = function (coin, useUnderlying) {
-            if (useUnderlying === void 0) { useUnderlying = true; }
+        this._getCoinIdx = (coin, useUnderlying = true) => {
             if (typeof coin === 'number') {
-                var coins_N = useUnderlying ? _this.underlyingCoins.length : _this.wrappedCoins.length;
-                var idx_1 = coin;
-                if (!Number.isInteger(idx_1)) {
+                const coins_N = useUnderlying ? this.underlyingCoins.length : this.wrappedCoins.length;
+                const idx = coin;
+                if (!Number.isInteger(idx)) {
                     throw Error('Index must be integer');
                 }
-                if (idx_1 < 0) {
+                if (idx < 0) {
                     throw Error('Index must be >= 0');
                 }
-                if (idx_1 > coins_N - 1) {
-                    throw Error("Index must be < ".concat(coins_N));
+                if (idx > coins_N - 1) {
+                    throw Error(`Index must be < ${coins_N}`);
                 }
-                return idx_1;
+                return idx;
             }
-            var coinAddress = (0, utils_1._getCoinAddresses)(coin)[0];
-            var lowerCaseCoinAddresses = useUnderlying ?
-                _this.underlyingCoinAddresses.map(function (c) { return c.toLowerCase(); }) :
-                _this.wrappedCoinAddresses.map(function (c) { return c.toLowerCase(); });
-            var idx = lowerCaseCoinAddresses.indexOf(coinAddress.toLowerCase());
+            const [coinAddress] = _getCoinAddresses(coin);
+            const lowerCaseCoinAddresses = useUnderlying ?
+                this.underlyingCoinAddresses.map((c) => c.toLowerCase()) :
+                this.wrappedCoinAddresses.map((c) => c.toLowerCase());
+            const idx = lowerCaseCoinAddresses.indexOf(coinAddress.toLowerCase());
             if (idx === -1) {
-                throw Error("There is no ".concat(coin, " among ").concat(_this.name, " pool ").concat(useUnderlying ? 'underlying' : 'wrapped', " coins"));
+                throw Error(`There is no ${coin} among ${this.name} pool ${useUnderlying ? 'underlying' : 'wrapped'} coins`);
             }
             return idx;
         };
-        this._getRates = function () { return __awaiter(_this, void 0, void 0, function () {
-            var _rates, i, addr, _c, _d, _e, _f;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        _rates = [];
-                        i = 0;
-                        _g.label = 1;
-                    case 1:
-                        if (!(i < this.wrappedCoinAddresses.length)) return [3 /*break*/, 9];
-                        addr = this.wrappedCoinAddresses[i];
-                        if (!this.useLending[i]) return [3 /*break*/, 7];
-                        if (!['compound', 'usdt', 'ib'].includes(this.id)) return [3 /*break*/, 3];
-                        _d = (_c = _rates).push;
-                        return [4 /*yield*/, curve_1.curve.contracts[addr].contract.exchangeRateStored()];
-                    case 2:
-                        _d.apply(_c, [_g.sent()]);
-                        return [3 /*break*/, 6];
-                    case 3:
-                        if (!['y', 'busd', 'pax'].includes(this.id)) return [3 /*break*/, 5];
-                        _f = (_e = _rates).push;
-                        return [4 /*yield*/, curve_1.curve.contracts[addr].contract.getPricePerFullShare()];
-                    case 4:
-                        _f.apply(_e, [_g.sent()]);
-                        return [3 /*break*/, 6];
-                    case 5:
-                        _rates.push(ethers_1.ethers.BigNumber.from(10).pow(18)); // Aave ratio 1:1
-                        _g.label = 6;
-                    case 6: return [3 /*break*/, 8];
-                    case 7:
-                        _rates.push(ethers_1.ethers.BigNumber.from(10).pow(18));
-                        _g.label = 8;
-                    case 8:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 9: return [2 /*return*/, _rates];
+        this._getRates = async () => {
+            const _rates = [];
+            for (let i = 0; i < this.wrappedCoinAddresses.length; i++) {
+                const addr = this.wrappedCoinAddresses[i];
+                if (this.useLending[i]) {
+                    if (['compound', 'usdt', 'ib'].includes(this.id)) {
+                        _rates.push(await curve.contracts[addr].contract.exchangeRateStored());
+                    }
+                    else if (['y', 'busd', 'pax'].includes(this.id)) {
+                        _rates.push(await curve.contracts[addr].contract.getPricePerFullShare());
+                    }
+                    else {
+                        _rates.push(10n ** 18n); // Aave ratio 1:1
+                    }
+                }
+                else {
+                    _rates.push(10n ** 18n);
                 }
-            });
-        }); };
-        this._balances = function (rawCoinNames, rawCoinAddresses) {
-            var addresses = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                addresses[_i - 2] = arguments[_i];
             }
-            return __awaiter(_this, void 0, void 0, function () {
-                var coinNames, coinAddresses, i, rawBalances, balances, _c, addresses_1, address, _d, coinNames_1, coinName;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
-                        case 0:
-                            coinNames = [];
-                            coinAddresses = [];
-                            // removing duplicates
-                            for (i = 0; i < rawCoinAddresses.length; i++) {
-                                if (!coinAddresses.includes(rawCoinAddresses[i])) {
-                                    coinNames.push(rawCoinNames[i]);
-                                    coinAddresses.push(rawCoinAddresses[i]);
-                                }
-                            }
-                            addresses = (0, utils_1._prepareAddresses)(addresses);
-                            return [4 /*yield*/, (0, utils_1._getBalances)(coinAddresses, addresses)];
-                        case 1:
-                            rawBalances = _e.sent();
-                            balances = {};
-                            for (_c = 0, addresses_1 = addresses; _c < addresses_1.length; _c++) {
-                                address = addresses_1[_c];
-                                balances[address] = {};
-                                for (_d = 0, coinNames_1 = coinNames; _d < coinNames_1.length; _d++) {
-                                    coinName = coinNames_1[_d];
-                                    balances[address][coinName] = rawBalances[address].shift();
-                                }
-                            }
-                            return [2 /*return*/, addresses.length === 1 ? balances[addresses[0]] : balances];
-                    }
-                });
-            });
+            return _rates;
         };
-        this._underlyingPrices = function () { return __awaiter(_this, void 0, void 0, function () {
-            var promises, _i, _c, addr;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        promises = [];
-                        for (_i = 0, _c = this.underlyingCoinAddresses; _i < _c.length; _i++) {
-                            addr = _c[_i];
-                            promises.push((0, utils_1._getUsdRate)(addr));
-                        }
-                        return [4 /*yield*/, Promise.all(promises)];
-                    case 1: return [2 /*return*/, _d.sent()];
+        this._balances = async (rawCoinNames, rawCoinAddresses, ...addresses) => {
+            const coinNames = [];
+            const coinAddresses = [];
+            // removing duplicates
+            for (let i = 0; i < rawCoinAddresses.length; i++) {
+                if (!coinAddresses.includes(rawCoinAddresses[i])) {
+                    coinNames.push(rawCoinNames[i]);
+                    coinAddresses.push(rawCoinAddresses[i]);
                 }
-            });
-        }); };
-        // NOTE! It may crash!
-        this._wrappedPrices = function () { return __awaiter(_this, void 0, void 0, function () {
-            var promises, _i, _c, addr;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        promises = [];
-                        for (_i = 0, _c = this.wrappedCoinAddresses; _i < _c.length; _i++) {
-                            addr = _c[_i];
-                            promises.push((0, utils_1._getUsdRate)(addr));
-                        }
-                        return [4 /*yield*/, Promise.all(promises)];
-                    case 1: return [2 /*return*/, _d.sent()];
+            }
+            addresses = _prepareAddresses(addresses);
+            const rawBalances = await _getBalances(coinAddresses, addresses);
+            const balances = {};
+            for (const address of addresses) {
+                balances[address] = {};
+                for (const coinName of coinNames) {
+                    balances[address][coinName] = rawBalances[address].shift();
                 }
-            });
-        }); };
-        var poolData = __assign(__assign(__assign({}, curve_1.curve.constants.POOLS_DATA), curve_1.curve.constants.FACTORY_POOLS_DATA), curve_1.curve.constants.CRYPTO_FACTORY_POOLS_DATA)[id];
+            }
+            return addresses.length === 1 ? balances[addresses[0]] : balances;
+        };
+        this._underlyingPrices = async () => {
+            const promises = [];
+            for (const addr of this.underlyingCoinAddresses) {
+                promises.push(_getUsdRate(addr));
+            }
+            return await Promise.all(promises);
+        };
+        // NOTE! It may crash!
+        this._wrappedPrices = async () => {
+            const promises = [];
+            for (const addr of this.wrappedCoinAddresses) {
+                promises.push(_getUsdRate(addr));
+            }
+            return await Promise.all(promises);
+        };
+        const poolData = { ...curve.constants.POOLS_DATA, ...curve.constants.FACTORY_POOLS_DATA, ...curve.constants.CRYPTO_FACTORY_POOLS_DATA }[id];
         this.id = id;
         this.name = poolData.name;
         this.fullName = poolData.full_name;
@@ -1134,15 +751,15 @@ var PoolTemplate = /** @class */ (function () {
         this.isFactory = poolData.is_factory || false;
         this.isMetaFactory = (this.isMeta && this.isFactory) || this.zap === '0xa79828df1850e8a3a3064576f380d90aecdd3359';
         this.basePool = poolData.base_pool || '';
-        this.metaCoinIdx = this.isMeta ? (_c = poolData.meta_coin_idx) !== null && _c !== void 0 ? _c : poolData.wrapped_coins.length - 1 : -1;
+        this.metaCoinIdx = this.isMeta ? poolData.meta_coin_idx ?? poolData.wrapped_coins.length - 1 : -1;
         this.underlyingCoins = poolData.underlying_coins;
         this.wrappedCoins = poolData.wrapped_coins;
         this.underlyingCoinAddresses = poolData.underlying_coin_addresses;
         this.wrappedCoinAddresses = poolData.wrapped_coin_addresses;
         this.underlyingDecimals = poolData.underlying_decimals;
         this.wrappedDecimals = poolData.wrapped_decimals;
-        this.useLending = poolData.use_lending || poolData.underlying_coin_addresses.map(function () { return false; });
-        this.inApi = (_d = poolData.in_api) !== null && _d !== void 0 ? _d : false;
+        this.useLending = poolData.use_lending || poolData.underlying_coin_addresses.map(() => false);
+        this.inApi = poolData.in_api ?? false;
         this.estimateGas = {
             depositApprove: this.depositApproveEstimateGas.bind(this),
             deposit: this.depositEstimateGas.bind(this),
@@ -1189,168 +806,92 @@ var PoolTemplate = /** @class */ (function () {
             allCoinBalances: this.walletAllCoinBalances.bind(this),
         };
     }
-    PoolTemplate.prototype.rewardsOnly = function () {
-        if (curve_1.curve.chainId === 2222)
+    rewardsOnly() {
+        if (curve.chainId === 2222)
             return true; // TODO remove this for Kava and Celo
-        if (this.gauge === ethers_1.ethers.constants.AddressZero)
-            throw Error("".concat(this.name, " doesn't have gauge"));
-        var gaugeContract = curve_1.curve.contracts[this.gauge].contract;
+        if (this.gauge === curve.constants.ZERO_ADDRESS)
+            throw Error(`${this.name} doesn't have gauge`);
+        const gaugeContract = curve.contracts[this.gauge].contract;
         return !('inflation_rate()' in gaugeContract || 'inflation_rate(uint256)' in gaugeContract);
-    };
-    PoolTemplate.prototype.statsWrappedBalances = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var swapContract, contractCalls, _wrappedBalances;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        swapContract = curve_1.curve.contracts[this.address].multicallContract;
-                        contractCalls = this.wrappedCoins.map(function (_, i) { return swapContract.balances(i); });
-                        return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
-                    case 1:
-                        _wrappedBalances = _c.sent();
-                        return [2 /*return*/, _wrappedBalances.map(function (_b, i) { return ethers_1.ethers.utils.formatUnits(_b, _this.wrappedDecimals[i]); })];
-                }
-            });
-        });
-    };
+    }
+    async statsWrappedBalances() {
+        const swapContract = curve.contracts[this.address].multicallContract;
+        const contractCalls = this.wrappedCoins.map((_, i) => swapContract.balances(i));
+        const _wrappedBalances = await curve.multicallProvider.all(contractCalls);
+        return _wrappedBalances.map((_b, i) => curve.formatUnits(_b, this.wrappedDecimals[i]));
+    }
     // OVERRIDE
-    PoolTemplate.prototype.statsUnderlyingBalances = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.statsWrappedBalances()];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype._pureCalcLpTokenAmount = function (_amounts, isDeposit, useUnderlying) {
-        if (isDeposit === void 0) { isDeposit = true; }
-        if (useUnderlying === void 0) { useUnderlying = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            var calcContractAddress, N_coins, contract;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        calcContractAddress = this.isMeta && useUnderlying ? this.zap : this.address;
-                        N_coins = useUnderlying ? this.underlyingCoins.length : this.wrappedCoins.length;
-                        contract = curve_1.curve.contracts[calcContractAddress].contract;
-                        if (!(this.isMetaFactory && useUnderlying)) return [3 /*break*/, 4];
-                        if (!contract["calc_token_amount(address,uint256[".concat(N_coins, "],bool)")]) return [3 /*break*/, 2];
-                        return [4 /*yield*/, contract.calc_token_amount(this.address, _amounts, isDeposit, curve_1.curve.constantOptions)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                    case 2: return [4 /*yield*/, contract.calc_token_amount(this.address, _amounts, curve_1.curve.constantOptions)];
-                    case 3: return [2 /*return*/, _c.sent()];
-                    case 4:
-                        if (!contract["calc_token_amount(uint256[".concat(N_coins, "],bool)")]) return [3 /*break*/, 6];
-                        return [4 /*yield*/, contract.calc_token_amount(_amounts, isDeposit, curve_1.curve.constantOptions)];
-                    case 5: return [2 /*return*/, _c.sent()];
-                    case 6: return [4 /*yield*/, contract.calc_token_amount(_amounts, curve_1.curve.constantOptions)];
-                    case 7: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.calcLpTokenAmount = function (amounts, isDeposit) {
-        if (isDeposit === void 0) { isDeposit = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _underlyingAmounts, _expected;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (amounts.length !== this.underlyingCoinAddresses.length) {
-                            throw Error("".concat(this.name, " pool has ").concat(this.underlyingCoinAddresses.length, " coins (amounts provided for ").concat(amounts.length, ")"));
-                        }
-                        _underlyingAmounts = amounts.map(function (amount, i) { return (0, utils_1.parseUnits)(amount, _this.underlyingDecimals[i]); });
-                        return [4 /*yield*/, this._calcLpTokenAmount(_underlyingAmounts, isDeposit, true)];
-                    case 1:
-                        _expected = _c.sent();
-                        return [2 /*return*/, ethers_1.ethers.utils.formatUnits(_expected)];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.calcLpTokenAmountWrapped = function (amounts, isDeposit) {
-        if (isDeposit === void 0) { isDeposit = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _amounts, _expected;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (amounts.length !== this.wrappedCoinAddresses.length) {
-                            throw Error("".concat(this.name, " pool has ").concat(this.wrappedCoinAddresses.length, " coins (amounts provided for ").concat(amounts.length, ")"));
-                        }
-                        if (this.isFake) {
-                            throw Error("".concat(this.name, " pool doesn't have this method"));
-                        }
-                        _amounts = amounts.map(function (amount, i) { return (0, utils_1.parseUnits)(amount, _this.wrappedDecimals[i]); });
-                        return [4 /*yield*/, this._calcLpTokenAmount(_amounts, isDeposit, false)];
-                    case 1:
-                        _expected = _c.sent();
-                        return [2 /*return*/, ethers_1.ethers.utils.formatUnits(_expected)];
-                }
-            });
-        });
-    };
+    async statsUnderlyingBalances() {
+        return await this.statsWrappedBalances();
+    }
+    async _pureCalcLpTokenAmount(_amounts, isDeposit = true, useUnderlying = true) {
+        const calcContractAddress = this.isMeta && useUnderlying ? this.zap : this.address;
+        const N_coins = useUnderlying ? this.underlyingCoins.length : this.wrappedCoins.length;
+        const contract = curve.contracts[calcContractAddress].contract;
+        if (this.isMetaFactory && useUnderlying) {
+            if (contract[`calc_token_amount(address,uint256[${N_coins}],bool)`]) {
+                return await contract.calc_token_amount(this.address, _amounts, isDeposit, curve.constantOptions);
+            }
+            return await contract.calc_token_amount(this.address, _amounts, curve.constantOptions);
+        }
+        if (contract[`calc_token_amount(uint256[${N_coins}],bool)`]) {
+            return await contract.calc_token_amount(_amounts, isDeposit, curve.constantOptions);
+        }
+        return await contract.calc_token_amount(_amounts, curve.constantOptions);
+    }
+    async calcLpTokenAmount(amounts, isDeposit = true) {
+        if (amounts.length !== this.underlyingCoinAddresses.length) {
+            throw Error(`${this.name} pool has ${this.underlyingCoinAddresses.length} coins (amounts provided for ${amounts.length})`);
+        }
+        const _underlyingAmounts = amounts.map((amount, i) => parseUnits(amount, this.underlyingDecimals[i]));
+        const _expected = await this._calcLpTokenAmount(_underlyingAmounts, isDeposit, true);
+        return curve.formatUnits(_expected);
+    }
+    async calcLpTokenAmountWrapped(amounts, isDeposit = true) {
+        if (amounts.length !== this.wrappedCoinAddresses.length) {
+            throw Error(`${this.name} pool has ${this.wrappedCoinAddresses.length} coins (amounts provided for ${amounts.length})`);
+        }
+        if (this.isFake) {
+            throw Error(`${this.name} pool doesn't have this method`);
+        }
+        const _amounts = amounts.map((amount, i) => parseUnits(amount, this.wrappedDecimals[i]));
+        const _expected = await this._calcLpTokenAmount(_amounts, isDeposit, false);
+        return curve.formatUnits(_expected);
+    }
     // ---------------- DEPOSIT ----------------
-    PoolTemplate.prototype.metaUnderlyingSeedAmounts = function (amount1) {
+    metaUnderlyingSeedAmounts(amount1) {
         if (this.isCrypto)
-            throw Error("Use cryptoSeedAmounts method for ".concat(this.name, " pool"));
+            throw Error(`Use cryptoSeedAmounts method for ${this.name} pool`);
         if (!this.isMeta)
             throw Error("metaUnderlyingSeedAmounts method exists only for meta stable pools");
-        var amount1BN = (0, utils_1.BN)(amount1);
+        const amount1BN = BN(amount1);
         if (amount1BN.lte(0))
             throw Error("Initial deposit amounts must be > 0");
-        var amounts = [(0, utils_1._cutZeros)(amount1BN.toFixed(this.underlyingDecimals[0]))];
-        for (var i = 1; i < this.underlyingDecimals.length; i++) {
+        const amounts = [_cutZeros(amount1BN.toFixed(this.underlyingDecimals[0]))];
+        for (let i = 1; i < this.underlyingDecimals.length; i++) {
             amounts.push(amount1BN.div(this.underlyingDecimals.length - 1).toFixed(this.underlyingDecimals[i]));
         }
         return amounts;
-    };
-    PoolTemplate.prototype.cryptoSeedAmounts = function (amount1) {
-        return __awaiter(this, void 0, void 0, function () {
-            var decimals, amount1BN, priceScaleBN, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!this.isCrypto)
-                            throw Error("cryptoSeedAmounts method doesn't exist for stable pools");
-                        decimals = this.isMeta ? this.wrappedDecimals : this.underlyingDecimals;
-                        if (decimals.length > 2)
-                            throw Error("cryptoSeedAmounts method doesn't exist for pools with N coins > 2");
-                        amount1BN = (0, utils_1.BN)(amount1);
-                        if (amount1BN.lte(0))
-                            throw Error("Initial deposit amounts must be > 0");
-                        _c = utils_1.toBN;
-                        return [4 /*yield*/, curve_1.curve.contracts[this.address].contract.price_scale(curve_1.curve.constantOptions)];
-                    case 1:
-                        priceScaleBN = _c.apply(void 0, [_d.sent()]);
-                        return [2 /*return*/, [(0, utils_1._cutZeros)(amount1BN.toFixed(decimals[0])), (0, utils_1._cutZeros)(amount1BN.div(priceScaleBN).toFixed(decimals[1]))]];
-                }
-            });
-        });
-    };
+    }
+    async cryptoSeedAmounts(amount1) {
+        if (!this.isCrypto)
+            throw Error("cryptoSeedAmounts method doesn't exist for stable pools");
+        const decimals = this.isMeta ? this.wrappedDecimals : this.underlyingDecimals;
+        if (decimals.length > 2)
+            throw Error("cryptoSeedAmounts method doesn't exist for pools with N coins > 2");
+        const amount1BN = BN(amount1);
+        if (amount1BN.lte(0))
+            throw Error("Initial deposit amounts must be > 0");
+        const priceScaleBN = toBN(await curve.contracts[this.address].contract.price_scale(curve.constantOptions));
+        return [_cutZeros(amount1BN.toFixed(decimals[0])), _cutZeros(amount1BN.div(priceScaleBN).toFixed(decimals[1]))];
+    }
     // OVERRIDE
-    PoolTemplate.prototype.depositBalancedAmounts = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("depositBalancedAmounts method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
-    PoolTemplate.prototype.depositExpected = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.calcLpTokenAmount(amounts)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+    async depositBalancedAmounts() {
+        throw Error(`depositBalancedAmounts method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
+    async depositExpected(amounts) {
+        return await this.calcLpTokenAmount(amounts);
+    }
     // | balanced[i] / sum(balanced[j]) = balance[i] / sum(balance[j]) |
     // | sum(pj * balanced[j]) = sum(aj * pj)                          |
     //
@@ -1361,1761 +902,807 @@ var PoolTemplate = /** @class */ (function () {
     // totalBalanceBN = sum(balance[j])
     // ratiosBN[i] = balancesBN[i] / totalBalanceBN = ri = balance[i] / sum(balance[j])
     // denominatorBN = sum(rj * pj / ri)
-    PoolTemplate.prototype._balancedAmountsWithSameValue = function (amountsBN, pricesBN, balancesBN) {
-        var valuesBN = amountsBN.map(function (aBN, i) { return aBN.times(pricesBN[i]); });
-        var totalValueBN = valuesBN.reduce(function (v1BN, v2BN) { return v1BN.plus(v2BN); });
-        var totalBalanceBN = balancesBN.reduce(function (b1BN, b2BN) { return b1BN.plus(b2BN); });
-        var ratiosBN = balancesBN.map(function (bBN) { return bBN.div(totalBalanceBN); });
-        var balancedAmountsBN = [];
-        var _loop_1 = function (i) {
-            var denominatorBN = ratiosBN.map(function (rBN, j) { return rBN.times(pricesBN[j])
-                .div(ratiosBN[i]); }).reduce(function (xBN, yBN) { return xBN.plus(yBN); });
+    _balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN) {
+        const valuesBN = amountsBN.map((aBN, i) => aBN.times(pricesBN[i]));
+        const totalValueBN = valuesBN.reduce((v1BN, v2BN) => v1BN.plus(v2BN));
+        const totalBalanceBN = balancesBN.reduce((b1BN, b2BN) => b1BN.plus(b2BN));
+        const ratiosBN = balancesBN.map((bBN) => bBN.div(totalBalanceBN));
+        const balancedAmountsBN = [];
+        for (let i = 0; i < amountsBN.length; i++) {
+            const denominatorBN = ratiosBN.map((rBN, j) => rBN.times(pricesBN[j])
+                .div(ratiosBN[i])).reduce((xBN, yBN) => xBN.plus(yBN));
             balancedAmountsBN.push(totalValueBN.div(denominatorBN));
-        };
-        for (var i = 0; i < amountsBN.length; i++) {
-            _loop_1(i);
         }
         return balancedAmountsBN.map(String);
-    };
-    PoolTemplate.prototype.depositBonus = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var amountsBN, prices, _c, pricesBN, balancesBN, balancedAmounts, expectedBN, _d, balancedExpectedBN, _e;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        amountsBN = amounts.map(utils_1.BN);
-                        if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._underlyingPrices()];
-                    case 1:
-                        _c = _f.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _c = this.underlyingCoins.map(function () { return 1; });
-                        _f.label = 3;
-                    case 3:
-                        prices = _c;
-                        pricesBN = prices.map(utils_1.BN);
-                        return [4 /*yield*/, this.stats.underlyingBalances()];
-                    case 4:
-                        balancesBN = (_f.sent()).map(utils_1.BN);
-                        balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
-                        _d = utils_1.BN;
-                        return [4 /*yield*/, this.depositExpected(amounts)];
-                    case 5:
-                        expectedBN = _d.apply(void 0, [_f.sent()]);
-                        _e = utils_1.BN;
-                        return [4 /*yield*/, this.depositExpected(balancedAmounts)];
-                    case 6:
-                        balancedExpectedBN = _e.apply(void 0, [_f.sent()]);
-                        return [2 /*return*/, String(expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100))];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositIsApproved = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, (0, utils_1.hasAllowance)(this.underlyingCoinAddresses, amounts, curve_1.curve.signerAddress, this.zap || this.address)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositApproveEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)(this.underlyingCoinAddresses, amounts, this.zap || this.address)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositApprove = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, (0, utils_1.ensureAllowance)(this.underlyingCoinAddresses, amounts, this.zap || this.address)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+    }
+    async depositBonus(amounts) {
+        const amountsBN = amounts.map(BN);
+        const prices = (this.isCrypto || this.id === 'wsteth') ? await this._underlyingPrices() : this.underlyingCoins.map(() => 1);
+        const pricesBN = prices.map(BN);
+        const balancesBN = (await this.stats.underlyingBalances()).map(BN);
+        const balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
+        const expectedBN = BN(await this.depositExpected(amounts));
+        const balancedExpectedBN = BN(await this.depositExpected(balancedAmounts));
+        return String(expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100));
+    }
+    async depositIsApproved(amounts) {
+        return await hasAllowance(this.underlyingCoinAddresses, amounts, curve.signerAddress, this.zap || this.address);
+    }
+    async depositApproveEstimateGas(amounts) {
+        return await ensureAllowanceEstimateGas(this.underlyingCoinAddresses, amounts, this.zap || this.address);
+    }
+    async depositApprove(amounts) {
+        return await ensureAllowance(this.underlyingCoinAddresses, amounts, this.zap || this.address);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.depositEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("depositEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async depositEstimateGas(amounts) {
+        throw Error(`depositEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.deposit = function (amounts, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("deposit method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async deposit(amounts, slippage = 0.5) {
+        throw Error(`deposit method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- DEPOSIT WRAPPED ----------------
-    PoolTemplate.prototype.depositWrappedBalancedAmounts = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("depositWrappedBalancedAmounts method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
-    PoolTemplate.prototype.depositWrappedExpected = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isFake) {
-                            throw Error("depositWrappedExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        }
-                        return [4 /*yield*/, this.calcLpTokenAmountWrapped(amounts)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositWrappedBonus = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var amountsBN, pricesBN, balancesBN, balancedAmounts, expectedBN, _c, balancedExpectedBN, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        amountsBN = amounts.map(utils_1.BN);
-                        return [4 /*yield*/, this._wrappedPrices()];
-                    case 1:
-                        pricesBN = (_e.sent()).map(utils_1.BN);
-                        return [4 /*yield*/, this.stats.wrappedBalances()];
-                    case 2:
-                        balancesBN = (_e.sent()).map(utils_1.BN);
-                        balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
-                        _c = utils_1.BN;
-                        return [4 /*yield*/, this.depositWrappedExpected(amounts)];
-                    case 3:
-                        expectedBN = _c.apply(void 0, [_e.sent()]);
-                        _d = utils_1.BN;
-                        return [4 /*yield*/, this.depositWrappedExpected(balancedAmounts)];
-                    case 4:
-                        balancedExpectedBN = _d.apply(void 0, [_e.sent()]);
-                        return [2 /*return*/, String(expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100))];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositWrappedIsApproved = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isFake) {
-                            throw Error("depositWrappedIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)(this.wrappedCoinAddresses, amounts, curve_1.curve.signerAddress, this.address)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositWrappedApproveEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isFake) {
-                            throw Error("depositWrappedApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)(this.wrappedCoinAddresses, amounts, this.address)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositWrappedApprove = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isFake) {
-                            throw Error("depositWrappedApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.ensureAllowance)(this.wrappedCoinAddresses, amounts, this.address)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+    async depositWrappedBalancedAmounts() {
+        throw Error(`depositWrappedBalancedAmounts method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
+    async depositWrappedExpected(amounts) {
+        if (this.isFake) {
+            throw Error(`depositWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        }
+        return await this.calcLpTokenAmountWrapped(amounts);
+    }
+    async depositWrappedBonus(amounts) {
+        const amountsBN = amounts.map(BN);
+        const pricesBN = (await this._wrappedPrices()).map(BN);
+        const balancesBN = (await this.stats.wrappedBalances()).map(BN);
+        const balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
+        const expectedBN = BN(await this.depositWrappedExpected(amounts));
+        const balancedExpectedBN = BN(await this.depositWrappedExpected(balancedAmounts));
+        return String(expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100));
+    }
+    async depositWrappedIsApproved(amounts) {
+        if (this.isFake) {
+            throw Error(`depositWrappedIsApproved method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        }
+        return await hasAllowance(this.wrappedCoinAddresses, amounts, curve.signerAddress, this.address);
+    }
+    async depositWrappedApproveEstimateGas(amounts) {
+        if (this.isFake) {
+            throw Error(`depositWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        }
+        return await ensureAllowanceEstimateGas(this.wrappedCoinAddresses, amounts, this.address);
+    }
+    async depositWrappedApprove(amounts) {
+        if (this.isFake) {
+            throw Error(`depositWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        }
+        return await ensureAllowance(this.wrappedCoinAddresses, amounts, this.address);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.depositWrappedEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("depositWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async depositWrappedEstimateGas(amounts) {
+        throw Error(`depositWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.depositWrapped = function (amounts, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("depositWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async depositWrapped(amounts, slippage = 0.5) {
+        throw Error(`depositWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- STAKING ----------------
-    PoolTemplate.prototype.stakeIsApproved = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("stakeIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.gauge)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.stakeApproveEstimateGas = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("stakeApproveEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [lpTokenAmount], this.gauge)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.stakeApprove = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("stakeApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [lpTokenAmount], this.gauge)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.stakeEstimateGas = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _lpTokenAmount;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("stakeEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        _lpTokenAmount = (0, utils_1.parseUnits)(lpTokenAmount);
-                        return [4 /*yield*/, curve_1.curve.contracts[this.gauge].contract.estimateGas.deposit(_lpTokenAmount, curve_1.curve.constantOptions)];
-                    case 1: return [2 /*return*/, (_c.sent()).toNumber()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.stake = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _lpTokenAmount, gasLimit;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("stake method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        _lpTokenAmount = (0, utils_1.parseUnits)(lpTokenAmount);
-                        return [4 /*yield*/, (0, utils_1._ensureAllowance)([this.lpToken], [_lpTokenAmount], this.gauge)];
-                    case 1:
-                        _c.sent();
-                        return [4 /*yield*/, curve_1.curve.updateFeeData()];
-                    case 2:
-                        _c.sent();
-                        return [4 /*yield*/, curve_1.curve.contracts[this.gauge].contract.estimateGas.deposit(_lpTokenAmount, curve_1.curve.constantOptions)];
-                    case 3:
-                        gasLimit = (_c.sent()).mul(150).div(100);
-                        return [4 /*yield*/, curve_1.curve.contracts[this.gauge].contract.deposit(_lpTokenAmount, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                    case 4: return [2 /*return*/, (_c.sent()).hash];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.unstakeEstimateGas = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _lpTokenAmount;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("unstakeEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        _lpTokenAmount = (0, utils_1.parseUnits)(lpTokenAmount);
-                        return [4 /*yield*/, curve_1.curve.contracts[this.gauge].contract.estimateGas.withdraw(_lpTokenAmount, curve_1.curve.constantOptions)];
-                    case 1: return [2 /*return*/, (_c.sent()).toNumber()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.unstake = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _lpTokenAmount, gasLimit;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("unstake method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        _lpTokenAmount = (0, utils_1.parseUnits)(lpTokenAmount);
-                        return [4 /*yield*/, curve_1.curve.updateFeeData()];
-                    case 1:
-                        _c.sent();
-                        return [4 /*yield*/, curve_1.curve.contracts[this.gauge].contract.estimateGas.withdraw(_lpTokenAmount, curve_1.curve.constantOptions)];
-                    case 2:
-                        gasLimit = (_c.sent()).mul(200).div(100);
-                        return [4 /*yield*/, curve_1.curve.contracts[this.gauge].contract.withdraw(_lpTokenAmount, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                    case 3: return [2 /*return*/, (_c.sent()).hash];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.claimableCrv = function (address) {
-        if (address === void 0) { address = ""; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _c, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        if (this.rewardsOnly())
-                            throw Error("".concat(this.name, " has Rewards-Only Gauge. Use claimableRewards instead"));
-                        address = address || curve_1.curve.signerAddress;
-                        if (!address)
-                            throw Error("Need to connect wallet or pass address into args");
-                        _d = (_c = ethers_1.ethers.utils).formatUnits;
-                        return [4 /*yield*/, curve_1.curve.contracts[this.gauge].contract.claimable_tokens(address, curve_1.curve.constantOptions)];
-                    case 1: return [2 /*return*/, _d.apply(_c, [_e.sent()])];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.claimCrvEstimateGas = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.rewardsOnly())
-                            throw Error("".concat(this.name, " has Rewards-Only Gauge. Use claimRewards instead"));
-                        return [4 /*yield*/, curve_1.curve.contracts[curve_1.curve.constants.ALIASES.minter].contract.estimateGas.mint(this.gauge, curve_1.curve.constantOptions)];
-                    case 1: return [2 /*return*/, (_c.sent()).toNumber()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.claimCrv = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var contract, gasLimit;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.rewardsOnly())
-                            throw Error("".concat(this.name, " has Rewards-Only Gauge. Use claimRewards instead"));
-                        contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.minter].contract;
-                        return [4 /*yield*/, contract.estimateGas.mint(this.gauge, curve_1.curve.constantOptions)];
-                    case 1:
-                        gasLimit = (_c.sent()).mul(130).div(100);
-                        return [4 /*yield*/, contract.mint(this.gauge, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                    case 2: return [2 /*return*/, (_c.sent()).hash];
-                }
-            });
-        });
-    };
+    async stakeIsApproved(lpTokenAmount) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`stakeIsApproved method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        return await hasAllowance([this.lpToken], [lpTokenAmount], curve.signerAddress, this.gauge);
+    }
+    async stakeApproveEstimateGas(lpTokenAmount) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`stakeApproveEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        return await ensureAllowanceEstimateGas([this.lpToken], [lpTokenAmount], this.gauge);
+    }
+    async stakeApprove(lpTokenAmount) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`stakeApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        return await ensureAllowance([this.lpToken], [lpTokenAmount], this.gauge);
+    }
+    async stakeEstimateGas(lpTokenAmount) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`stakeEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const _lpTokenAmount = parseUnits(lpTokenAmount);
+        return Number(await curve.contracts[this.gauge].contract.deposit.estimateGas(_lpTokenAmount, curve.constantOptions));
+    }
+    async stake(lpTokenAmount) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`stake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const _lpTokenAmount = parseUnits(lpTokenAmount);
+        await _ensureAllowance([this.lpToken], [_lpTokenAmount], this.gauge);
+        await curve.updateFeeData();
+        const gasLimit = mulBy1_3(await curve.contracts[this.gauge].contract.deposit.estimateGas(_lpTokenAmount, curve.constantOptions));
+        return (await curve.contracts[this.gauge].contract.deposit(_lpTokenAmount, { ...curve.options, gasLimit })).hash;
+    }
+    async unstakeEstimateGas(lpTokenAmount) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`unstakeEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const _lpTokenAmount = parseUnits(lpTokenAmount);
+        return Number(await curve.contracts[this.gauge].contract.withdraw.estimateGas(_lpTokenAmount, curve.constantOptions));
+    }
+    async unstake(lpTokenAmount) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`unstake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const _lpTokenAmount = parseUnits(lpTokenAmount);
+        await curve.updateFeeData();
+        const gasLimit = (await curve.contracts[this.gauge].contract.withdraw.estimateGas(_lpTokenAmount, curve.constantOptions)) * 200n / 100n;
+        return (await curve.contracts[this.gauge].contract.withdraw(_lpTokenAmount, { ...curve.options, gasLimit })).hash;
+    }
+    async claimableCrv(address = "") {
+        if (this.rewardsOnly())
+            throw Error(`${this.name} has Rewards-Only Gauge. Use claimableRewards instead`);
+        address = address || curve.signerAddress;
+        if (!address)
+            throw Error("Need to connect wallet or pass address into args");
+        return curve.formatUnits(await curve.contracts[this.gauge].contract.claimable_tokens(address, curve.constantOptions));
+    }
+    async claimCrvEstimateGas() {
+        if (this.rewardsOnly())
+            throw Error(`${this.name} has Rewards-Only Gauge. Use claimRewards instead`);
+        return Number(await curve.contracts[curve.constants.ALIASES.minter].contract.mint.estimateGas(this.gauge, curve.constantOptions));
+    }
+    async claimCrv() {
+        if (this.rewardsOnly())
+            throw Error(`${this.name} has Rewards-Only Gauge. Use claimRewards instead`);
+        const contract = curve.contracts[curve.constants.ALIASES.minter].contract;
+        const gasLimit = mulBy1_3(await contract.mint.estimateGas(this.gauge, curve.constantOptions));
+        return (await contract.mint(this.gauge, { ...curve.options, gasLimit })).hash;
+    }
     // TODO 1. Fix aave and saave error
-    PoolTemplate.prototype.claimableRewards = function (address) {
-        if (address === void 0) { address = ""; }
-        return __awaiter(this, void 0, void 0, function () {
-            var gaugeContract, rewardTokens, rewards, _i, rewardTokens_5, rewardToken, _amount, rewardToken, _totalAmount, _claimedAmount;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("claimableRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        address = address || curve_1.curve.signerAddress;
-                        if (!address)
-                            throw Error("Need to connect wallet or pass address into args");
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        return [4 /*yield*/, this.rewardTokens()];
-                    case 1:
-                        rewardTokens = _c.sent();
-                        rewards = [];
-                        if (!('claimable_reward(address,address)' in gaugeContract)) return [3 /*break*/, 6];
-                        _i = 0, rewardTokens_5 = rewardTokens;
-                        _c.label = 2;
-                    case 2:
-                        if (!(_i < rewardTokens_5.length)) return [3 /*break*/, 5];
-                        rewardToken = rewardTokens_5[_i];
-                        return [4 /*yield*/, gaugeContract.claimable_reward(address, rewardToken.token, curve_1.curve.constantOptions)];
-                    case 3:
-                        _amount = _c.sent();
-                        rewards.push({
-                            token: rewardToken.token,
-                            symbol: rewardToken.symbol,
-                            amount: ethers_1.ethers.utils.formatUnits(_amount, rewardToken.decimals),
-                        });
-                        _c.label = 4;
-                    case 4:
-                        _i++;
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 9];
-                    case 6:
-                        if (!('claimable_reward(address)' in gaugeContract && rewardTokens.length > 0)) return [3 /*break*/, 9];
-                        rewardToken = rewardTokens[0];
-                        return [4 /*yield*/, gaugeContract.claimable_reward(address, curve_1.curve.constantOptions)];
-                    case 7:
-                        _totalAmount = _c.sent();
-                        return [4 /*yield*/, gaugeContract.claimed_rewards_for(address, curve_1.curve.constantOptions)];
-                    case 8:
-                        _claimedAmount = _c.sent();
-                        rewards.push({
-                            token: rewardToken.token,
-                            symbol: rewardToken.symbol,
-                            amount: ethers_1.ethers.utils.formatUnits(_totalAmount.sub(_claimedAmount), rewardToken.decimals),
-                        });
-                        _c.label = 9;
-                    case 9: return [2 /*return*/, rewards];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.claimRewardsEstimateGas = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var gaugeContract;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("claimRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        if (!("claim_rewards()" in gaugeContract))
-                            throw Error("".concat(this.name, " pool doesn't have such method"));
-                        return [4 /*yield*/, gaugeContract.estimateGas.claim_rewards(curve_1.curve.constantOptions)];
-                    case 1: return [2 /*return*/, (_c.sent()).toNumber()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.claimRewards = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var gaugeContract, gasLimit;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("claimRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        if (!("claim_rewards()" in gaugeContract))
-                            throw Error("".concat(this.name, " pool doesn't have such method"));
-                        return [4 /*yield*/, gaugeContract.estimateGas.claim_rewards(curve_1.curve.constantOptions)];
-                    case 1:
-                        gasLimit = (_c.sent()).mul(130).div(100);
-                        return [4 /*yield*/, gaugeContract.claim_rewards(__assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                    case 2: return [2 /*return*/, (_c.sent()).hash];
-                }
+    async claimableRewards(address = "") {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`claimableRewards method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        address = address || curve.signerAddress;
+        if (!address)
+            throw Error("Need to connect wallet or pass address into args");
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        const rewardTokens = await this.rewardTokens();
+        const rewards = [];
+        if ('claimable_reward(address,address)' in gaugeContract) {
+            for (const rewardToken of rewardTokens) {
+                const _amount = await gaugeContract.claimable_reward(address, rewardToken.token, curve.constantOptions);
+                rewards.push({
+                    token: rewardToken.token,
+                    symbol: rewardToken.symbol,
+                    amount: curve.formatUnits(_amount, rewardToken.decimals),
+                });
+            }
+        }
+        else if ('claimable_reward(address)' in gaugeContract && rewardTokens.length > 0) { // Synthetix Gauge
+            const rewardToken = rewardTokens[0];
+            const _totalAmount = await gaugeContract.claimable_reward(address, curve.constantOptions);
+            const _claimedAmount = await gaugeContract.claimed_rewards_for(address, curve.constantOptions);
+            rewards.push({
+                token: rewardToken.token,
+                symbol: rewardToken.symbol,
+                amount: curve.formatUnits(_totalAmount.sub(_claimedAmount), rewardToken.decimals),
             });
-        });
-    };
-    // ---------------- DEPOSIT & STAKE ----------------
-    PoolTemplate.prototype.depositAndStakeExpected = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, this.depositExpected(amounts)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeBonus = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, this.depositBonus(amounts)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeIsApproved = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var coinsAllowance, gaugeContract, gaugeAllowance;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)(this.underlyingCoinAddresses, amounts, curve_1.curve.signerAddress, curve_1.curve.constants.ALIASES.deposit_and_stake)];
-                    case 1:
-                        coinsAllowance = _c.sent();
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        if (!Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) return [3 /*break*/, 3];
-                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, curve_1.curve.signerAddress, curve_1.curve.constantOptions)];
-                    case 2:
-                        gaugeAllowance = _c.sent();
-                        return [2 /*return*/, coinsAllowance && gaugeAllowance];
-                    case 3: return [2 /*return*/, coinsAllowance];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeApproveEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var approveCoinsGas, gaugeContract, gaugeAllowance, approveGaugeGas;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)(this.underlyingCoinAddresses, amounts, curve_1.curve.constants.ALIASES.deposit_and_stake)];
-                    case 1:
-                        approveCoinsGas = _c.sent();
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        if (!Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) return [3 /*break*/, 4];
-                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, curve_1.curve.signerAddress, curve_1.curve.constantOptions)];
-                    case 2:
-                        gaugeAllowance = _c.sent();
-                        if (!!gaugeAllowance) return [3 /*break*/, 4];
-                        return [4 /*yield*/, gaugeContract.estimateGas.set_approve_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, true, curve_1.curve.constantOptions)];
-                    case 3:
-                        approveGaugeGas = (_c.sent()).toNumber();
-                        return [2 /*return*/, approveCoinsGas + approveGaugeGas];
-                    case 4: return [2 /*return*/, approveCoinsGas];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeApprove = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var approveCoinsTx, gaugeContract, gaugeAllowance, gasLimit, approveGaugeTx;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, (0, utils_1.ensureAllowance)(this.underlyingCoinAddresses, amounts, curve_1.curve.constants.ALIASES.deposit_and_stake)];
-                    case 1:
-                        approveCoinsTx = _c.sent();
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        if (!Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) return [3 /*break*/, 5];
-                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, curve_1.curve.signerAddress, curve_1.curve.constantOptions)];
-                    case 2:
-                        gaugeAllowance = _c.sent();
-                        if (!!gaugeAllowance) return [3 /*break*/, 5];
-                        return [4 /*yield*/, gaugeContract.estimateGas.set_approve_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, true, curve_1.curve.constantOptions)];
-                    case 3:
-                        gasLimit = (_c.sent()).mul(130).div(100);
-                        return [4 /*yield*/, gaugeContract.set_approve_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, true, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                    case 4:
-                        approveGaugeTx = (_c.sent()).hash;
-                        return [2 /*return*/, __spreadArray(__spreadArray([], approveCoinsTx, true), [approveGaugeTx], false)];
-                    case 5: return [2 /*return*/, approveCoinsTx];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStake method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, this._depositAndStake(amounts, 1, true, true)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStake = function (amounts, slippage) {
-        if (slippage === void 0) { slippage = 0.1; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStake method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        return [4 /*yield*/, this._depositAndStake(amounts, slippage, true, false)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+        }
+        return rewards;
+    }
+    async claimRewardsEstimateGas() {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`claimRewards method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        if (!("claim_rewards()" in gaugeContract))
+            throw Error(`${this.name} pool doesn't have such method`);
+        return Number(await gaugeContract.claim_rewards.estimateGas(curve.constantOptions));
+    }
+    async claimRewards() {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`claimRewards method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        if (!("claim_rewards()" in gaugeContract))
+            throw Error(`${this.name} pool doesn't have such method`);
+        const gasLimit = mulBy1_3(await gaugeContract.claim_rewards.estimateGas(curve.constantOptions));
+        return (await gaugeContract.claim_rewards({ ...curve.options, gasLimit })).hash;
+    }
+    // ---------------- DEPOSIT & STAKE ----------------
+    async depositAndStakeExpected(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeExpected method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        return await this.depositExpected(amounts);
+    }
+    async depositAndStakeBonus(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeBonus method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        return await this.depositBonus(amounts);
+    }
+    async depositAndStakeIsApproved(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeIsApproved method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const coinsAllowance = await hasAllowance(this.underlyingCoinAddresses, amounts, curve.signerAddress, curve.constants.ALIASES.deposit_and_stake);
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        if (Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) {
+            const gaugeAllowance = await gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+            return coinsAllowance && gaugeAllowance;
+        }
+        return coinsAllowance;
+    }
+    async depositAndStakeApproveEstimateGas(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const approveCoinsGas = await ensureAllowanceEstimateGas(this.underlyingCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake);
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        if (Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) {
+            const gaugeAllowance = await gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+            if (!gaugeAllowance) {
+                const approveGaugeGas = Number(await gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions));
+                return approveCoinsGas + approveGaugeGas;
+            }
+        }
+        return approveCoinsGas;
+    }
+    async depositAndStakeApprove(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        const approveCoinsTx = await ensureAllowance(this.underlyingCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake);
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        if (Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) {
+            const gaugeAllowance = await gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+            if (!gaugeAllowance) {
+                const gasLimit = mulBy1_3(await gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions));
+                const approveGaugeTx = (await gaugeContract.set_approve_deposit(curve.constants.ALIASES.deposit_and_stake, true, { ...curve.options, gasLimit })).hash;
+                return [...approveCoinsTx, approveGaugeTx];
+            }
+        }
+        return approveCoinsTx;
+    }
+    async depositAndStakeEstimateGas(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        return await this._depositAndStake(amounts, 1, true, true);
+    }
+    async depositAndStake(amounts, slippage = 0.1) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        return await this._depositAndStake(amounts, slippage, true, false);
+    }
     // ---------------- DEPOSIT & STAKE WRAPPED ----------------
-    PoolTemplate.prototype.depositAndStakeWrappedExpected = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeWrappedExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        if (this.isPlain || this.isFake)
-                            throw Error("depositAndStakeWrappedExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, this.depositWrappedExpected(amounts)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeWrappedBonus = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeWrappedBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        if (this.isPlain || this.isFake)
-                            throw Error("depositAndStakeWrappedBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, this.depositWrappedBonus(amounts)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeWrappedIsApproved = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var coinsAllowance, gaugeContract, gaugeAllowance;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeWrappedIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        if (this.isPlain || this.isFake)
-                            throw Error("depositAndStakeWrappedIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)(this.wrappedCoinAddresses, amounts, curve_1.curve.signerAddress, curve_1.curve.constants.ALIASES.deposit_and_stake)];
-                    case 1:
-                        coinsAllowance = _c.sent();
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        if (!Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) return [3 /*break*/, 3];
-                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, curve_1.curve.signerAddress, curve_1.curve.constantOptions)];
-                    case 2:
-                        gaugeAllowance = _c.sent();
-                        return [2 /*return*/, coinsAllowance && gaugeAllowance];
-                    case 3: return [2 /*return*/, coinsAllowance];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeWrappedApproveEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var approveCoinsGas, gaugeContract, gaugeAllowance, approveGaugeGas;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeWrappedApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        if (this.isPlain || this.isFake)
-                            throw Error("depositAndStakeWrappedApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)(this.wrappedCoinAddresses, amounts, curve_1.curve.constants.ALIASES.deposit_and_stake)];
-                    case 1:
-                        approveCoinsGas = _c.sent();
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        if (!Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) return [3 /*break*/, 4];
-                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, curve_1.curve.signerAddress, curve_1.curve.constantOptions)];
-                    case 2:
-                        gaugeAllowance = _c.sent();
-                        if (!!gaugeAllowance) return [3 /*break*/, 4];
-                        return [4 /*yield*/, gaugeContract.estimateGas.set_approve_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, true, curve_1.curve.constantOptions)];
-                    case 3:
-                        approveGaugeGas = (_c.sent()).toNumber();
-                        return [2 /*return*/, approveCoinsGas + approveGaugeGas];
-                    case 4: return [2 /*return*/, approveCoinsGas];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeWrappedApprove = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var approveCoinsTx, gaugeContract, gaugeAllowance, gasLimit, approveGaugeTx;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeWrappedApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        if (this.isPlain || this.isFake)
-                            throw Error("depositAndStakeWrappedApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, (0, utils_1.ensureAllowance)(this.wrappedCoinAddresses, amounts, curve_1.curve.constants.ALIASES.deposit_and_stake)];
-                    case 1:
-                        approveCoinsTx = _c.sent();
-                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        if (!Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) return [3 /*break*/, 5];
-                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, curve_1.curve.signerAddress, curve_1.curve.constantOptions)];
-                    case 2:
-                        gaugeAllowance = _c.sent();
-                        if (!!gaugeAllowance) return [3 /*break*/, 5];
-                        return [4 /*yield*/, gaugeContract.estimateGas.set_approve_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, true, curve_1.curve.constantOptions)];
-                    case 3:
-                        gasLimit = (_c.sent()).mul(130).div(100);
-                        return [4 /*yield*/, gaugeContract.set_approve_deposit(curve_1.curve.constants.ALIASES.deposit_and_stake, true, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                    case 4:
-                        approveGaugeTx = (_c.sent()).hash;
-                        return [2 /*return*/, __spreadArray(__spreadArray([], approveCoinsTx, true), [approveGaugeTx], false)];
-                    case 5: return [2 /*return*/, approveCoinsTx];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeWrappedEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        if (this.isPlain || this.isFake)
-                            throw Error("depositAndStakeWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, this._depositAndStake(amounts, 1, false, true)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.depositAndStakeWrapped = function (amounts, slippage) {
-        if (slippage === void 0) { slippage = 0.1; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero) {
-                            throw Error("depositAndStakeWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
-                        }
-                        if (this.isPlain || this.isFake)
-                            throw Error("depositAndStakeWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, this._depositAndStake(amounts, slippage, false, false)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype._depositAndStake = function (amounts, slippage, isUnderlying, estimateGas) {
-        return __awaiter(this, void 0, void 0, function () {
-            var coinAddresses, coins, decimals, depositAddress, balances, _c, _d, _e, _f, _g, i, allowance, _h, _amounts, contract, useUnderlying, _expectedLpTokenAmount, _j, _k, _l, _m, _o, minAmountBN, _minMintAmount, ethIndex, value, maxCoins, i, _gas, gasLimit;
-            return __generator(this, function (_q) {
-                switch (_q.label) {
-                    case 0:
-                        coinAddresses = isUnderlying ? __spreadArray([], this.underlyingCoinAddresses, true) : __spreadArray([], this.wrappedCoinAddresses, true);
-                        coins = isUnderlying ? this.underlyingCoins : this.wrappedCoinAddresses;
-                        decimals = isUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
-                        depositAddress = isUnderlying ? this.zap || this.address : this.address;
-                        if (amounts.length !== coinAddresses.length) {
-                            throw Error("".concat(this.name, " pool has ").concat(coinAddresses.length, " coins (amounts provided for ").concat(amounts.length, ")"));
-                        }
-                        if (!isUnderlying) return [3 /*break*/, 2];
-                        _e = (_d = Object).values;
-                        return [4 /*yield*/, this.walletUnderlyingCoinBalances()];
-                    case 1:
-                        _c = _e.apply(_d, [_q.sent()]);
-                        return [3 /*break*/, 4];
-                    case 2:
-                        _g = (_f = Object).values;
-                        return [4 /*yield*/, this.walletWrappedCoinBalances()];
-                    case 3:
-                        _c = _g.apply(_f, [_q.sent()]);
-                        _q.label = 4;
-                    case 4:
-                        balances = _c;
-                        for (i = 0; i < balances.length; i++) {
-                            if (Number(balances[i]) < Number(amounts[i])) {
-                                throw Error("Not enough ".concat(coins[i], ". Actual: ").concat(balances[i], ", required: ").concat(amounts[i]));
-                            }
-                        }
-                        if (!isUnderlying) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.depositAndStakeIsApproved(amounts)];
-                    case 5:
-                        _h = _q.sent();
-                        return [3 /*break*/, 8];
-                    case 6: return [4 /*yield*/, this.depositAndStakeWrappedIsApproved(amounts)];
-                    case 7:
-                        _h = _q.sent();
-                        _q.label = 8;
-                    case 8:
-                        allowance = _h;
-                        if (estimateGas && !allowance) {
-                            throw Error("Token allowance is needed to estimate gas");
-                        }
-                        if (!!estimateGas) return [3 /*break*/, 12];
-                        if (!isUnderlying) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.depositAndStakeApprove(amounts)];
-                    case 9:
-                        _q.sent();
-                        return [3 /*break*/, 12];
-                    case 10: return [4 /*yield*/, this.depositAndStakeWrappedApprove(amounts)];
-                    case 11:
-                        _q.sent();
-                        _q.label = 12;
-                    case 12:
-                        _amounts = amounts.map(function (amount, i) { return (0, utils_1.parseUnits)(amount, decimals[i]); });
-                        contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.deposit_and_stake].contract;
-                        useUnderlying = isUnderlying && (this.isLending || (this.isCrypto && !this.isPlain)) && (!this.zap || this.id == 'avaxcrypto');
-                        if (!isUnderlying) return [3 /*break*/, 14];
-                        _l = (_k = ethers_1.ethers.utils).parseUnits;
-                        return [4 /*yield*/, this.depositAndStakeExpected(amounts)];
-                    case 13:
-                        _j = _l.apply(_k, [_q.sent()]);
-                        return [3 /*break*/, 16];
-                    case 14:
-                        _o = (_m = ethers_1.ethers.utils).parseUnits;
-                        return [4 /*yield*/, this.depositAndStakeWrappedExpected(amounts)];
-                    case 15:
-                        _j = _o.apply(_m, [_q.sent()]);
-                        _q.label = 16;
-                    case 16:
-                        _expectedLpTokenAmount = _j;
-                        minAmountBN = (0, utils_1.toBN)(_expectedLpTokenAmount).times(100 - slippage).div(100);
-                        _minMintAmount = (0, utils_1.fromBN)(minAmountBN);
-                        ethIndex = (0, utils_1.getEthIndex)(coinAddresses);
-                        value = _amounts[ethIndex] || ethers_1.ethers.BigNumber.from(0);
-                        maxCoins = curve_1.curve.chainId === 137 ? 6 : 5;
-                        for (i = 0; i < maxCoins; i++) {
-                            coinAddresses[i] = coinAddresses[i] || ethers_1.ethers.constants.AddressZero;
-                            _amounts[i] = _amounts[i] || ethers_1.ethers.BigNumber.from(0);
-                        }
-                        return [4 /*yield*/, contract.estimateGas.deposit_and_stake(depositAddress, this.lpToken, this.gauge, coins.length, coinAddresses, _amounts, _minMintAmount, useUnderlying, this.isMetaFactory && isUnderlying ? this.address : ethers_1.ethers.constants.AddressZero, __assign(__assign({}, curve_1.curve.constantOptions), { value: value }))];
-                    case 17:
-                        _gas = (_q.sent());
-                        if (estimateGas)
-                            return [2 /*return*/, _gas.toNumber()];
-                        return [4 /*yield*/, curve_1.curve.updateFeeData()];
-                    case 18:
-                        _q.sent();
-                        gasLimit = _gas.mul(200).div(100);
-                        return [4 /*yield*/, contract.deposit_and_stake(depositAddress, this.lpToken, this.gauge, coins.length, coinAddresses, _amounts, _minMintAmount, useUnderlying, this.isMetaFactory && isUnderlying ? this.address : ethers_1.ethers.constants.AddressZero, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit, value: value }))];
-                    case 19: return [2 /*return*/, (_q.sent()).hash];
-                }
-            });
-        });
-    };
+    async depositAndStakeWrappedExpected(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        if (this.isPlain || this.isFake)
+            throw Error(`depositAndStakeWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        return await this.depositWrappedExpected(amounts);
+    }
+    async depositAndStakeWrappedBonus(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeWrappedBonus method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        if (this.isPlain || this.isFake)
+            throw Error(`depositAndStakeWrappedBonus method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        return await this.depositWrappedBonus(amounts);
+    }
+    async depositAndStakeWrappedIsApproved(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeWrappedIsApproved method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        if (this.isPlain || this.isFake)
+            throw Error(`depositAndStakeWrappedIsApproved method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        const coinsAllowance = await hasAllowance(this.wrappedCoinAddresses, amounts, curve.signerAddress, curve.constants.ALIASES.deposit_and_stake);
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        if (Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) {
+            const gaugeAllowance = await gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+            return coinsAllowance && gaugeAllowance;
+        }
+        return coinsAllowance;
+    }
+    async depositAndStakeWrappedApproveEstimateGas(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        if (this.isPlain || this.isFake)
+            throw Error(`depositAndStakeWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        const approveCoinsGas = await ensureAllowanceEstimateGas(this.wrappedCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake);
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        if (Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) {
+            const gaugeAllowance = await gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+            if (!gaugeAllowance) {
+                const approveGaugeGas = Number(await gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions));
+                return approveCoinsGas + approveGaugeGas;
+            }
+        }
+        return approveCoinsGas;
+    }
+    async depositAndStakeWrappedApprove(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        if (this.isPlain || this.isFake)
+            throw Error(`depositAndStakeWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        const approveCoinsTx = await ensureAllowance(this.wrappedCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake);
+        const gaugeContract = curve.contracts[this.gauge].contract;
+        if (Object.prototype.hasOwnProperty.call(gaugeContract, 'approved_to_deposit')) {
+            const gaugeAllowance = await gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+            if (!gaugeAllowance) {
+                const gasLimit = mulBy1_3(await gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions));
+                const approveGaugeTx = (await gaugeContract.set_approve_deposit(curve.constants.ALIASES.deposit_and_stake, true, { ...curve.options, gasLimit })).hash;
+                return [...approveCoinsTx, approveGaugeTx];
+            }
+        }
+        return approveCoinsTx;
+    }
+    async depositAndStakeWrappedEstimateGas(amounts) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeWrapped method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        if (this.isPlain || this.isFake)
+            throw Error(`depositAndStakeWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        return await this._depositAndStake(amounts, 1, false, true);
+    }
+    async depositAndStakeWrapped(amounts, slippage = 0.1) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            throw Error(`depositAndStakeWrapped method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
+        }
+        if (this.isPlain || this.isFake)
+            throw Error(`depositAndStakeWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        return await this._depositAndStake(amounts, slippage, false, false);
+    }
+    async _depositAndStake(amounts, slippage, isUnderlying, estimateGas) {
+        const coinAddresses = isUnderlying ? [...this.underlyingCoinAddresses] : [...this.wrappedCoinAddresses];
+        const coins = isUnderlying ? this.underlyingCoins : this.wrappedCoinAddresses;
+        const decimals = isUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
+        const depositAddress = isUnderlying ? this.zap || this.address : this.address;
+        if (amounts.length !== coinAddresses.length) {
+            throw Error(`${this.name} pool has ${coinAddresses.length} coins (amounts provided for ${amounts.length})`);
+        }
+        const balances = isUnderlying ? Object.values(await this.walletUnderlyingCoinBalances()) : Object.values(await this.walletWrappedCoinBalances());
+        for (let i = 0; i < balances.length; i++) {
+            if (Number(balances[i]) < Number(amounts[i])) {
+                throw Error(`Not enough ${coins[i]}. Actual: ${balances[i]}, required: ${amounts[i]}`);
+            }
+        }
+        const allowance = isUnderlying ? await this.depositAndStakeIsApproved(amounts) : await this.depositAndStakeWrappedIsApproved(amounts);
+        if (estimateGas && !allowance) {
+            throw Error("Token allowance is needed to estimate gas");
+        }
+        if (!estimateGas) {
+            if (isUnderlying) {
+                await this.depositAndStakeApprove(amounts);
+            }
+            else {
+                await this.depositAndStakeWrappedApprove(amounts);
+            }
+        }
+        const _amounts = amounts.map((amount, i) => parseUnits(amount, decimals[i]));
+        const contract = curve.contracts[curve.constants.ALIASES.deposit_and_stake].contract;
+        const useUnderlying = isUnderlying && (this.isLending || (this.isCrypto && !this.isPlain)) && (!this.zap || this.id == 'avaxcrypto');
+        const _expectedLpTokenAmount = isUnderlying ?
+            curve.parseUnits(await this.depositAndStakeExpected(amounts)) :
+            curve.parseUnits(await this.depositAndStakeWrappedExpected(amounts));
+        const minAmountBN = toBN(_expectedLpTokenAmount).times(100 - slippage).div(100);
+        const _minMintAmount = fromBN(minAmountBN);
+        const ethIndex = getEthIndex(coinAddresses);
+        const value = _amounts[ethIndex] || 0n;
+        const maxCoins = curve.chainId === 137 ? 6 : 5;
+        for (let i = 0; i < maxCoins; i++) {
+            coinAddresses[i] = coinAddresses[i] || curve.constants.ZERO_ADDRESS;
+            _amounts[i] = _amounts[i] || 0n;
+        }
+        const _gas = (await contract.deposit_and_stake.estimateGas(depositAddress, this.lpToken, this.gauge, coins.length, coinAddresses, _amounts, _minMintAmount, useUnderlying, this.isMetaFactory && isUnderlying ? this.address : curve.constants.ZERO_ADDRESS, { ...curve.constantOptions, value }));
+        if (estimateGas)
+            return Number(_gas);
+        await curve.updateFeeData();
+        const gasLimit = _gas * 200n / 100n;
+        return (await contract.deposit_and_stake(depositAddress, this.lpToken, this.gauge, coins.length, coinAddresses, _amounts, _minMintAmount, useUnderlying, this.isMetaFactory && isUnderlying ? this.address : curve.constants.ZERO_ADDRESS, { ...curve.options, gasLimit, value })).hash;
+    }
     // ---------------- WITHDRAW ----------------
     // OVERRIDE
-    PoolTemplate.prototype.withdrawExpected = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawIsApproved = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!this.zap)
-                            return [2 /*return*/, true];
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.zap)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawApproveEstimateGas = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!this.zap)
-                            return [2 /*return*/, 0];
-                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [lpTokenAmount], this.zap)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawApprove = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!this.zap)
-                            return [2 /*return*/, []];
-                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [lpTokenAmount], this.zap)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+    async withdrawExpected(lpTokenAmount) {
+        throw Error(`withdrawExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
+    async withdrawIsApproved(lpTokenAmount) {
+        if (!this.zap)
+            return true;
+        return await hasAllowance([this.lpToken], [lpTokenAmount], curve.signerAddress, this.zap);
+    }
+    async withdrawApproveEstimateGas(lpTokenAmount) {
+        if (!this.zap)
+            return 0;
+        return await ensureAllowanceEstimateGas([this.lpToken], [lpTokenAmount], this.zap);
+    }
+    async withdrawApprove(lpTokenAmount) {
+        if (!this.zap)
+            return [];
+        return await ensureAllowance([this.lpToken], [lpTokenAmount], this.zap);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawEstimateGas = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdraw method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawEstimateGas(lpTokenAmount) {
+        throw Error(`withdraw method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdraw = function (lpTokenAmount, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdraw method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdraw(lpTokenAmount, slippage = 0.5) {
+        throw Error(`withdraw method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- WITHDRAW WRAPPED ----------------
     // OVERRIDE
-    PoolTemplate.prototype.withdrawWrappedExpected = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawWrappedExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawWrappedExpected(lpTokenAmount) {
+        throw Error(`withdrawWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawWrappedEstimateGas = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawWrappedEstimateGas(lpTokenAmount) {
+        throw Error(`withdrawWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawWrapped = function (lpTokenAmount, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawWrapped(lpTokenAmount, slippage = 0.5) {
+        throw Error(`withdrawWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- WITHDRAW IMBALANCE ----------------
-    PoolTemplate.prototype.withdrawImbalanceExpected = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isCrypto)
-                            throw Error("withdrawImbalanceExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, this.calcLpTokenAmount(amounts, false)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawImbalanceBonus = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var prices, _c, value, lpTokenAmount, balancedAmounts, balancedValue;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._underlyingPrices()];
-                    case 1:
-                        _c = _d.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _c = this.underlyingCoins.map(function () { return 1; });
-                        _d.label = 3;
-                    case 3:
-                        prices = _c;
-                        value = amounts.map(utils_1.checkNumber).map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [4 /*yield*/, this.withdrawImbalanceExpected(amounts)];
-                    case 4:
-                        lpTokenAmount = _d.sent();
-                        return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
-                    case 5:
-                        balancedAmounts = _d.sent();
-                        balancedValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [2 /*return*/, String((value - balancedValue) / balancedValue * 100)];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawImbalanceIsApproved = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _amounts, _maxBurnAmount;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isCrypto)
-                            throw Error("withdrawImbalanceIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        if (!this.zap) return [3 /*break*/, 3];
-                        _amounts = amounts.map(function (amount, i) { return (0, utils_1.parseUnits)(amount, _this.underlyingDecimals[i]); });
-                        return [4 /*yield*/, this._calcLpTokenAmount(_amounts, false)];
-                    case 1:
-                        _maxBurnAmount = (_c.sent()).mul(101).div(100);
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], curve_1.curve.signerAddress, this.zap)];
-                    case 2: return [2 /*return*/, _c.sent()];
-                    case 3: return [2 /*return*/, true];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawImbalanceApproveEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _amounts, _maxBurnAmount;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isCrypto)
-                            throw Error("withdrawImbalanceApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        if (!this.zap) return [3 /*break*/, 3];
-                        _amounts = amounts.map(function (amount, i) { return (0, utils_1.parseUnits)(amount, _this.underlyingDecimals[i]); });
-                        return [4 /*yield*/, this._calcLpTokenAmount(_amounts, false)];
-                    case 1:
-                        _maxBurnAmount = (_c.sent()).mul(101).div(100);
-                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], this.zap)];
-                    case 2: return [2 /*return*/, _c.sent()];
-                    case 3: return [2 /*return*/, 0];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawImbalanceApprove = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _amounts, _maxBurnAmount;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isCrypto)
-                            throw Error("withdrawImbalanceApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        if (!this.zap) return [3 /*break*/, 3];
-                        _amounts = amounts.map(function (amount, i) { return (0, utils_1.parseUnits)(amount, _this.underlyingDecimals[i]); });
-                        return [4 /*yield*/, this._calcLpTokenAmount(_amounts, false)];
-                    case 1:
-                        _maxBurnAmount = (_c.sent()).mul(101).div(100);
-                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], this.zap)];
-                    case 2: return [2 /*return*/, _c.sent()];
-                    case 3: return [2 /*return*/, []];
-                }
-            });
-        });
-    };
+    async withdrawImbalanceExpected(amounts) {
+        if (this.isCrypto)
+            throw Error(`withdrawImbalanceExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        return await this.calcLpTokenAmount(amounts, false);
+    }
+    async withdrawImbalanceBonus(amounts) {
+        const prices = (this.isCrypto || this.id === 'wsteth') ? await this._underlyingPrices() : this.underlyingCoins.map(() => 1);
+        const value = amounts.map(checkNumber).map(Number).reduce((s, a, i) => s + (a * prices[i]), 0);
+        const lpTokenAmount = await this.withdrawImbalanceExpected(amounts);
+        const balancedAmounts = await this.withdrawExpected(lpTokenAmount);
+        const balancedValue = balancedAmounts.map(Number).reduce((s, a, i) => s + (a * prices[i]), 0);
+        return String((value - balancedValue) / balancedValue * 100);
+    }
+    async withdrawImbalanceIsApproved(amounts) {
+        if (this.isCrypto)
+            throw Error(`withdrawImbalanceIsApproved method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        if (this.zap) {
+            const _amounts = amounts.map((amount, i) => parseUnits(amount, this.underlyingDecimals[i]));
+            const _maxBurnAmount = (await this._calcLpTokenAmount(_amounts, false)) * 101n / 100n;
+            return await hasAllowance([this.lpToken], [curve.formatUnits(_maxBurnAmount, 18)], curve.signerAddress, this.zap);
+        }
+        return true;
+    }
+    async withdrawImbalanceApproveEstimateGas(amounts) {
+        if (this.isCrypto)
+            throw Error(`withdrawImbalanceApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        if (this.zap) {
+            const _amounts = amounts.map((amount, i) => parseUnits(amount, this.underlyingDecimals[i]));
+            const _maxBurnAmount = (await this._calcLpTokenAmount(_amounts, false)) * 101n / 100n;
+            return await ensureAllowanceEstimateGas([this.lpToken], [curve.formatUnits(_maxBurnAmount, 18)], this.zap);
+        }
+        return 0;
+    }
+    async withdrawImbalanceApprove(amounts) {
+        if (this.isCrypto)
+            throw Error(`withdrawImbalanceApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        if (this.zap) {
+            const _amounts = amounts.map((amount, i) => parseUnits(amount, this.underlyingDecimals[i]));
+            const _maxBurnAmount = (await this._calcLpTokenAmount(_amounts, false)) * 101n / 100n;
+            return await ensureAllowance([this.lpToken], [curve.formatUnits(_maxBurnAmount, 18)], this.zap);
+        }
+        return [];
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawImbalanceEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawImbalance method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawImbalanceEstimateGas(amounts) {
+        throw Error(`withdrawImbalance method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawImbalance = function (amounts, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawImbalance method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawImbalance(amounts, slippage = 0.5) {
+        throw Error(`withdrawImbalance method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- WITHDRAW IMBALANCE WRAPPED ----------------
-    PoolTemplate.prototype.withdrawImbalanceWrappedExpected = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isCrypto || this.isPlain || this.isFake)
-                            throw Error("withdrawImbalanceWrappedExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        return [4 /*yield*/, this.calcLpTokenAmountWrapped(amounts, false)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawImbalanceWrappedBonus = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var prices, value, lpTokenAmount, _c, balancedAmounts, balancedValue;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this._wrappedPrices()];
-                    case 1:
-                        prices = _d.sent();
-                        value = amounts.map(utils_1.checkNumber).map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        _c = Number;
-                        return [4 /*yield*/, this.withdrawImbalanceWrappedExpected(amounts)];
-                    case 2:
-                        lpTokenAmount = _c.apply(void 0, [_d.sent()]);
-                        return [4 /*yield*/, this.withdrawWrappedExpected(lpTokenAmount)];
-                    case 3:
-                        balancedAmounts = _d.sent();
-                        balancedValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [2 /*return*/, String((value - balancedValue) / balancedValue * 100)];
-                }
-            });
-        });
-    };
+    async withdrawImbalanceWrappedExpected(amounts) {
+        if (this.isCrypto || this.isPlain || this.isFake)
+            throw Error(`withdrawImbalanceWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        return await this.calcLpTokenAmountWrapped(amounts, false);
+    }
+    async withdrawImbalanceWrappedBonus(amounts) {
+        const prices = await this._wrappedPrices();
+        const value = amounts.map(checkNumber).map(Number).reduce((s, a, i) => s + (a * prices[i]), 0);
+        const lpTokenAmount = Number(await this.withdrawImbalanceWrappedExpected(amounts));
+        const balancedAmounts = await this.withdrawWrappedExpected(lpTokenAmount);
+        const balancedValue = balancedAmounts.map(Number).reduce((s, a, i) => s + (a * prices[i]), 0);
+        return String((value - balancedValue) / balancedValue * 100);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawImbalanceWrappedEstimateGas = function (amounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawImbalanceWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawImbalanceWrappedEstimateGas(amounts) {
+        throw Error(`withdrawImbalanceWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawImbalanceWrapped = function (amounts, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawImbalanceWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawImbalanceWrapped(amounts, slippage = 0.5) {
+        throw Error(`withdrawImbalanceWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- WITHDRAW ONE COIN ----------------
     // OVERRIDE
-    PoolTemplate.prototype._withdrawOneCoinExpected = function (_lpTokenAmount, i) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawOneCoinExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawOneCoinExpected = function (lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function () {
-            var i, _lpTokenAmount, _expected;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        i = this._getCoinIdx(coin);
-                        _lpTokenAmount = (0, utils_1.parseUnits)(lpTokenAmount);
-                        return [4 /*yield*/, this._withdrawOneCoinExpected(_lpTokenAmount, i)];
-                    case 1:
-                        _expected = _c.sent();
-                        return [2 /*return*/, ethers_1.ethers.utils.formatUnits(_expected, this.underlyingDecimals[i])];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawOneCoinBonus = function (lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function () {
-            var prices, _c, coinPrice, amount, _d, value, balancedAmounts, balancedValue;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._underlyingPrices()];
-                    case 1:
-                        _c = _e.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _c = this.underlyingCoins.map(function () { return 1; });
-                        _e.label = 3;
-                    case 3:
-                        prices = _c;
-                        coinPrice = prices[this._getCoinIdx(coin)];
-                        _d = Number;
-                        return [4 /*yield*/, this.withdrawOneCoinExpected(lpTokenAmount, coin)];
-                    case 4:
-                        amount = _d.apply(void 0, [_e.sent()]);
-                        value = amount * coinPrice;
-                        return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
-                    case 5:
-                        balancedAmounts = _e.sent();
-                        balancedValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [2 /*return*/, String((value - balancedValue) / balancedValue * 100)];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawOneCoinIsApproved = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!this.zap)
-                            return [2 /*return*/, true];
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.zap)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawOneCoinApproveEstimateGas = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!this.zap)
-                            return [2 /*return*/, 0];
-                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [lpTokenAmount], this.zap)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawOneCoinApprove = function (lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!this.zap)
-                            return [2 /*return*/, []];
-                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [lpTokenAmount], this.zap)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+    async _withdrawOneCoinExpected(_lpTokenAmount, i) {
+        throw Error(`withdrawOneCoinExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
+    async withdrawOneCoinExpected(lpTokenAmount, coin) {
+        const i = this._getCoinIdx(coin);
+        const _lpTokenAmount = parseUnits(lpTokenAmount);
+        const _expected = await this._withdrawOneCoinExpected(_lpTokenAmount, i);
+        return curve.formatUnits(_expected, this.underlyingDecimals[i]);
+    }
+    async withdrawOneCoinBonus(lpTokenAmount, coin) {
+        const prices = (this.isCrypto || this.id === 'wsteth') ? await this._underlyingPrices() : this.underlyingCoins.map(() => 1);
+        const coinPrice = prices[this._getCoinIdx(coin)];
+        const amount = Number(await this.withdrawOneCoinExpected(lpTokenAmount, coin));
+        const value = amount * coinPrice;
+        const balancedAmounts = await this.withdrawExpected(lpTokenAmount);
+        const balancedValue = balancedAmounts.map(Number).reduce((s, a, i) => s + (a * prices[i]), 0);
+        return String((value - balancedValue) / balancedValue * 100);
+    }
+    async withdrawOneCoinIsApproved(lpTokenAmount) {
+        if (!this.zap)
+            return true;
+        return await hasAllowance([this.lpToken], [lpTokenAmount], curve.signerAddress, this.zap);
+    }
+    async withdrawOneCoinApproveEstimateGas(lpTokenAmount) {
+        if (!this.zap)
+            return 0;
+        return await ensureAllowanceEstimateGas([this.lpToken], [lpTokenAmount], this.zap);
+    }
+    async withdrawOneCoinApprove(lpTokenAmount) {
+        if (!this.zap)
+            return [];
+        return await ensureAllowance([this.lpToken], [lpTokenAmount], this.zap);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawOneCoinEstimateGas = function (lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawOneCoin method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawOneCoinEstimateGas(lpTokenAmount, coin) {
+        throw Error(`withdrawOneCoin method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawOneCoin = function (lpTokenAmount, coin, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawOneCoin method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawOneCoin(lpTokenAmount, coin, slippage = 0.5) {
+        throw Error(`withdrawOneCoin method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- WITHDRAW ONE COIN WRAPPED ----------------
     // OVERRIDE
-    PoolTemplate.prototype._withdrawOneCoinWrappedExpected = function (_lpTokenAmount, i) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawOneCoinWrappedExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawOneCoinWrappedExpected = function (lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function () {
-            var i, _lpTokenAmount, _expected;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        i = this._getCoinIdx(coin, false);
-                        _lpTokenAmount = (0, utils_1.parseUnits)(lpTokenAmount);
-                        return [4 /*yield*/, this._withdrawOneCoinWrappedExpected(_lpTokenAmount, i)];
-                    case 1:
-                        _expected = _c.sent();
-                        return [2 /*return*/, ethers_1.ethers.utils.formatUnits(_expected, this.wrappedDecimals[i])];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.withdrawOneCoinWrappedBonus = function (lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function () {
-            var prices, coinPrice, amount, _c, value, balancedAmounts, balancedValue;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this._wrappedPrices()];
-                    case 1:
-                        prices = _d.sent();
-                        coinPrice = prices[this._getCoinIdx(coin, false)];
-                        _c = Number;
-                        return [4 /*yield*/, this.withdrawOneCoinWrappedExpected(lpTokenAmount, coin)];
-                    case 2:
-                        amount = _c.apply(void 0, [_d.sent()]);
-                        value = amount * coinPrice;
-                        return [4 /*yield*/, this.withdrawWrappedExpected(lpTokenAmount)];
-                    case 3:
-                        balancedAmounts = _d.sent();
-                        balancedValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [2 /*return*/, String((value - balancedValue) / balancedValue * 100)];
-                }
-            });
-        });
-    };
+    async _withdrawOneCoinWrappedExpected(_lpTokenAmount, i) {
+        throw Error(`withdrawOneCoinWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
+    async withdrawOneCoinWrappedExpected(lpTokenAmount, coin) {
+        const i = this._getCoinIdx(coin, false);
+        const _lpTokenAmount = parseUnits(lpTokenAmount);
+        const _expected = await this._withdrawOneCoinWrappedExpected(_lpTokenAmount, i);
+        return curve.formatUnits(_expected, this.wrappedDecimals[i]);
+    }
+    async withdrawOneCoinWrappedBonus(lpTokenAmount, coin) {
+        const prices = await this._wrappedPrices();
+        const coinPrice = prices[this._getCoinIdx(coin, false)];
+        const amount = Number(await this.withdrawOneCoinWrappedExpected(lpTokenAmount, coin));
+        const value = amount * coinPrice;
+        const balancedAmounts = await this.withdrawWrappedExpected(lpTokenAmount);
+        const balancedValue = balancedAmounts.map(Number).reduce((s, a, i) => s + (a * prices[i]), 0);
+        return String((value - balancedValue) / balancedValue * 100);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawOneCoinWrappedEstimateGas = function (lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawOneCoinWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawOneCoinWrappedEstimateGas(lpTokenAmount, coin) {
+        throw Error(`withdrawOneCoinWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.withdrawOneCoinWrapped = function (lpTokenAmount, coin, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("withdrawOneCoinWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async withdrawOneCoinWrapped(lpTokenAmount, coin, slippage = 0.5) {
+        throw Error(`withdrawOneCoinWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- WALLET BALANCES ----------------
-    PoolTemplate.prototype.walletBalances = function () {
-        var addresses = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            addresses[_i] = arguments[_i];
-        }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!(this.gauge === ethers_1.ethers.constants.AddressZero)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._balances.apply(this, __spreadArray([__spreadArray(__spreadArray(['lpToken'], this.underlyingCoinAddresses, true), this.wrappedCoinAddresses, true), __spreadArray(__spreadArray([this.lpToken], this.underlyingCoinAddresses, true), this.wrappedCoinAddresses, true)], addresses, false))];
-                    case 1: return [2 /*return*/, _c.sent()];
-                    case 2: return [4 /*yield*/, this._balances.apply(this, __spreadArray([__spreadArray(__spreadArray(['lpToken', 'gauge'], this.underlyingCoinAddresses, true), this.wrappedCoinAddresses, true), __spreadArray(__spreadArray([this.lpToken, this.gauge], this.underlyingCoinAddresses, true), this.wrappedCoinAddresses, true)], addresses, false))];
-                    case 3: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.walletLpTokenBalances = function () {
-        var addresses = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            addresses[_i] = arguments[_i];
+    async walletBalances(...addresses) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            return await this._balances(['lpToken', ...this.underlyingCoinAddresses, ...this.wrappedCoinAddresses], [this.lpToken, ...this.underlyingCoinAddresses, ...this.wrappedCoinAddresses], ...addresses);
         }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!(this.gauge === ethers_1.ethers.constants.AddressZero)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._balances.apply(this, __spreadArray([['lpToken'], [this.lpToken]], addresses, false))];
-                    case 1: return [2 /*return*/, _c.sent()];
-                    case 2: return [4 /*yield*/, this._balances.apply(this, __spreadArray([['lpToken', 'gauge'], [this.lpToken, this.gauge]], addresses, false))];
-                    case 3: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.walletUnderlyingCoinBalances = function () {
-        var addresses = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            addresses[_i] = arguments[_i];
+        else {
+            return await this._balances(['lpToken', 'gauge', ...this.underlyingCoinAddresses, ...this.wrappedCoinAddresses], [this.lpToken, this.gauge, ...this.underlyingCoinAddresses, ...this.wrappedCoinAddresses], ...addresses);
         }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this._balances.apply(this, __spreadArray([this.underlyingCoinAddresses, this.underlyingCoinAddresses], addresses, false))];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.walletWrappedCoinBalances = function () {
-        var addresses = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            addresses[_i] = arguments[_i];
+    }
+    async walletLpTokenBalances(...addresses) {
+        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+            return await this._balances(['lpToken'], [this.lpToken], ...addresses);
         }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this._balances.apply(this, __spreadArray([this.wrappedCoinAddresses, this.wrappedCoinAddresses], addresses, false))];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.walletAllCoinBalances = function () {
-        var addresses = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            addresses[_i] = arguments[_i];
+        else {
+            return await this._balances(['lpToken', 'gauge'], [this.lpToken, this.gauge], ...addresses);
         }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this._balances.apply(this, __spreadArray([__spreadArray(__spreadArray([], this.underlyingCoinAddresses, true), this.wrappedCoinAddresses, true), __spreadArray(__spreadArray([], this.underlyingCoinAddresses, true), this.wrappedCoinAddresses, true)], addresses, false))];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+    }
+    async walletUnderlyingCoinBalances(...addresses) {
+        return await this._balances(this.underlyingCoinAddresses, this.underlyingCoinAddresses, ...addresses);
+    }
+    async walletWrappedCoinBalances(...addresses) {
+        return await this._balances(this.wrappedCoinAddresses, this.wrappedCoinAddresses, ...addresses);
+    }
+    async walletAllCoinBalances(...addresses) {
+        return await this._balances([...this.underlyingCoinAddresses, ...this.wrappedCoinAddresses], [...this.underlyingCoinAddresses, ...this.wrappedCoinAddresses], ...addresses);
+    }
     // ---------------- USER BALANCES, BASE PROFIT AND SHARE ----------------
-    PoolTemplate.prototype._userLpTotalBalance = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var lpBalances, lpTotalBalanceBN;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.walletLpTokenBalances(address)];
-                    case 1:
-                        lpBalances = _c.sent();
-                        lpTotalBalanceBN = (0, utils_1.BN)(lpBalances.lpToken);
-                        if ('gauge' in lpBalances)
-                            lpTotalBalanceBN = lpTotalBalanceBN.plus((0, utils_1.BN)(lpBalances.gauge));
-                        return [2 /*return*/, lpTotalBalanceBN];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.userBalances = function (address) {
-        if (address === void 0) { address = ""; }
-        return __awaiter(this, void 0, void 0, function () {
-            var lpTotalBalanceBN;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        address = address || curve_1.curve.signerAddress;
-                        if (!address)
-                            throw Error("Need to connect wallet or pass address into args");
-                        return [4 /*yield*/, this._userLpTotalBalance(address)];
-                    case 1:
-                        lpTotalBalanceBN = _c.sent();
-                        if (lpTotalBalanceBN.eq(0))
-                            return [2 /*return*/, this.underlyingCoins.map(function () { return "0"; })];
-                        return [4 /*yield*/, this.withdrawExpected(lpTotalBalanceBN.toFixed(18))];
-                    case 2: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.userWrappedBalances = function (address) {
-        if (address === void 0) { address = ""; }
-        return __awaiter(this, void 0, void 0, function () {
-            var lpTotalBalanceBN;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        address = address || curve_1.curve.signerAddress;
-                        if (!address)
-                            throw Error("Need to connect wallet or pass address into args");
-                        return [4 /*yield*/, this._userLpTotalBalance(address)];
-                    case 1:
-                        lpTotalBalanceBN = _c.sent();
-                        if (lpTotalBalanceBN.eq(0))
-                            return [2 /*return*/, this.wrappedCoins.map(function () { return "0"; })];
-                        return [4 /*yield*/, this.withdrawWrappedExpected(lpTotalBalanceBN.toFixed(18))];
-                    case 2: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.userLiquidityUSD = function (address) {
-        if (address === void 0) { address = ""; }
-        return __awaiter(this, void 0, void 0, function () {
-            var lpBalanceBN, lpPrice;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this._userLpTotalBalance(address)];
-                    case 1:
-                        lpBalanceBN = _c.sent();
-                        return [4 /*yield*/, (0, utils_1._getUsdRate)(this.lpToken)];
-                    case 2:
-                        lpPrice = _c.sent();
-                        return [2 /*return*/, lpBalanceBN.times(lpPrice).toFixed(8)];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.baseProfit = function (address) {
-        if (address === void 0) { address = ""; }
-        return __awaiter(this, void 0, void 0, function () {
-            var apyData, apyBN, totalLiquidityBN, _c, annualProfitBN, monthlyProfitBN, weeklyProfitBN, dailyProfitBN;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.statsBaseApy()];
-                    case 1:
-                        apyData = _d.sent();
-                        if (!('week' in apyData))
-                            return [2 /*return*/, { day: "0", week: "0", month: "0", year: "0" }];
-                        apyBN = (0, utils_1.BN)(apyData.week).div(100);
-                        _c = utils_1.BN;
-                        return [4 /*yield*/, this.userLiquidityUSD(address)];
-                    case 2:
-                        totalLiquidityBN = _c.apply(void 0, [_d.sent()]);
-                        annualProfitBN = apyBN.times(totalLiquidityBN);
-                        monthlyProfitBN = annualProfitBN.div(12);
-                        weeklyProfitBN = annualProfitBN.div(52);
-                        dailyProfitBN = annualProfitBN.div(365);
-                        return [2 /*return*/, {
-                                day: dailyProfitBN.toString(),
-                                week: weeklyProfitBN.toString(),
-                                month: monthlyProfitBN.toString(),
-                                year: annualProfitBN.toString(),
-                            }];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.userShare = function (address) {
-        if (address === void 0) { address = ""; }
-        return __awaiter(this, void 0, void 0, function () {
-            var withGauge, userLpBalance, userLpTotalBalanceBN, totalLp, gaugeLp, _c, _d;
-            var _e;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        withGauge = this.gauge !== ethers_1.ethers.constants.AddressZero;
-                        address = address || curve_1.curve.signerAddress;
-                        if (!address)
-                            throw Error("Need to connect wallet or pass address into args");
-                        return [4 /*yield*/, this.walletLpTokenBalances(address)];
-                    case 1:
-                        userLpBalance = _f.sent();
-                        userLpTotalBalanceBN = (0, utils_1.BN)(userLpBalance.lpToken);
-                        if (withGauge)
-                            userLpTotalBalanceBN = userLpTotalBalanceBN.plus((0, utils_1.BN)(userLpBalance.gauge));
-                        if (!withGauge) return [3 /*break*/, 3];
-                        return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                curve_1.curve.contracts[this.lpToken].multicallContract.totalSupply(),
-                                curve_1.curve.contracts[this.gauge].multicallContract.totalSupply(),
-                            ])];
-                    case 2:
-                        _e = (_f.sent()).map(function (_supply) { return ethers_1.ethers.utils.formatUnits(_supply); }), totalLp = _e[0], gaugeLp = _e[1];
-                        return [3 /*break*/, 5];
-                    case 3:
-                        _d = (_c = ethers_1.ethers.utils).formatUnits;
-                        return [4 /*yield*/, curve_1.curve.contracts[this.lpToken].contract.totalSupply(curve_1.curve.constantOptions)];
-                    case 4:
-                        totalLp = _d.apply(_c, [_f.sent()]);
-                        _f.label = 5;
-                    case 5: return [2 /*return*/, {
-                            lpUser: userLpTotalBalanceBN.toString(),
-                            lpTotal: totalLp,
-                            lpShare: (0, utils_1.BN)(totalLp).gt(0) ? userLpTotalBalanceBN.div(totalLp).times(100).toString() : '0',
-                            gaugeUser: userLpBalance.gauge,
-                            gaugeTotal: gaugeLp,
-                            gaugeShare: !withGauge ? undefined : (0, utils_1.BN)(gaugeLp).gt(0) ? (0, utils_1.BN)(userLpBalance.gauge).div(gaugeLp).times(100).toString() : '0',
-                        }];
-                }
-            });
-        });
-    };
+    async _userLpTotalBalance(address) {
+        const lpBalances = await this.walletLpTokenBalances(address);
+        let lpTotalBalanceBN = BN(lpBalances.lpToken);
+        if ('gauge' in lpBalances)
+            lpTotalBalanceBN = lpTotalBalanceBN.plus(BN(lpBalances.gauge));
+        return lpTotalBalanceBN;
+    }
+    async userBalances(address = "") {
+        address = address || curve.signerAddress;
+        if (!address)
+            throw Error("Need to connect wallet or pass address into args");
+        const lpTotalBalanceBN = await this._userLpTotalBalance(address);
+        if (lpTotalBalanceBN.eq(0))
+            return this.underlyingCoins.map(() => "0");
+        return await this.withdrawExpected(lpTotalBalanceBN.toFixed(18));
+    }
+    async userWrappedBalances(address = "") {
+        address = address || curve.signerAddress;
+        if (!address)
+            throw Error("Need to connect wallet or pass address into args");
+        const lpTotalBalanceBN = await this._userLpTotalBalance(address);
+        if (lpTotalBalanceBN.eq(0))
+            return this.wrappedCoins.map(() => "0");
+        return await this.withdrawWrappedExpected(lpTotalBalanceBN.toFixed(18));
+    }
+    async userLiquidityUSD(address = "") {
+        const lpBalanceBN = await this._userLpTotalBalance(address);
+        const lpPrice = await _getUsdRate(this.lpToken);
+        return lpBalanceBN.times(lpPrice).toFixed(8);
+    }
+    async baseProfit(address = "") {
+        const apyData = await this.statsBaseApy();
+        if (!('week' in apyData))
+            return { day: "0", week: "0", month: "0", year: "0" };
+        const apyBN = BN(apyData.week).div(100);
+        const totalLiquidityBN = BN(await this.userLiquidityUSD(address));
+        const annualProfitBN = apyBN.times(totalLiquidityBN);
+        const monthlyProfitBN = annualProfitBN.div(12);
+        const weeklyProfitBN = annualProfitBN.div(52);
+        const dailyProfitBN = annualProfitBN.div(365);
+        return {
+            day: dailyProfitBN.toString(),
+            week: weeklyProfitBN.toString(),
+            month: monthlyProfitBN.toString(),
+            year: annualProfitBN.toString(),
+        };
+    }
+    async userShare(address = "") {
+        const withGauge = this.gauge !== curve.constants.ZERO_ADDRESS;
+        address = address || curve.signerAddress;
+        if (!address)
+            throw Error("Need to connect wallet or pass address into args");
+        const userLpBalance = await this.walletLpTokenBalances(address);
+        let userLpTotalBalanceBN = BN(userLpBalance.lpToken);
+        if (withGauge)
+            userLpTotalBalanceBN = userLpTotalBalanceBN.plus(BN(userLpBalance.gauge));
+        let totalLp, gaugeLp;
+        if (withGauge) {
+            [totalLp, gaugeLp] = (await curve.multicallProvider.all([
+                curve.contracts[this.lpToken].multicallContract.totalSupply(),
+                curve.contracts[this.gauge].multicallContract.totalSupply(),
+            ])).map((_supply) => curve.formatUnits(_supply));
+        }
+        else {
+            totalLp = curve.formatUnits(await curve.contracts[this.lpToken].contract.totalSupply(curve.constantOptions));
+        }
+        return {
+            lpUser: userLpTotalBalanceBN.toString(),
+            lpTotal: totalLp,
+            lpShare: BN(totalLp).gt(0) ? userLpTotalBalanceBN.div(totalLp).times(100).toString() : '0',
+            gaugeUser: userLpBalance.gauge,
+            gaugeTotal: gaugeLp,
+            gaugeShare: !withGauge ? undefined : BN(gaugeLp).gt(0) ? BN(userLpBalance.gauge).div(gaugeLp).times(100).toString() : '0',
+        };
+    }
     // ---------------- SWAP ----------------
-    PoolTemplate.prototype._swapExpected = function (i, j, _amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contractAddress, contract;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        contractAddress = this.isCrypto && this.isMeta ? this.zap : this.address;
-                        contract = curve_1.curve.contracts[contractAddress].contract;
-                        if (!Object.prototype.hasOwnProperty.call(contract, 'get_dy_underlying')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, contract.get_dy_underlying(i, j, _amount, curve_1.curve.constantOptions)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                    case 2:
-                        if (!('get_dy(address,uint256,uint256,uint256)' in contract)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, contract.get_dy(this.address, i, j, _amount, curve_1.curve.constantOptions)];
-                    case 3: // atricrypto3 based metapools
-                    return [2 /*return*/, _c.sent()];
-                    case 4: return [4 /*yield*/, contract.get_dy(i, j, _amount, curve_1.curve.constantOptions)];
-                    case 5: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.swapExpected = function (inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var i, j, _amount, _expected;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        i = this._getCoinIdx(inputCoin);
-                        j = this._getCoinIdx(outputCoin);
-                        _amount = (0, utils_1.parseUnits)(amount, this.underlyingDecimals[i]);
-                        return [4 /*yield*/, this._swapExpected(i, j, _amount)];
-                    case 1:
-                        _expected = _c.sent();
-                        return [2 /*return*/, ethers_1.ethers.utils.formatUnits(_expected, this.underlyingDecimals[j])];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.swapPriceImpact = function (inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var i, j, _c, inputCoinDecimals, outputCoinDecimals, _amount, _output, smallAmountIntBN, amountIntBN, _smallAmount, _smallOutput, priceImpactBN;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        i = this._getCoinIdx(inputCoin);
-                        j = this._getCoinIdx(outputCoin);
-                        _c = [this.underlyingDecimals[i], this.underlyingDecimals[j]], inputCoinDecimals = _c[0], outputCoinDecimals = _c[1];
-                        _amount = (0, utils_1.parseUnits)(amount, inputCoinDecimals);
-                        return [4 /*yield*/, this._swapExpected(i, j, _amount)];
-                    case 1:
-                        _output = _d.sent();
-                        smallAmountIntBN = (0, utils_1._get_small_x)(_amount, _output, inputCoinDecimals, outputCoinDecimals);
-                        amountIntBN = (0, utils_1.toBN)(_amount, 0);
-                        if (smallAmountIntBN.gte(amountIntBN))
-                            return [2 /*return*/, 0];
-                        _smallAmount = (0, utils_1.fromBN)(smallAmountIntBN.div(Math.pow(10, inputCoinDecimals)), inputCoinDecimals);
-                        return [4 /*yield*/, this._swapExpected(i, j, _smallAmount)];
-                    case 2:
-                        _smallOutput = _d.sent();
-                        priceImpactBN = (0, utils_1._get_price_impact)(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
-                        return [2 /*return*/, Number((0, utils_1._cutZeros)(priceImpactBN.toFixed(4)))];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype._swapContractAddress = function () {
+    async _swapExpected(i, j, _amount) {
+        const contractAddress = this.isCrypto && this.isMeta ? this.zap : this.address;
+        const contract = curve.contracts[contractAddress].contract;
+        if (Object.prototype.hasOwnProperty.call(contract, 'get_dy_underlying')) {
+            return await contract.get_dy_underlying(i, j, _amount, curve.constantOptions);
+        }
+        else {
+            if ('get_dy(address,uint256,uint256,uint256)' in contract) { // atricrypto3 based metapools
+                return await contract.get_dy(this.address, i, j, _amount, curve.constantOptions);
+            }
+            return await contract.get_dy(i, j, _amount, curve.constantOptions);
+        }
+    }
+    async swapExpected(inputCoin, outputCoin, amount) {
+        const i = this._getCoinIdx(inputCoin);
+        const j = this._getCoinIdx(outputCoin);
+        const _amount = parseUnits(amount, this.underlyingDecimals[i]);
+        const _expected = await this._swapExpected(i, j, _amount);
+        return curve.formatUnits(_expected, this.underlyingDecimals[j]);
+    }
+    async swapPriceImpact(inputCoin, outputCoin, amount) {
+        const i = this._getCoinIdx(inputCoin);
+        const j = this._getCoinIdx(outputCoin);
+        const [inputCoinDecimals, outputCoinDecimals] = [this.underlyingDecimals[i], this.underlyingDecimals[j]];
+        const _amount = parseUnits(amount, inputCoinDecimals);
+        const _output = await this._swapExpected(i, j, _amount);
+        const smallAmountIntBN = _get_small_x(_amount, _output, inputCoinDecimals, outputCoinDecimals);
+        const amountIntBN = toBN(_amount, 0);
+        if (smallAmountIntBN.gte(amountIntBN))
+            return 0;
+        const _smallAmount = fromBN(smallAmountIntBN.div(10 ** inputCoinDecimals), inputCoinDecimals);
+        const _smallOutput = await this._swapExpected(i, j, _smallAmount);
+        const priceImpactBN = _get_price_impact(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
+        return Number(_cutZeros(priceImpactBN.toFixed(4)));
+    }
+    _swapContractAddress() {
         return (this.isCrypto && this.isMeta) || (this.isMetaFactory && (new PoolTemplate(this.basePool).isLending)) ? this.zap : this.address;
-    };
-    PoolTemplate.prototype.swapIsApproved = function (inputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contractAddress, i;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        contractAddress = this._swapContractAddress();
-                        i = this._getCoinIdx(inputCoin);
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.underlyingCoinAddresses[i]], [amount], curve_1.curve.signerAddress, contractAddress)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.swapApproveEstimateGas = function (inputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contractAddress, i;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        contractAddress = this._swapContractAddress();
-                        i = this._getCoinIdx(inputCoin);
-                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.underlyingCoinAddresses[i]], [amount], contractAddress)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    PoolTemplate.prototype.swapApprove = function (inputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contractAddress, i;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        contractAddress = this._swapContractAddress();
-                        i = this._getCoinIdx(inputCoin);
-                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.underlyingCoinAddresses[i]], [amount], contractAddress)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+    }
+    async swapIsApproved(inputCoin, amount) {
+        const contractAddress = this._swapContractAddress();
+        const i = this._getCoinIdx(inputCoin);
+        return await hasAllowance([this.underlyingCoinAddresses[i]], [amount], curve.signerAddress, contractAddress);
+    }
+    async swapApproveEstimateGas(inputCoin, amount) {
+        const contractAddress = this._swapContractAddress();
+        const i = this._getCoinIdx(inputCoin);
+        return await ensureAllowanceEstimateGas([this.underlyingCoinAddresses[i]], [amount], contractAddress);
+    }
+    async swapApprove(inputCoin, amount) {
+        const contractAddress = this._swapContractAddress();
+        const i = this._getCoinIdx(inputCoin);
+        return await ensureAllowance([this.underlyingCoinAddresses[i]], [amount], contractAddress);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.swapEstimateGas = function (inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("swap method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async swapEstimateGas(inputCoin, outputCoin, amount) {
+        throw Error(`swap method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.swap = function (inputCoin, outputCoin, amount, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("swap method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async swap(inputCoin, outputCoin, amount, slippage = 0.5) {
+        throw Error(`swap method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // ---------------- SWAP WRAPPED ----------------
-    PoolTemplate.prototype._swapWrappedExpected = function (i, j, _amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, curve_1.curve.contracts[this.address].contract.get_dy(i, j, _amount, curve_1.curve.constantOptions)];
-                    case 1: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
+    async _swapWrappedExpected(i, j, _amount) {
+        return await curve.contracts[this.address].contract.get_dy(i, j, _amount, curve.constantOptions);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.swapWrappedExpected = function (inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("swapWrappedExpected method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
-    PoolTemplate.prototype.swapWrappedPriceImpact = function (inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var i, j, _c, inputCoinDecimals, outputCoinDecimals, _amount, _output, smallAmountIntBN, amountIntBN, _smallAmount, _smallOutput, priceImpactBN;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (this.isPlain || this.isFake) {
-                            throw Error("swapWrappedPriceImpact method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        }
-                        i = this._getCoinIdx(inputCoin, false);
-                        j = this._getCoinIdx(outputCoin, false);
-                        _c = [this.wrappedDecimals[i], this.wrappedDecimals[j]], inputCoinDecimals = _c[0], outputCoinDecimals = _c[1];
-                        _amount = (0, utils_1.parseUnits)(amount, inputCoinDecimals);
-                        return [4 /*yield*/, this._swapWrappedExpected(i, j, _amount)];
-                    case 1:
-                        _output = _d.sent();
-                        smallAmountIntBN = (0, utils_1._get_small_x)(_amount, _output, inputCoinDecimals, outputCoinDecimals);
-                        amountIntBN = (0, utils_1.toBN)(_amount, 0);
-                        if (smallAmountIntBN.gte(amountIntBN))
-                            return [2 /*return*/, 0];
-                        _smallAmount = (0, utils_1.fromBN)(smallAmountIntBN.div(Math.pow(10, inputCoinDecimals)), inputCoinDecimals);
-                        return [4 /*yield*/, this._swapWrappedExpected(i, j, _smallAmount)];
-                    case 2:
-                        _smallOutput = _d.sent();
-                        priceImpactBN = (0, utils_1._get_price_impact)(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
-                        return [2 /*return*/, Number((0, utils_1._cutZeros)(priceImpactBN.toFixed(4)))];
-                }
-            });
-        });
-    };
+    async swapWrappedExpected(inputCoin, outputCoin, amount) {
+        throw Error(`swapWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
+    async swapWrappedPriceImpact(inputCoin, outputCoin, amount) {
+        if (this.isPlain || this.isFake) {
+            throw Error(`swapWrappedPriceImpact method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        }
+        const i = this._getCoinIdx(inputCoin, false);
+        const j = this._getCoinIdx(outputCoin, false);
+        const [inputCoinDecimals, outputCoinDecimals] = [this.wrappedDecimals[i], this.wrappedDecimals[j]];
+        const _amount = parseUnits(amount, inputCoinDecimals);
+        const _output = await this._swapWrappedExpected(i, j, _amount);
+        const smallAmountIntBN = _get_small_x(_amount, _output, inputCoinDecimals, outputCoinDecimals);
+        const amountIntBN = toBN(_amount, 0);
+        if (smallAmountIntBN.gte(amountIntBN))
+            return 0;
+        const _smallAmount = fromBN(smallAmountIntBN.div(10 ** inputCoinDecimals), inputCoinDecimals);
+        const _smallOutput = await this._swapWrappedExpected(i, j, _smallAmount);
+        const priceImpactBN = _get_price_impact(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
+        return Number(_cutZeros(priceImpactBN.toFixed(4)));
+    }
     // OVERRIDE
-    PoolTemplate.prototype.swapWrappedIsApproved = function (inputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("swapWrappedIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async swapWrappedIsApproved(inputCoin, amount) {
+        throw Error(`swapWrappedIsApproved method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.swapWrappedApproveEstimateGas = function (inputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("swapWrappedApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async swapWrappedApproveEstimateGas(inputCoin, amount) {
+        throw Error(`swapWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.swapWrappedApprove = function (inputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("swapWrappedApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async swapWrappedApprove(inputCoin, amount) {
+        throw Error(`swapWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.swapWrappedEstimateGas = function (inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("swapWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
+    async swapWrappedEstimateGas(inputCoin, outputCoin, amount) {
+        throw Error(`swapWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
     // OVERRIDE
-    PoolTemplate.prototype.swapWrapped = function (inputCoin, outputCoin, amount, slippage) {
-        if (slippage === void 0) { slippage = 0.5; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                throw Error("swapWrapped method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-            });
-        });
-    };
-    return PoolTemplate;
-}());
-exports.PoolTemplate = PoolTemplate;
+    async swapWrapped(inputCoin, outputCoin, amount, slippage = 0.5) {
+        throw Error(`swapWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
+    }
+}