@curvefi/api 2.31.1 → 2.33.0

package/lib/pools/PoolTemplate.js

@@ -1,737 +1,1066 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import 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));
-                    }
-                }
-            }
-            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);
-                }
-                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());
+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.contracts[this.address].multicallContract;
+                        lpMulticallContract = 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 = curve.parseUnits("0");
+                        _fee = curve.parseUnits("0");
+                        _j.label = 1;
+                    case 1:
+                        _j.trys.push([1, 3, , 8]);
+                        return [4 /*yield*/, 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.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.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 = [
+                            curve.formatUnits(_virtualPrice),
+                            curve.formatUnits(_fee, 8),
+                            curve.formatUnits(_adminFee * _fee),
+                            curve.formatUnits(_A, 0),
+                            curve.formatUnits(_lpTokenSupply),
+                            _gamma ? curve.formatUnits(_gamma) : undefined,
+                        ], 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 curve.formatUnits(_p); });
+                            priceOracle = [];
+                            priceScale = [];
+                            for (i = 0; i < this.wrappedCoins.length - 1; i++) {
+                                priceOracle.push(prices.shift());
+                                priceScale.push(prices.shift());
+                            }
+                        }
+                        A_PRECISION = curve.chainId === 1 && ['compound', 'usdt', 'y', 'busd', 'susd', 'pax', 'ren', 'sbtc', 'hbtc', '3pool'].includes(this.id) ? 1 : 100;
+                        return [4 /*yield*/, 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(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,
+                        ], 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 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.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.constants.NETWORK_NAME;
+                            poolType = !this.isFactory && !this.isCrypto ? "main" :
+                                !this.isFactory ? "crypto" :
+                                    !(this.isCrypto && this.isFactory) ? "factory" :
+                                        "factory-crypto";
+                            return [4 /*yield*/, _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(_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)];
+                    }
+                });
+            });
         };
-        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.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.chainId)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, Promise.all([
+                                _getLegacyAPYsAndVolumes(curve.constants.NETWORK_NAME),
+                                _getFactoryAPYsAndVolumes(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*/, _getUsdRate(this.lpToken)];
+                    case 2:
+                        lpPrice = _e.sent();
+                        return [2 /*return*/, (poolData_1.volume * lpPrice).toString()];
+                    case 3:
+                        network = curve.constants.NETWORK_NAME;
+                        return [4 /*yield*/, _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()];
                 }
-            }
-            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.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.chainId)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Promise.all([
+                                _getLegacyAPYsAndVolumes(curve.constants.NETWORK_NAME),
+                                _getFactoryAPYsAndVolumes(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.constants.NETWORK_NAME;
+                        return [4 /*yield*/, _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(),
+                            }];
                 }
-            }
-            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.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.chainId);
+                            if (!(useApi && !isDisabledChain)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, _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.chainId !== 1)) return [3 /*break*/, 7];
+                            gaugeContract = curve.contracts[this.gauge].multicallContract;
+                            lpTokenContract = curve.contracts[this.lpToken].multicallContract;
+                            crvContract = curve.contracts[curve.constants.ALIASES.crv].contract;
+                            currentWeek = Math.floor(Date.now() / 1000 / WEEK);
+                            return [4 /*yield*/, curve.multicallProvider.all([
+                                    gaugeContract.inflation_rate(currentWeek),
+                                    gaugeContract.working_supply(),
+                                    lpTokenContract.totalSupply(),
+                                ])];
+                        case 4:
+                            _d = (_g.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _d[0], workingSupplyBN = _d[1], totalSupplyBN = _d[2];
+                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 6];
+                            _c = toBN;
+                            return [4 /*yield*/, crvContract.balanceOf(this.gauge, 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.contracts[this.gauge].multicallContract;
+                            lpTokenContract = curve.contracts[this.lpToken].multicallContract;
+                            gaugeControllerContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
+                            weightBN = void 0;
+                            return [4 /*yield*/, 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 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*/, _getUsdRate(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()]];
+                    }
+                });
+            });
         };
-        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(),
+        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 === curve.constants.ZERO_ADDRESS)
+                                return [2 /*return*/, []];
+                            isDisabledChain = [1313161554].includes(curve.chainId);
+                            if (!(curve.chainId === 1 || (useApi && !isDisabledChain))) return [3 /*break*/, 2];
+                            return [4 /*yield*/, _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.contracts[this.gauge].multicallContract;
+                            lpTokenContract = curve.contracts[this.lpToken].multicallContract;
+                            rewardContract = curve.contracts[this.sRewardContract || this.gauge].multicallContract;
+                            return [4 /*yield*/, this.statsTotalLiquidity()];
+                        case 5:
+                            totalLiquidityUSD = _d.sent();
+                            return [4 /*yield*/, _getUsdRate(rewardToken.token)];
+                        case 6:
+                            rewardRate = _d.sent();
+                            return [4 /*yield*/, 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 = toBN(_stakedSupply);
+                            totalSupplyBN = toBN(_totalSupply);
+                            inflationBN = toBN(rewardData.rate, rewardToken.decimals);
+                            periodFinish = Number(curve.formatUnits(rewardData.period_finish, 0)) * 1000;
+                            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(),
+                            });
+                            _d.label = 8;
+                        case 8:
+                            _i++;
+                            return [3 /*break*/, 4];
+                        case 9: return [2 /*return*/, apy];
+                    }
                 });
-            }
-            return apy;
+            });
         };
-        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);
+        this._calcLpTokenAmount = memoize(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 e_2, lpContract, _lpTotalSupply, decimals_1, amounts, seedAmounts_1, contract, basePool, e_3, lpContract, _lpTotalSupply, decimals_2, amounts_1, seedAmounts_2, _amounts18Decimals;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (!this.isCrypto) return [3 /*break*/, 6];
+                            _c.label = 1;
+                        case 1:
+                            _c.trys.push([1, 3, , 6]);
+                            return [4 /*yield*/, this._pureCalcLpTokenAmount(_amounts, isDeposit, useUnderlying)];
+                        case 2: return [2 /*return*/, _c.sent()];
+                        case 3:
+                            e_2 = _c.sent();
+                            lpContract = curve.contracts[this.lpToken].contract;
+                            return [4 /*yield*/, lpContract.totalSupply(curve.constantOptions)];
+                        case 4:
+                            _lpTotalSupply = _c.sent();
+                            if (_lpTotalSupply > curve.parseUnits("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 curve.formatUnits(_a, decimals_1[i]); });
+                            return [4 /*yield*/, this.cryptoSeedAmounts(amounts[0])];
+                        case 5:
+                            seedAmounts_1 = _c.sent();
+                            amounts.forEach(function (a, i) {
+                                if (!BN(a).eq(BN(seedAmounts_1[i])))
+                                    throw Error("Amounts must be = ".concat(seedAmounts_1));
+                            });
+                            return [2 /*return*/, parseUnits(Math.sqrt(Number(amounts[0]) * Number(amounts[1])))];
+                        case 6:
+                            _c.trys.push([6, 11, , 13]);
+                            contract = curve.contracts[curve.constants.ALIASES.stable_calc].contract;
+                            if (!this.isMeta) return [3 /*break*/, 8];
+                            basePool = new PoolTemplate(this.basePool);
+                            return [4 /*yield*/, contract.calc_token_amount_meta(this.address, this.lpToken, _amounts.concat(Array(5 - _amounts.length).fill(curve.parseUnits("0"))), _amounts.length, basePool.address, basePool.lpToken, isDeposit, useUnderlying)];
+                        case 7: return [2 /*return*/, _c.sent()];
+                        case 8: return [4 /*yield*/, contract.calc_token_amount(this.address, this.lpToken, _amounts.concat(Array(5 - _amounts.length).fill(curve.parseUnits("0"))), _amounts.length, isDeposit, useUnderlying && this.isLending)];
+                        case 9: return [2 /*return*/, _c.sent()];
+                        case 10: return [3 /*break*/, 13];
+                        case 11:
+                            e_3 = _c.sent();
+                            if (!isDeposit)
+                                throw e_3; // Seeding is only for deposit
+                            lpContract = curve.contracts[this.lpToken].contract;
+                            return [4 /*yield*/, lpContract.totalSupply(curve.constantOptions)];
+                        case 12:
+                            _lpTotalSupply = _c.sent();
+                            if (_lpTotalSupply > curve.parseUnits("0"))
+                                throw e_3; // Already seeded
+                            decimals_2 = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
+                            amounts_1 = _amounts.map(function (_a, i) { return curve.formatUnits(_a, decimals_2[i]); });
+                            if (this.isMeta && useUnderlying) {
+                                seedAmounts_2 = this.metaUnderlyingSeedAmounts(amounts_1[0]);
+                                amounts_1.forEach(function (a, i) {
+                                    if (!BN(a).eq(BN(seedAmounts_2[i])))
+                                        throw Error("Amounts must be = ".concat(seedAmounts_2));
+                                });
+                            }
+                            else {
+                                if (_amounts[0] <= curve.parseUnits("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");
+                                });
+                            }
+                            _amounts18Decimals = amounts_1.map(function (a) { return parseUnits(a); });
+                            return [2 /*return*/, _amounts18Decimals.reduce(function (_a, _b) { return _a + _b; })];
+                        case 13: return [2 /*return*/];
                     }
-                }
-                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
+            maxAge: 30 * 1000,
+            length: 3,
         });
         // ---------------- CRV PROFIT, CLAIM, BOOSTING ----------------
-        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.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.signerAddress;
+                            if (!address)
+                                throw Error("Need to connect wallet or pass address into args");
+                            if (!(curve.chainId !== 1)) return [3 /*break*/, 4];
+                            gaugeContract = curve.contracts[this.gauge].multicallContract;
+                            crvContract = curve.contracts[curve.constants.ALIASES.crv].contract;
+                            currentWeek = Math.floor(Date.now() / 1000 / WEEK);
+                            return [4 /*yield*/, curve.multicallProvider.all([
+                                    gaugeContract.inflation_rate(currentWeek),
+                                    gaugeContract.working_balances(address),
+                                    gaugeContract.working_supply(),
+                                ])];
+                        case 1:
+                            _d = (_f.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _d[0], workingBalanceBN = _d[1], workingSupplyBN = _d[2];
+                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 3];
+                            _c = toBN;
+                            return [4 /*yield*/, crvContract.balanceOf(this.gauge, 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.contracts[this.gauge].multicallContract;
+                            gaugeControllerContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
+                            weightBN = void 0;
+                            return [4 /*yield*/, 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 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*/, _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.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.constants.ALIASES.crv,
+                                    symbol: 'CRV',
+                                    price: crvPrice,
+                                }];
+                    }
+                });
+            });
         };
-        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.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.chainId !== 1)
+                                throw Error("Boosting is available only on Ethereum network");
+                            if (this.gauge === curve.constants.ZERO_ADDRESS)
+                                throw Error("".concat(this.name, " doesn't have gauge"));
+                            address = address || curve.signerAddress;
+                            if (!address)
+                                throw Error("Need to connect wallet or pass address into args");
+                            gaugeContract = curve.contracts[this.gauge].multicallContract;
+                            return [4 /*yield*/, curve.multicallProvider.all([
+                                    gaugeContract.working_balances(address),
+                                    gaugeContract.balanceOf(address),
+                                ])];
+                        case 1:
+                            _c = (_d.sent()).map(function (value) { return 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.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.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.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.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*/, BN(baseApy).times(BN(boost)).toNumber()];
+                    }
+                });
+            });
         };
-        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]);
+        this.maxBoostedStake = function () {
+            var addresses = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                addresses[_i] = arguments[_i];
             }
-            return addresses.length === 1 ? result[addresses[0]] : result;
+            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.chainId !== 1)
+                                throw Error("Boosting is available only on Ethereum network");
+                            if (this.gauge === curve.constants.ZERO_ADDRESS)
+                                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.signerAddress !== '')
+                                addresses = [curve.signerAddress];
+                            if (addresses.length === 0)
+                                throw Error("Need to connect wallet or pass addresses into args");
+                            votingEscrowContract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
+                            gaugeContract = curve.contracts[this.gauge].multicallContract;
+                            contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
+                            addresses.forEach(function (account) {
+                                contractCalls.push(votingEscrowContract.balanceOf(account));
+                            });
+                            return [4 /*yield*/, curve.multicallProvider.all(contractCalls)];
+                        case 1:
+                            _response = _f.sent();
+                            responseBN = _response.map(function (value) { return 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]] = toStringFromBN(entry[1]);
+                            }
+                            return [2 /*return*/, addresses.length === 1 ? result[addresses[0]] : result];
+                    }
+                });
+            });
         };
         // ---------------- REWARDS PROFIT, CLAIM ----------------
-        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
+        this.rewardTokens = memoize(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 === curve.constants.ZERO_ADDRESS)
+                                return [2 /*return*/, []];
+                            if (!useApi) return [3 /*break*/, 2];
+                            return [4 /*yield*/, _getRewardsFromApi()];
+                        case 1:
+                            rewards = _f.sent();
+                            if (!rewards[this.gauge])
+                                return [2 /*return*/, []];
+                            rewards[this.gauge].forEach(function (r) { return _setContracts(r.tokenAddress, ERC20Abi); });
+                            return [2 /*return*/, rewards[this.gauge].map(function (r) { return ({ token: r.tokenAddress, symbol: r.symbol, decimals: Number(r.decimals) }); })];
+                        case 2:
+                            gaugeContract = curve.contracts[this.gauge].contract;
+                            gaugeMulticallContract = 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 = curve).formatUnits;
+                            return [4 /*yield*/, gaugeContract.reward_count(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.multicallProvider.all(tokenCalls)];
+                        case 5:
+                            tokens = (_f.sent())
+                                .filter(function (addr) { return addr !== curve.constants.ZERO_ADDRESS; })
+                                .map(function (addr) { return addr.toLowerCase(); });
+                            tokenInfoCalls = [];
+                            for (_i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+                                token = tokens_1[_i];
+                                _setContracts(token, ERC20Abi);
+                                tokenMulticallContract = curve.contracts[token].multicallContract;
+                                tokenInfoCalls.push(tokenMulticallContract.symbol(), tokenMulticallContract.decimals());
+                            }
+                            return [4 /*yield*/, curve.multicallProvider.all(tokenInfoCalls)];
+                        case 6:
+                            tokenInfo_1 = _f.sent();
+                            for (i = 0; i < tokens.length; i++) {
+                                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.contracts[this.sRewardContract].contract;
+                            method = "snx()" in rewardContract ? "snx" : "rewardsToken" // susd, tbtc : dusd, musd, rsv, sbtc
+                            ;
+                            return [4 /*yield*/, rewardContract[method](curve.constantOptions)];
+                        case 8:
+                            token = (_f.sent()).toLowerCase();
+                            _setContracts(token, ERC20Abi);
+                            tokenMulticallContract = curve.contracts[token].multicallContract;
+                            return [4 /*yield*/, 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
+                    }
+                });
+            });
         }, {
             promise: true,
             maxAge: 30 * 60 * 1000, // 30m
         });
-        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,
+        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 === curve.constants.ZERO_ADDRESS)
+                                throw Error("".concat(this.name, " doesn't have gauge"));
+                            address = address || 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.contracts[this.gauge].multicallContract;
+                            result = [];
+                            if (!('reward_data(address)' in 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.multicallProvider.all(calls)];
+                        case 2:
+                            res = _f.sent();
+                            balanceBN = toBN(res.shift());
+                            totalSupplyBN = 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(curve.formatUnits(_rewardData.period_finish, 0)) * 1000;
+                            inflationRateBN = periodFinish > Date.now() ? toBN(_rewardData.rate, rewardToken.decimals) : BN(0);
+                            return [4 /*yield*/, _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.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1)) return [3 /*break*/, 10];
+                            rewardToken = rewardTokens[0];
+                            sRewardContract = curve.contracts[this.sRewardContract].multicallContract;
+                            return [4 /*yield*/, 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 = Number(_periodFinish) * 1000;
+                            inflationRateBN = periodFinish > Date.now() ? toBN(_inflationRate, rewardToken.decimals) : BN(0);
+                            balanceBN = toBN(_balance);
+                            totalSupplyBN = toBN(_totalSupply);
+                            return [4 /*yield*/, _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*/, _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];
+                    }
                 });
-            }
-            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 = 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);
+        this.gaugeOptimalDeposits = function () {
+            var accounts = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                accounts[_i] = arguments[_i];
             }
-            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;
+            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 === curve.constants.ZERO_ADDRESS)
+                                throw Error("".concat(this.name, " doesn't have gauge"));
+                            if (accounts.length == 1 && Array.isArray(accounts[0]))
+                                accounts = accounts[0];
+                            votingEscrowContract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
+                            lpTokenContract = curve.contracts[this.lpToken].multicallContract;
+                            gaugeContract = 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.multicallProvider.all(contractCalls)];
+                        case 1:
+                            _response = _j.sent();
+                            response = _response.map(function (value) { return toBN(value); });
+                            _c = response.splice(0, 2), veTotalSupply = _c[0], gaugeTotalSupply = _c[1];
+                            votingPower = {};
+                            totalBalance = 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, 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]] = toStringFromBN(entry[1]);
+                            }
+                            return [2 /*return*/, optimal];
                     }
-                }
-            }
-            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 = (coin, useUnderlying = true) => {
+        this._getCoinIdx = function (coin, useUnderlying) {
+            if (useUnderlying === void 0) { useUnderlying = true; }
             if (typeof coin === 'number') {
-                const coins_N = useUnderlying ? this.underlyingCoins.length : this.wrappedCoins.length;
-                const idx = coin;
-                if (!Number.isInteger(idx)) {
+                var coins_N = useUnderlying ? _this.underlyingCoins.length : _this.wrappedCoins.length;
+                var idx_1 = coin;
+                if (!Number.isInteger(idx_1)) {
                     throw Error('Index must be integer');
                 }
-                if (idx < 0) {
+                if (idx_1 < 0) {
                     throw Error('Index must be >= 0');
                 }
-                if (idx > coins_N - 1) {
-                    throw Error(`Index must be < ${coins_N}`);
+                if (idx_1 > coins_N - 1) {
+                    throw Error("Index must be < ".concat(coins_N));
                 }
-                return idx;
+                return idx_1;
             }
-            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());
+            var coinAddress = _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());
             if (idx === -1) {
-                throw Error(`There is no ${coin} among ${this.name} pool ${useUnderlying ? 'underlying' : 'wrapped'} coins`);
+                throw Error("There is no ".concat(coin, " among ").concat(_this.name, " pool ").concat(useUnderlying ? 'underlying' : 'wrapped', " coins"));
             }
             return idx;
         };
-        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);
+        // Used by mixins
+        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.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.contracts[addr].contract.getPricePerFullShare()];
+                    case 4:
+                        _f.apply(_e, [_g.sent()]);
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _rates.push(curve.parseUnits(String(Math.pow(10, 18)), 0)); // Aave ratio 1:1
+                        _g.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        _rates.push(curve.parseUnits(String(Math.pow(10, 18)), 0));
+                        _g.label = 8;
+                    case 8:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 9: return [2 /*return*/, _rates];
                 }
+            });
+        }); };
+        this._balances = function (rawCoinNames, rawCoinAddresses) {
+            var addresses = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                addresses[_i - 2] = arguments[_i];
             }
-            return _rates;
+            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 = _prepareAddresses(addresses);
+                            return [4 /*yield*/, _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];
+                    }
+                });
+            });
         };
-        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]);
+        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(_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();
-                }
-            }
-            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._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(_getUsdRate(addr));
+                        }
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1: return [2 /*return*/, _d.sent()];
+                }
+            });
+        }); };
+        var poolData = __assign(__assign(__assign({}, 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;
@@ -751,15 +1080,15 @@ export class PoolTemplate {
         this.isFactory = poolData.is_factory || false;
         this.isMetaFactory = (this.isMeta && this.isFactory) || this.zap === '0xa79828df1850e8a3a3064576f380d90aecdd3359';
         this.basePool = poolData.base_pool || '';
-        this.metaCoinIdx = this.isMeta ? poolData.meta_coin_idx ?? poolData.wrapped_coins.length - 1 : -1;
+        this.metaCoinIdx = this.isMeta ? (_c = poolData.meta_coin_idx) !== null && _c !== void 0 ? _c : 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(() => false);
-        this.inApi = poolData.in_api ?? false;
+        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.estimateGas = {
             depositApprove: this.depositApproveEstimateGas.bind(this),
             deposit: this.depositEstimateGas.bind(this),
@@ -806,92 +1135,168 @@ export class PoolTemplate {
             allCoinBalances: this.walletAllCoinBalances.bind(this),
         };
     }
-    rewardsOnly() {
+    PoolTemplate.prototype.rewardsOnly = function () {
         if (curve.chainId === 2222)
             return true; // TODO remove this for Kava and Celo
         if (this.gauge === curve.constants.ZERO_ADDRESS)
-            throw Error(`${this.name} doesn't have gauge`);
-        const gaugeContract = curve.contracts[this.gauge].contract;
+            throw Error("".concat(this.name, " doesn't have gauge"));
+        var gaugeContract = curve.contracts[this.gauge].contract;
         return !('inflation_rate()' in gaugeContract || 'inflation_rate(uint256)' in gaugeContract);
-    }
-    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]));
-    }
+    };
+    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.contracts[this.address].multicallContract;
+                        contractCalls = this.wrappedCoins.map(function (_, i) { return swapContract.balances(i); });
+                        return [4 /*yield*/, curve.multicallProvider.all(contractCalls)];
+                    case 1:
+                        _wrappedBalances = _c.sent();
+                        return [2 /*return*/, _wrappedBalances.map(function (_b, i) { return curve.formatUnits(_b, _this.wrappedDecimals[i]); })];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    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);
-    }
+    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.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.constantOptions)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                    case 2: return [4 /*yield*/, contract.calc_token_amount(this.address, _amounts, 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.constantOptions)];
+                    case 5: return [2 /*return*/, _c.sent()];
+                    case 6: return [4 /*yield*/, contract.calc_token_amount(_amounts, 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 parseUnits(amount, _this.underlyingDecimals[i]); });
+                        return [4 /*yield*/, this._calcLpTokenAmount(_underlyingAmounts, isDeposit, true)];
+                    case 1:
+                        _expected = _c.sent();
+                        return [2 /*return*/, curve.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 parseUnits(amount, _this.wrappedDecimals[i]); });
+                        return [4 /*yield*/, this._calcLpTokenAmount(_amounts, isDeposit, false)];
+                    case 1:
+                        _expected = _c.sent();
+                        return [2 /*return*/, curve.formatUnits(_expected)];
+                }
+            });
+        });
+    };
     // ---------------- DEPOSIT ----------------
-    metaUnderlyingSeedAmounts(amount1) {
+    PoolTemplate.prototype.metaUnderlyingSeedAmounts = function (amount1) {
         if (this.isCrypto)
-            throw Error(`Use cryptoSeedAmounts method for ${this.name} pool`);
+            throw Error("Use cryptoSeedAmounts method for ".concat(this.name, " pool"));
         if (!this.isMeta)
             throw Error("metaUnderlyingSeedAmounts method exists only for meta stable pools");
-        const amount1BN = BN(amount1);
+        var amount1BN = BN(amount1);
         if (amount1BN.lte(0))
             throw Error("Initial deposit amounts must be > 0");
-        const amounts = [_cutZeros(amount1BN.toFixed(this.underlyingDecimals[0]))];
-        for (let i = 1; i < this.underlyingDecimals.length; i++) {
+        var amounts = [_cutZeros(amount1BN.toFixed(this.underlyingDecimals[0]))];
+        for (var i = 1; i < this.underlyingDecimals.length; i++) {
             amounts.push(amount1BN.div(this.underlyingDecimals.length - 1).toFixed(this.underlyingDecimals[i]));
         }
         return amounts;
-    }
-    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]))];
-    }
+    };
+    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 = BN(amount1);
+                        if (amount1BN.lte(0))
+                            throw Error("Initial deposit amounts must be > 0");
+                        _c = toBN;
+                        return [4 /*yield*/, curve.contracts[this.address].contract.price_scale(curve.constantOptions)];
+                    case 1:
+                        priceScaleBN = _c.apply(void 0, [_d.sent()]);
+                        return [2 /*return*/, [_cutZeros(amount1BN.toFixed(decimals[0])), _cutZeros(amount1BN.div(priceScaleBN).toFixed(decimals[1]))]];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async depositBalancedAmounts() {
-        throw Error(`depositBalancedAmounts method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
-    async depositExpected(amounts) {
-        return await this.calcLpTokenAmount(amounts);
-    }
+    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()];
+                }
+            });
+        });
+    };
     // | balanced[i] / sum(balanced[j]) = balance[i] / sum(balance[j]) |
     // | sum(pj * balanced[j]) = sum(aj * pj)                          |
     //
@@ -902,807 +1307,1773 @@ export class PoolTemplate {
     // totalBalanceBN = sum(balance[j])
     // ratiosBN[i] = balancesBN[i] / totalBalanceBN = ri = balance[i] / sum(balance[j])
     // denominatorBN = sum(rj * pj / ri)
-    _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));
+    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); });
             balancedAmountsBN.push(totalValueBN.div(denominatorBN));
+        };
+        for (var i = 0; i < amountsBN.length; i++) {
+            _loop_1(i);
         }
         return balancedAmountsBN.map(String);
-    }
-    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);
-    }
+    };
+    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(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(BN);
+                        return [4 /*yield*/, this.stats.underlyingBalances()];
+                    case 4:
+                        balancesBN = (_f.sent()).map(BN);
+                        balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
+                        _d = BN;
+                        return [4 /*yield*/, this.depositExpected(amounts)];
+                    case 5:
+                        expectedBN = _d.apply(void 0, [_f.sent()]);
+                        _e = 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*/, hasAllowance(this.underlyingCoinAddresses, amounts, 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*/, 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*/, ensureAllowance(this.underlyingCoinAddresses, amounts, this.zap || this.address)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async depositEstimateGas(amounts) {
-        throw Error(`depositEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async deposit(amounts, slippage = 0.5) {
-        throw Error(`deposit method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- DEPOSIT WRAPPED ----------------
-    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);
-    }
+    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(BN);
+                        return [4 /*yield*/, this._wrappedPrices()];
+                    case 1:
+                        pricesBN = (_e.sent()).map(BN);
+                        return [4 /*yield*/, this.stats.wrappedBalances()];
+                    case 2:
+                        balancesBN = (_e.sent()).map(BN);
+                        balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
+                        _c = BN;
+                        return [4 /*yield*/, this.depositWrappedExpected(amounts)];
+                    case 3:
+                        expectedBN = _c.apply(void 0, [_e.sent()]);
+                        _d = 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*/, hasAllowance(this.wrappedCoinAddresses, amounts, 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*/, 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*/, ensureAllowance(this.wrappedCoinAddresses, amounts, this.address)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async depositWrappedEstimateGas(amounts) {
-        throw Error(`depositWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async depositWrapped(amounts, slippage = 0.5) {
-        throw Error(`depositWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- STAKING ----------------
-    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;
-    }
+    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 === curve.constants.ZERO_ADDRESS) {
+                            throw Error("stakeIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, hasAllowance([this.lpToken], [lpTokenAmount], 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 === curve.constants.ZERO_ADDRESS) {
+                            throw Error("stakeApproveEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, 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 === curve.constants.ZERO_ADDRESS) {
+                            throw Error("stakeApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, 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, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            throw Error("stakeEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        _lpTokenAmount = parseUnits(lpTokenAmount);
+                        _c = Number;
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.deposit.estimateGas(_lpTokenAmount, curve.constantOptions)];
+                    case 1: return [2 /*return*/, _c.apply(void 0, [_d.sent()])];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.stake = function (lpTokenAmount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _lpTokenAmount, gasLimit, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            throw Error("stake method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        _lpTokenAmount = parseUnits(lpTokenAmount);
+                        return [4 /*yield*/, _ensureAllowance([this.lpToken], [_lpTokenAmount], this.gauge)];
+                    case 1:
+                        _d.sent();
+                        return [4 /*yield*/, curve.updateFeeData()];
+                    case 2:
+                        _d.sent();
+                        _c = mulBy1_3;
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.deposit.estimateGas(_lpTokenAmount, curve.constantOptions)];
+                    case 3:
+                        gasLimit = _c.apply(void 0, [_d.sent()]);
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.deposit(_lpTokenAmount, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_d.sent()).hash];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.unstakeEstimateGas = function (lpTokenAmount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _lpTokenAmount, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            throw Error("unstakeEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        _lpTokenAmount = parseUnits(lpTokenAmount);
+                        _c = Number;
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.withdraw.estimateGas(_lpTokenAmount, curve.constantOptions)];
+                    case 1: return [2 /*return*/, _c.apply(void 0, [_d.sent()])];
+                }
+            });
+        });
+    };
+    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 === curve.constants.ZERO_ADDRESS) {
+                            throw Error("unstake method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        _lpTokenAmount = parseUnits(lpTokenAmount);
+                        return [4 /*yield*/, curve.updateFeeData()];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.withdraw.estimateGas(_lpTokenAmount, curve.constantOptions)];
+                    case 2:
+                        gasLimit = (_c.sent()) * curve.parseUnits("200", 0) / curve.parseUnits("100", 0);
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.withdraw(_lpTokenAmount, __assign(__assign({}, 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.signerAddress;
+                        if (!address)
+                            throw Error("Need to connect wallet or pass address into args");
+                        _d = (_c = curve).formatUnits;
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.claimable_tokens(address, curve.constantOptions)];
+                    case 1: return [2 /*return*/, _d.apply(_c, [_e.sent()])];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.claimCrvEstimateGas = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.rewardsOnly())
+                            throw Error("".concat(this.name, " has Rewards-Only Gauge. Use claimRewards instead"));
+                        _c = Number;
+                        return [4 /*yield*/, curve.contracts[curve.constants.ALIASES.minter].contract.mint.estimateGas(this.gauge, curve.constantOptions)];
+                    case 1: return [2 /*return*/, _c.apply(void 0, [_d.sent()])];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.claimCrv = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var contract, gasLimit, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.rewardsOnly())
+                            throw Error("".concat(this.name, " has Rewards-Only Gauge. Use claimRewards instead"));
+                        contract = curve.contracts[curve.constants.ALIASES.minter].contract;
+                        _c = mulBy1_3;
+                        return [4 /*yield*/, contract.mint.estimateGas(this.gauge, curve.constantOptions)];
+                    case 1:
+                        gasLimit = _c.apply(void 0, [_d.sent()]);
+                        return [4 /*yield*/, contract.mint(this.gauge, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                    case 2: return [2 /*return*/, (_d.sent()).hash];
+                }
+            });
+        });
+    };
     // TODO 1. Fix aave and saave error
-    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),
+    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 === curve.constants.ZERO_ADDRESS) {
+                            throw Error("claimableRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        address = address || curve.signerAddress;
+                        if (!address)
+                            throw Error("Need to connect wallet or pass address into args");
+                        gaugeContract = 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.constantOptions)];
+                    case 3:
+                        _amount = _c.sent();
+                        rewards.push({
+                            token: rewardToken.token,
+                            symbol: rewardToken.symbol,
+                            amount: curve.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.constantOptions)];
+                    case 7:
+                        _totalAmount = _c.sent();
+                        return [4 /*yield*/, gaugeContract.claimed_rewards_for(address, curve.constantOptions)];
+                    case 8:
+                        _claimedAmount = _c.sent();
+                        rewards.push({
+                            token: rewardToken.token,
+                            symbol: rewardToken.symbol,
+                            amount: curve.formatUnits(_totalAmount.sub(_claimedAmount), rewardToken.decimals),
+                        });
+                        _c.label = 9;
+                    case 9: return [2 /*return*/, rewards];
+                }
             });
-        }
-        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);
-    }
+        });
+    };
+    PoolTemplate.prototype.claimRewardsEstimateGas = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var gaugeContract, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            throw Error("claimRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        gaugeContract = curve.contracts[this.gauge].contract;
+                        if (!("claim_rewards()" in gaugeContract))
+                            throw Error("".concat(this.name, " pool doesn't have such method"));
+                        _c = Number;
+                        return [4 /*yield*/, gaugeContract.claim_rewards.estimateGas(curve.constantOptions)];
+                    case 1: return [2 /*return*/, _c.apply(void 0, [_d.sent()])];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.claimRewards = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var gaugeContract, gasLimit, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            throw Error("claimRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        gaugeContract = curve.contracts[this.gauge].contract;
+                        if (!("claim_rewards()" in gaugeContract))
+                            throw Error("".concat(this.name, " pool doesn't have such method"));
+                        _c = mulBy1_3;
+                        return [4 /*yield*/, gaugeContract.claim_rewards.estimateGas(curve.constantOptions)];
+                    case 1:
+                        gasLimit = _c.apply(void 0, [_d.sent()]);
+                        return [4 /*yield*/, gaugeContract.claim_rewards(__assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                    case 2: return [2 /*return*/, (_d.sent()).hash];
+                }
+            });
+        });
+    };
+    // ---------------- 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 === curve.constants.ZERO_ADDRESS) {
+                            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 === curve.constants.ZERO_ADDRESS) {
+                            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 === curve.constants.ZERO_ADDRESS) {
+                            throw Error("depositAndStakeIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, hasAllowance(this.underlyingCoinAddresses, amounts, curve.signerAddress, curve.constants.ALIASES.deposit_and_stake)];
+                    case 1:
+                        coinsAllowance = _c.sent();
+                        gaugeContract = curve.contracts[this.gauge].contract;
+                        if (!('approved_to_deposit' in gaugeContract)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, 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, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            throw Error("depositAndStakeApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, ensureAllowanceEstimateGas(this.underlyingCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake)];
+                    case 1:
+                        approveCoinsGas = _d.sent();
+                        gaugeContract = curve.contracts[this.gauge].contract;
+                        if (!('approved_to_deposit' in gaugeContract)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions)];
+                    case 2:
+                        gaugeAllowance = _d.sent();
+                        if (!!gaugeAllowance) return [3 /*break*/, 4];
+                        _c = Number;
+                        return [4 /*yield*/, gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions)];
+                    case 3:
+                        approveGaugeGas = _c.apply(void 0, [_d.sent()]);
+                        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, _c, approveGaugeTx;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            throw Error("depositAndStakeApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, ensureAllowance(this.underlyingCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake)];
+                    case 1:
+                        approveCoinsTx = _d.sent();
+                        gaugeContract = curve.contracts[this.gauge].contract;
+                        if (!('approved_to_deposit' in gaugeContract)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions)];
+                    case 2:
+                        gaugeAllowance = _d.sent();
+                        if (!!gaugeAllowance) return [3 /*break*/, 5];
+                        _c = mulBy1_3;
+                        return [4 /*yield*/, gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions)];
+                    case 3:
+                        gasLimit = _c.apply(void 0, [_d.sent()]);
+                        return [4 /*yield*/, gaugeContract.set_approve_deposit(curve.constants.ALIASES.deposit_and_stake, true, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                    case 4:
+                        approveGaugeTx = (_d.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 === curve.constants.ZERO_ADDRESS) {
+                            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 === curve.constants.ZERO_ADDRESS) {
+                            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()];
+                }
+            });
+        });
+    };
     // ---------------- DEPOSIT & STAKE WRAPPED ----------------
-    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;
-    }
+    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 === curve.constants.ZERO_ADDRESS) {
+                            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 === curve.constants.ZERO_ADDRESS) {
+                            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 === curve.constants.ZERO_ADDRESS) {
+                            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*/, hasAllowance(this.wrappedCoinAddresses, amounts, curve.signerAddress, curve.constants.ALIASES.deposit_and_stake)];
+                    case 1:
+                        coinsAllowance = _c.sent();
+                        gaugeContract = curve.contracts[this.gauge].contract;
+                        if (!('approved_to_deposit' in gaugeContract)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, 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, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            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*/, ensureAllowanceEstimateGas(this.wrappedCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake)];
+                    case 1:
+                        approveCoinsGas = _d.sent();
+                        gaugeContract = curve.contracts[this.gauge].contract;
+                        if (!('approved_to_deposit' in gaugeContract)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions)];
+                    case 2:
+                        gaugeAllowance = _d.sent();
+                        if (!!gaugeAllowance) return [3 /*break*/, 4];
+                        _c = Number;
+                        return [4 /*yield*/, gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions)];
+                    case 3:
+                        approveGaugeGas = _c.apply(void 0, [_d.sent()]);
+                        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, _c, approveGaugeTx;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.gauge === curve.constants.ZERO_ADDRESS) {
+                            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*/, ensureAllowance(this.wrappedCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake)];
+                    case 1:
+                        approveCoinsTx = _d.sent();
+                        gaugeContract = curve.contracts[this.gauge].contract;
+                        if (!('approved_to_deposit' in gaugeContract)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions)];
+                    case 2:
+                        gaugeAllowance = _d.sent();
+                        if (!!gaugeAllowance) return [3 /*break*/, 5];
+                        _c = mulBy1_3;
+                        return [4 /*yield*/, gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions)];
+                    case 3:
+                        gasLimit = _c.apply(void 0, [_d.sent()]);
+                        return [4 /*yield*/, gaugeContract.set_approve_deposit(curve.constants.ALIASES.deposit_and_stake, true, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                    case 4:
+                        approveGaugeTx = (_d.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 === curve.constants.ZERO_ADDRESS) {
+                            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 === curve.constants.ZERO_ADDRESS) {
+                            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 parseUnits(amount, decimals[i]); });
+                        contract = curve.contracts[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 = curve).parseUnits;
+                        return [4 /*yield*/, this.depositAndStakeExpected(amounts)];
+                    case 13:
+                        _j = _l.apply(_k, [_q.sent()]);
+                        return [3 /*break*/, 16];
+                    case 14:
+                        _o = (_m = curve).parseUnits;
+                        return [4 /*yield*/, this.depositAndStakeWrappedExpected(amounts)];
+                    case 15:
+                        _j = _o.apply(_m, [_q.sent()]);
+                        _q.label = 16;
+                    case 16:
+                        _expectedLpTokenAmount = _j;
+                        minAmountBN = toBN(_expectedLpTokenAmount).times(100 - slippage).div(100);
+                        _minMintAmount = fromBN(minAmountBN);
+                        ethIndex = getEthIndex(coinAddresses);
+                        value = _amounts[ethIndex] || curve.parseUnits("0");
+                        maxCoins = curve.chainId === 137 ? 6 : 5;
+                        for (i = 0; i < maxCoins; i++) {
+                            coinAddresses[i] = coinAddresses[i] || curve.constants.ZERO_ADDRESS;
+                            _amounts[i] = _amounts[i] || curve.parseUnits("0");
+                        }
+                        return [4 /*yield*/, 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, __assign(__assign({}, curve.constantOptions), { value: value }))];
+                    case 17:
+                        _gas = (_q.sent());
+                        if (estimateGas)
+                            return [2 /*return*/, Number(_gas)];
+                        return [4 /*yield*/, curve.updateFeeData()];
+                    case 18:
+                        _q.sent();
+                        gasLimit = _gas * curve.parseUnits("200", 0) / curve.parseUnits("100", 0);
+                        return [4 /*yield*/, contract.deposit_and_stake(depositAddress, this.lpToken, this.gauge, coins.length, coinAddresses, _amounts, _minMintAmount, useUnderlying, this.isMetaFactory && isUnderlying ? this.address : curve.constants.ZERO_ADDRESS, __assign(__assign({}, curve.options), { gasLimit: gasLimit, value: value }))];
+                    case 19: return [2 /*return*/, (_q.sent()).hash];
+                }
+            });
+        });
+    };
     // ---------------- WITHDRAW ----------------
     // OVERRIDE
-    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);
-    }
+    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*/, hasAllowance([this.lpToken], [lpTokenAmount], 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*/, 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*/, ensureAllowance([this.lpToken], [lpTokenAmount], this.zap)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawEstimateGas(lpTokenAmount) {
-        throw Error(`withdraw method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async withdraw(lpTokenAmount, slippage = 0.5) {
-        throw Error(`withdraw method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- WITHDRAW WRAPPED ----------------
     // OVERRIDE
-    async withdrawWrappedExpected(lpTokenAmount) {
-        throw Error(`withdrawWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawWrappedEstimateGas(lpTokenAmount) {
-        throw Error(`withdrawWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawWrapped(lpTokenAmount, slippage = 0.5) {
-        throw Error(`withdrawWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- WITHDRAW IMBALANCE ----------------
-    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 [];
-    }
+    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(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 parseUnits(amount, _this.underlyingDecimals[i]); });
+                        return [4 /*yield*/, this._calcLpTokenAmount(_amounts, false)];
+                    case 1:
+                        _maxBurnAmount = (_c.sent()) * curve.parseUnits("101", 0) / curve.parseUnits("100", 0);
+                        return [4 /*yield*/, hasAllowance([this.lpToken], [curve.formatUnits(_maxBurnAmount, 18)], 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 parseUnits(amount, _this.underlyingDecimals[i]); });
+                        return [4 /*yield*/, this._calcLpTokenAmount(_amounts, false)];
+                    case 1:
+                        _maxBurnAmount = (_c.sent()) * curve.parseUnits("101", 0) / curve.parseUnits("100", 0);
+                        return [4 /*yield*/, ensureAllowanceEstimateGas([this.lpToken], [curve.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 parseUnits(amount, _this.underlyingDecimals[i]); });
+                        return [4 /*yield*/, this._calcLpTokenAmount(_amounts, false)];
+                    case 1:
+                        _maxBurnAmount = (_c.sent()) * curve.parseUnits("101", 0) / curve.parseUnits("100", 0);
+                        return [4 /*yield*/, ensureAllowance([this.lpToken], [curve.formatUnits(_maxBurnAmount, 18)], this.zap)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                    case 3: return [2 /*return*/, []];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawImbalanceEstimateGas(amounts) {
-        throw Error(`withdrawImbalance method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawImbalance(amounts, slippage = 0.5) {
-        throw Error(`withdrawImbalance method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- WITHDRAW IMBALANCE WRAPPED ----------------
-    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);
-    }
+    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(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)];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawImbalanceWrappedEstimateGas(amounts) {
-        throw Error(`withdrawImbalanceWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawImbalanceWrapped(amounts, slippage = 0.5) {
-        throw Error(`withdrawImbalanceWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- WITHDRAW ONE COIN ----------------
     // OVERRIDE
-    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);
-    }
+    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 = parseUnits(lpTokenAmount);
+                        return [4 /*yield*/, this._withdrawOneCoinExpected(_lpTokenAmount, i)];
+                    case 1:
+                        _expected = _c.sent();
+                        return [2 /*return*/, curve.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*/, hasAllowance([this.lpToken], [lpTokenAmount], 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*/, 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*/, ensureAllowance([this.lpToken], [lpTokenAmount], this.zap)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawOneCoinEstimateGas(lpTokenAmount, coin) {
-        throw Error(`withdrawOneCoin method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawOneCoin(lpTokenAmount, coin, slippage = 0.5) {
-        throw Error(`withdrawOneCoin method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- WITHDRAW ONE COIN WRAPPED ----------------
     // OVERRIDE
-    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);
-    }
+    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 = parseUnits(lpTokenAmount);
+                        return [4 /*yield*/, this._withdrawOneCoinWrappedExpected(_lpTokenAmount, i)];
+                    case 1:
+                        _expected = _c.sent();
+                        return [2 /*return*/, curve.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)];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawOneCoinWrappedEstimateGas(lpTokenAmount, coin) {
-        throw Error(`withdrawOneCoinWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async withdrawOneCoinWrapped(lpTokenAmount, coin, slippage = 0.5) {
-        throw Error(`withdrawOneCoinWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- WALLET BALANCES ----------------
-    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);
+    PoolTemplate.prototype.walletBalances = 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);
-        }
-    }
-    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:
+                        if (!(this.gauge === curve.constants.ZERO_ADDRESS)) 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];
         }
-        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:
+                        if (!(this.gauge === curve.constants.ZERO_ADDRESS)) 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];
         }
-    }
-    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 ----------------
-    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));
+        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];
         }
-        else {
-            totalLp = curve.formatUnits(await curve.contracts[this.lpToken].contract.totalSupply(curve.constantOptions));
+        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];
         }
-        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',
-        };
-    }
+        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()];
+                }
+            });
+        });
+    };
+    // ---------------- 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 = BN(lpBalances.lpToken);
+                        if ('gauge' in lpBalances)
+                            lpTotalBalanceBN = lpTotalBalanceBN.plus(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.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.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*/, _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 = BN(apyData.week).div(100);
+                        _c = 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 !== curve.constants.ZERO_ADDRESS;
+                        address = address || 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 = BN(userLpBalance.lpToken);
+                        if (withGauge)
+                            userLpTotalBalanceBN = userLpTotalBalanceBN.plus(BN(userLpBalance.gauge));
+                        if (!withGauge) return [3 /*break*/, 3];
+                        return [4 /*yield*/, curve.multicallProvider.all([
+                                curve.contracts[this.lpToken].multicallContract.totalSupply(),
+                                curve.contracts[this.gauge].multicallContract.totalSupply(),
+                            ])];
+                    case 2:
+                        _e = (_f.sent()).map(function (_supply) { return curve.formatUnits(_supply); }), totalLp = _e[0], gaugeLp = _e[1];
+                        return [3 /*break*/, 5];
+                    case 3:
+                        _d = (_c = curve).formatUnits;
+                        return [4 /*yield*/, curve.contracts[this.lpToken].contract.totalSupply(curve.constantOptions)];
+                    case 4:
+                        totalLp = _d.apply(_c, [_f.sent()]);
+                        _f.label = 5;
+                    case 5: return [2 /*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 ----------------
-    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() {
+    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.contracts[contractAddress].contract;
+                        if (!('get_dy_underlying' in contract)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, contract.get_dy_underlying(i, j, _amount, 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.constantOptions)];
+                    case 3: // atricrypto3 based metapools
+                    return [2 /*return*/, _c.sent()];
+                    case 4: return [4 /*yield*/, contract.get_dy(i, j, _amount, 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 = parseUnits(amount, this.underlyingDecimals[i]);
+                        return [4 /*yield*/, this._swapExpected(i, j, _amount)];
+                    case 1:
+                        _expected = _c.sent();
+                        return [2 /*return*/, curve.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 = parseUnits(amount, inputCoinDecimals);
+                        return [4 /*yield*/, this._swapExpected(i, j, _amount)];
+                    case 1:
+                        _output = _d.sent();
+                        smallAmountIntBN = _get_small_x(_amount, _output, inputCoinDecimals, outputCoinDecimals);
+                        amountIntBN = toBN(_amount, 0);
+                        if (smallAmountIntBN.gte(amountIntBN))
+                            return [2 /*return*/, 0];
+                        _smallAmount = fromBN(smallAmountIntBN.div(Math.pow(10, inputCoinDecimals)), inputCoinDecimals);
+                        return [4 /*yield*/, this._swapExpected(i, j, _smallAmount)];
+                    case 2:
+                        _smallOutput = _d.sent();
+                        priceImpactBN = _get_price_impact(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
+                        return [2 /*return*/, Number(_cutZeros(priceImpactBN.toFixed(4)))];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype._swapContractAddress = function () {
         return (this.isCrypto && this.isMeta) || (this.isMetaFactory && (new PoolTemplate(this.basePool).isLending)) ? this.zap : this.address;
-    }
-    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);
-    }
+    };
+    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*/, hasAllowance([this.underlyingCoinAddresses[i]], [amount], 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*/, 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*/, ensureAllowance([this.underlyingCoinAddresses[i]], [amount], contractAddress)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async swapEstimateGas(inputCoin, outputCoin, amount) {
-        throw Error(`swap method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async swap(inputCoin, outputCoin, amount, slippage = 0.5) {
-        throw Error(`swap method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // ---------------- SWAP WRAPPED ----------------
-    async _swapWrappedExpected(i, j, _amount) {
-        return await curve.contracts[this.address].contract.get_dy(i, j, _amount, curve.constantOptions);
-    }
+    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.contracts[this.address].contract.get_dy(i, j, _amount, curve.constantOptions)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    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)));
-    }
+    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 = parseUnits(amount, inputCoinDecimals);
+                        return [4 /*yield*/, this._swapWrappedExpected(i, j, _amount)];
+                    case 1:
+                        _output = _d.sent();
+                        smallAmountIntBN = _get_small_x(_amount, _output, inputCoinDecimals, outputCoinDecimals);
+                        amountIntBN = toBN(_amount, 0);
+                        if (smallAmountIntBN.gte(amountIntBN))
+                            return [2 /*return*/, 0];
+                        _smallAmount = fromBN(smallAmountIntBN.div(Math.pow(10, inputCoinDecimals)), inputCoinDecimals);
+                        return [4 /*yield*/, this._swapWrappedExpected(i, j, _smallAmount)];
+                    case 2:
+                        _smallOutput = _d.sent();
+                        priceImpactBN = _get_price_impact(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
+                        return [2 /*return*/, Number(_cutZeros(priceImpactBN.toFixed(4)))];
+                }
+            });
+        });
+    };
     // OVERRIDE
-    async swapWrappedIsApproved(inputCoin, amount) {
-        throw Error(`swapWrappedIsApproved method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async swapWrappedApproveEstimateGas(inputCoin, amount) {
-        throw Error(`swapWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async swapWrappedApprove(inputCoin, amount) {
-        throw Error(`swapWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async swapWrappedEstimateGas(inputCoin, outputCoin, amount) {
-        throw Error(`swapWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
+    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, ")"));
+            });
+        });
+    };
     // OVERRIDE
-    async swapWrapped(inputCoin, outputCoin, amount, slippage = 0.5) {
-        throw Error(`swapWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-    }
-}
+    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;
+}());
+export { PoolTemplate };