@curvefi/api 1.4.2 → 1.5.0

package/lib/pools.js

@@ -126,6 +126,17 @@ var Pool = /** @class */ (function () {
                 });
             });
         };
+        this.getVirtualPrice = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _virtualPrice;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, curve_1.curve.contracts[this.swap].contract.get_virtual_price(curve_1.curve.constantOptions)];
+                    case 1:
+                        _virtualPrice = _a.sent();
+                        return [2 /*return*/, ethers_1.ethers.utils.formatUnits(_virtualPrice)];
+                }
+            });
+        }); };
         this.addLiquidityExpected = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -134,19 +145,52 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.addLiquidityIsApproved = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            var spender;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spender = (['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) || this.isMeta) ? this.zap : this.swap;
+                        return [4 /*yield*/, (0, utils_1.hasAllowance)(this.underlyingCoinAddresses, amounts, curve_1.curve.signerAddress, spender)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.addLiquidityApproveEstimateGas = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            var spender;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spender = (['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) || this.isMeta) ? this.zap : this.swap;
+                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)(this.underlyingCoinAddresses, amounts, spender)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.addLiquidityApprove = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            var spender;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spender = (['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) || this.isMeta) ? this.zap : this.swap;
+                        return [4 /*yield*/, (0, utils_1.ensureAllowance)(this.underlyingCoinAddresses, amounts, spender)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         this.addLiquidityEstimateGas = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
-            var balances, _a, _b, i, _amounts;
+            var balances, _a, _c, i, _amounts;
             var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         if (amounts.length !== this.underlyingCoinAddresses.length) {
                             throw Error(this.name + " pool has " + this.underlyingCoinAddresses.length + " coins (amounts provided for " + amounts.length + ")");
                         }
-                        _b = (_a = Object).values;
+                        _c = (_a = Object).values;
                         return [4 /*yield*/, this.underlyingCoinBalances()];
                     case 1:
-                        balances = _b.apply(_a, [_c.sent()]);
+                        balances = _c.apply(_a, [_d.sent()]);
                         for (i = 0; i < balances.length; i++) {
                             if (Number(balances[i]) < Number(amounts[i])) {
                                 throw Error("Not enough " + this.underlyingCoins[i] + ". Actual: " + balances[i] + ", required: " + amounts[i]);
@@ -154,7 +198,7 @@ var Pool = /** @class */ (function () {
                         }
                         return [4 /*yield*/, (0, utils_1.hasAllowance)(this.underlyingCoinAddresses, amounts, curve_1.curve.signerAddress, this.zap || this.swap)];
                     case 2:
-                        if (!(_c.sent())) {
+                        if (!(_d.sent())) {
                             throw Error("Token allowance is needed to estimate gas");
                         }
                         _amounts = amounts.map(function (amount, i) {
@@ -162,19 +206,60 @@ var Pool = /** @class */ (function () {
                         });
                         if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name)) return [3 /*break*/, 4];
                         return [4 /*yield*/, this._addLiquidityZap(_amounts, true)];
-                    case 3: return [2 /*return*/, _c.sent()];
+                    case 3: return [2 /*return*/, _d.sent()];
                     case 4:
                         if (!['aave', 'saave', 'ib'].includes(this.name)) return [3 /*break*/, 6];
                         return [4 /*yield*/, this._addLiquidity(_amounts, true, true)];
-                    case 5: return [2 /*return*/, _c.sent()];
+                    case 5: return [2 /*return*/, _d.sent()];
                     case 6:
                         if (!this.isMeta) return [3 /*break*/, 8];
                         return [4 /*yield*/, this._addLiquidityMetaZap(_amounts, true)];
-                    case 7: return [2 /*return*/, _c.sent()];
+                    case 7: return [2 /*return*/, _d.sent()];
                     case 8: return [4 /*yield*/, this._addLiquiditySwap(_amounts, true)];
                     case 9: 
                     // Plain pools
-                    return [2 /*return*/, _c.sent()];
+                    return [2 /*return*/, _d.sent()];
+                }
+            });
+        }); };
+        this.balancedAmounts = function () { return __awaiter(_this, void 0, void 0, function () {
+            var swapContract, contractCalls, _poolWrappedBalances, _poolUnderlyingBalances, _poolMetaCoinBalance, _poolUnderlyingBalance, basePool, _basePoolExpectedAmounts, _rates_1, poolBalances, walletBalances, _a, _c;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        swapContract = curve_1.curve.contracts[this.swap].multicallContract;
+                        contractCalls = this.coins.map(function (_, i) { return swapContract.balances(i); });
+                        return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
+                    case 1:
+                        _poolWrappedBalances = (_d.sent());
+                        _poolUnderlyingBalances = [];
+                        if (!this.isMeta) return [3 /*break*/, 3];
+                        _poolWrappedBalances.unshift(_poolWrappedBalances.pop());
+                        _poolMetaCoinBalance = _poolWrappedBalances[0], _poolUnderlyingBalance = _poolWrappedBalances.slice(1);
+                        basePool = new Pool(this.basePool);
+                        return [4 /*yield*/, basePool._calcExpectedAmounts(_poolMetaCoinBalance)];
+                    case 2:
+                        _basePoolExpectedAmounts = _d.sent();
+                        _poolUnderlyingBalances = __spreadArray(__spreadArray([], _poolUnderlyingBalance, true), _basePoolExpectedAmounts, true);
+                        return [3 /*break*/, 6];
+                    case 3:
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax', 'aave', 'saave', 'ib'].includes(this.name)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this._getRates()];
+                    case 4:
+                        _rates_1 = _d.sent();
+                        _poolUnderlyingBalances = _poolWrappedBalances.map(function (_b, i) { return _b.mul(_rates_1[i]).div(ethers_1.ethers.BigNumber.from(10).pow(18)); });
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _poolUnderlyingBalances = _poolWrappedBalances;
+                        _d.label = 6;
+                    case 6:
+                        poolBalances = _poolUnderlyingBalances.map(function (_b, i) { return Number(ethers_1.ethers.utils.formatUnits(_b, _this.underlyingDecimals[i])); });
+                        _c = (_a = Object).values;
+                        return [4 /*yield*/, this.underlyingCoinBalances()];
+                    case 7:
+                        walletBalances = _c.apply(_a, [_d.sent()]).map(Number);
+                        return [2 /*return*/, this._balancedAmounts(poolBalances, walletBalances)];
                 }
             });
         }); };
@@ -211,6 +296,25 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.balancedWrappedAmounts = function (address) { return __awaiter(_this, void 0, void 0, function () {
+            var swapContract, contractCalls, poolBalances, walletBalances, _a, _c;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        swapContract = curve_1.curve.contracts[this.swap].multicallContract;
+                        contractCalls = this.coins.map(function (_, i) { return swapContract.balances(i); });
+                        return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
+                    case 1:
+                        poolBalances = (_d.sent()).map(function (_b, i) { return Number(ethers_1.ethers.utils.formatUnits(_b, _this.decimals[i])); });
+                        _c = (_a = Object).values;
+                        return [4 /*yield*/, this.coinBalances(address ? [address] : [])];
+                    case 2:
+                        walletBalances = _c.apply(_a, [_d.sent()]).map(Number);
+                        return [2 /*return*/, this._balancedAmounts(poolBalances, walletBalances)];
+                }
+            });
+        }); };
         this.addLiquidityWrappedExpected = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -219,27 +323,51 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.addLiquidityWrappedIsApproved = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, utils_1.hasAllowance)(this.coinAddresses, amounts, curve_1.curve.signerAddress, this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.addLiquidityWrappedApproveEstimateGas = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)(this.coinAddresses, amounts, this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.addLiquidityWrappedApprove = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, utils_1.ensureAllowance)(this.coinAddresses, amounts, this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         this.addLiquidityWrappedEstimateGas = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
-            var balances, _a, _b, i, _amounts;
+            var balances, _a, _c, i, _amounts;
             var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         if (amounts.length !== this.coinAddresses.length) {
                             throw Error(this.name + " pool has " + this.coinAddresses.length + " coins (amounts provided for " + amounts.length + ")");
                         }
-                        _b = (_a = Object).values;
+                        _c = (_a = Object).values;
                         return [4 /*yield*/, this.coinBalances()];
                     case 1:
-                        balances = _b.apply(_a, [_c.sent()]);
+                        balances = _c.apply(_a, [_d.sent()]);
                         for (i = 0; i < balances.length; i++) {
                             if (Number(balances[i]) < Number(amounts[i])) {
                                 throw Error("Not enough " + this.coins[i] + ". Actual: " + balances[i] + ", required: " + amounts[i]);
                             }
                         }
-                        return [4 /*yield*/, (0, utils_1.hasAllowance)(this.coinAddresses, amounts, curve_1.curve.signerAddress, this.zap || this.swap)];
+                        return [4 /*yield*/, (0, utils_1.hasAllowance)(this.coinAddresses, amounts, curve_1.curve.signerAddress, this.swap)];
                     case 2:
-                        if (!(_c.sent())) {
+                        if (!(_d.sent())) {
                             throw Error("Token allowance is needed to estimate gas");
                         }
                         _amounts = amounts.map(function (amount, i) {
@@ -247,11 +375,11 @@ var Pool = /** @class */ (function () {
                         });
                         if (!['aave', 'saave', 'ib'].includes(this.name)) return [3 /*break*/, 4];
                         return [4 /*yield*/, this._addLiquidity(_amounts, false, true)];
-                    case 3: return [2 /*return*/, _c.sent()];
+                    case 3: return [2 /*return*/, _d.sent()];
                     case 4: return [4 /*yield*/, this._addLiquiditySwap(_amounts, true)];
                     case 5: 
                     // Lending pools with zap and metapools
-                    return [2 /*return*/, _c.sent()];
+                    return [2 /*return*/, _d.sent()];
                 }
             });
         }); };
@@ -306,13 +434,46 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.removeLiquidityIsApproved = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) && !this.isMeta)
+                            return [2 /*return*/, true];
+                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.removeLiquidityApproveEstimateGas = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) && !this.isMeta)
+                            return [2 /*return*/, 0];
+                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [lpTokenAmount], this.zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.removeLiquidityApprove = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) && !this.isMeta)
+                            return [2 /*return*/, []];
+                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [lpTokenAmount], this.zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         this.removeLiquidityEstimateGas = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
             var lpTokenBalance, _a, _lpTokenAmount;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0: return [4 /*yield*/, this.lpTokenBalances()];
                     case 1:
-                        lpTokenBalance = (_b.sent())['lpToken'];
+                        lpTokenBalance = (_c.sent())['lpToken'];
                         if (Number(lpTokenBalance) < Number(lpTokenAmount)) {
                             throw Error("Not enough LP tokens. Actual: " + lpTokenBalance + ", required: " + lpTokenAmount);
                         }
@@ -320,8 +481,8 @@ var Pool = /** @class */ (function () {
                         if (!_a) return [3 /*break*/, 3];
                         return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.zap)];
                     case 2:
-                        _a = !(_b.sent());
-                        _b.label = 3;
+                        _a = !(_c.sent());
+                        _c.label = 3;
                     case 3:
                         if (_a) {
                             throw Error("Token allowance is needed to estimate gas");
@@ -329,17 +490,17 @@ var Pool = /** @class */ (function () {
                         _lpTokenAmount = ethers_1.ethers.utils.parseUnits(lpTokenAmount);
                         if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name)) return [3 /*break*/, 5];
                         return [4 /*yield*/, this._removeLiquidityZap(_lpTokenAmount, true)];
-                    case 4: return [2 /*return*/, _b.sent()];
+                    case 4: return [2 /*return*/, _c.sent()];
                     case 5:
                         if (!['aave', 'saave', 'ib'].includes(this.name)) return [3 /*break*/, 7];
                         return [4 /*yield*/, this._removeLiquidity(_lpTokenAmount, true, true)];
-                    case 6: return [2 /*return*/, _b.sent()];
+                    case 6: return [2 /*return*/, _c.sent()];
                     case 7:
                         if (!this.isMeta) return [3 /*break*/, 9];
                         return [4 /*yield*/, this._removeLiquidityMetaZap(_lpTokenAmount, true)];
-                    case 8: return [2 /*return*/, _b.sent()];
+                    case 8: return [2 /*return*/, _c.sent()];
                     case 9: return [4 /*yield*/, this._removeLiquiditySwap(_lpTokenAmount, true)];
-                    case 10: return [2 /*return*/, _b.sent()];
+                    case 10: return [2 /*return*/, _c.sent()];
                 }
             });
         }); };
@@ -427,17 +588,89 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.removeLiquidityImbalanceIsApproved = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            var _amounts, _maxBurnAmount, _maxBurnAmount;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amounts = amounts.map(function (amount, i) { return ethers_1.ethers.utils.parseUnits(amount, _this.underlyingDecimals[i]); });
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this._calcLpTokenAmountWithUnderlying(_amounts, false)];
+                    case 1:
+                        _maxBurnAmount = (_a.sent()).mul(101).div(100);
+                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], curve_1.curve.signerAddress, this.zap)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        if (!this.isMeta) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this._calcLpTokenAmountZap(_amounts, false)];
+                    case 4:
+                        _maxBurnAmount = (_a.sent()).mul(101).div(100);
+                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], curve_1.curve.signerAddress, this.zap)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                    case 6: return [2 /*return*/, true];
+                }
+            });
+        }); };
+        this.removeLiquidityImbalanceApproveEstimateGas = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            var _amounts, _maxBurnAmount, _maxBurnAmount;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amounts = amounts.map(function (amount, i) { return ethers_1.ethers.utils.parseUnits(amount, _this.underlyingDecimals[i]); });
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this._calcLpTokenAmountWithUnderlying(_amounts, false)];
+                    case 1:
+                        _maxBurnAmount = (_a.sent()).mul(101).div(100);
+                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], this.zap)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        if (!this.isMeta) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this._calcLpTokenAmountZap(_amounts, false)];
+                    case 4:
+                        _maxBurnAmount = (_a.sent()).mul(101).div(100);
+                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], this.zap)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                    case 6: return [2 /*return*/, 0];
+                }
+            });
+        }); };
+        this.removeLiquidityImbalanceApprove = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
+            var _amounts, _maxBurnAmount, _maxBurnAmount;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amounts = amounts.map(function (amount, i) { return ethers_1.ethers.utils.parseUnits(amount, _this.underlyingDecimals[i]); });
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this._calcLpTokenAmountWithUnderlying(_amounts, false)];
+                    case 1:
+                        _maxBurnAmount = (_a.sent()).mul(101).div(100);
+                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], this.zap)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        if (!this.isMeta) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this._calcLpTokenAmountZap(_amounts, false)];
+                    case 4:
+                        _maxBurnAmount = (_a.sent()).mul(101).div(100);
+                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [ethers_1.ethers.utils.formatUnits(_maxBurnAmount, 18)], this.zap)];
+                    case 5: return [2 /*return*/, _a.sent()];
+                    case 6: return [2 /*return*/, []];
+                }
+            });
+        }); };
         this.removeLiquidityImbalanceEstimateGas = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
             var lpTokenAmount, lpTokenBalance, _a, _amounts;
             var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0: return [4 /*yield*/, this.removeLiquidityImbalanceExpected(amounts)];
                     case 1:
-                        lpTokenAmount = _b.sent();
+                        lpTokenAmount = _c.sent();
                         return [4 /*yield*/, this.lpTokenBalances()];
                     case 2:
-                        lpTokenBalance = (_b.sent())['lpToken'];
+                        lpTokenBalance = (_c.sent())['lpToken'];
                         if (Number(lpTokenBalance) < Number(lpTokenAmount)) {
                             throw Error("Not enough LP tokens. Actual: " + lpTokenBalance + ", required: " + lpTokenAmount);
                         }
@@ -445,8 +678,8 @@ var Pool = /** @class */ (function () {
                         if (!_a) return [3 /*break*/, 4];
                         return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.zap)];
                     case 3:
-                        _a = !(_b.sent());
-                        _b.label = 4;
+                        _a = !(_c.sent());
+                        _c.label = 4;
                     case 4:
                         if (_a) {
                             throw Error("Token allowance is needed to estimate gas");
@@ -454,17 +687,17 @@ var Pool = /** @class */ (function () {
                         _amounts = amounts.map(function (amount, i) { return ethers_1.ethers.utils.parseUnits(amount, _this.underlyingDecimals[i]); });
                         if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name)) return [3 /*break*/, 6];
                         return [4 /*yield*/, this._removeLiquidityImbalanceZap(_amounts, true)];
-                    case 5: return [2 /*return*/, _b.sent()];
+                    case 5: return [2 /*return*/, _c.sent()];
                     case 6:
                         if (!['aave', 'saave', 'ib'].includes(this.name)) return [3 /*break*/, 8];
                         return [4 /*yield*/, this._removeLiquidityImbalance(_amounts, true, true)];
-                    case 7: return [2 /*return*/, _b.sent()];
+                    case 7: return [2 /*return*/, _c.sent()];
                     case 8:
                         if (!this.isMeta) return [3 /*break*/, 10];
                         return [4 /*yield*/, this._removeLiquidityImbalanceMetaZap(_amounts, true)];
-                    case 9: return [2 /*return*/, _b.sent()];
+                    case 9: return [2 /*return*/, _c.sent()];
                     case 10: return [4 /*yield*/, this._removeLiquidityImbalanceSwap(_amounts, true)];
-                    case 11: return [2 /*return*/, _b.sent()];
+                    case 11: return [2 /*return*/, _c.sent()];
                 }
             });
         }); };
@@ -572,13 +805,46 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.removeLiquidityOneCoinIsApproved = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) && !(this.name === 'susd') && !this.isMeta)
+                            return [2 /*return*/, true];
+                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.removeLiquidityOneCoinApproveEstimateGas = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) && !(this.name === 'susd') && !this.isMeta)
+                            return [2 /*return*/, 0];
+                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [lpTokenAmount], this.zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.removeLiquidityOneCoinApprove = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) && !(this.name === 'susd') && !this.isMeta)
+                            return [2 /*return*/, []];
+                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [lpTokenAmount], this.zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         this.removeLiquidityOneCoinEstimateGas = function (lpTokenAmount, coin) { return __awaiter(_this, void 0, void 0, function () {
             var lpTokenBalance, _a, i, _lpTokenAmount;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0: return [4 /*yield*/, this.lpTokenBalances()];
                     case 1:
-                        lpTokenBalance = (_b.sent())['lpToken'];
+                        lpTokenBalance = (_c.sent())['lpToken'];
                         if (Number(lpTokenBalance) < Number(lpTokenAmount)) {
                             throw Error("Not enough LP tokens. Actual: " + lpTokenBalance + ", required: " + lpTokenAmount);
                         }
@@ -586,8 +852,8 @@ var Pool = /** @class */ (function () {
                         if (!_a) return [3 /*break*/, 3];
                         return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.zap)];
                     case 2:
-                        _a = !(_b.sent());
-                        _b.label = 3;
+                        _a = !(_c.sent());
+                        _c.label = 3;
                     case 3:
                         if (_a) {
                             throw Error("Token allowance is needed to estimate gas");
@@ -596,15 +862,15 @@ var Pool = /** @class */ (function () {
                         _lpTokenAmount = ethers_1.ethers.utils.parseUnits(lpTokenAmount);
                         if (!(['compound', 'usdt', 'y', 'busd', 'pax'].includes(this.name) || this.name === 'susd' || this.isMeta)) return [3 /*break*/, 5];
                         return [4 /*yield*/, this._removeLiquidityOneCoinZap(_lpTokenAmount, i, true)];
-                    case 4: return [2 /*return*/, _b.sent()];
+                    case 4: return [2 /*return*/, _c.sent()];
                     case 5:
                         if (!['aave', 'saave', 'ib'].includes(this.name)) return [3 /*break*/, 7];
                         return [4 /*yield*/, this._removeLiquidityOneCoin(_lpTokenAmount, i, true, true)];
-                    case 6: return [2 /*return*/, _b.sent()];
+                    case 6: return [2 /*return*/, _c.sent()];
                     case 7: return [4 /*yield*/, this._removeLiquidityOneCoinSwap(_lpTokenAmount, i, true)];
                     case 8: 
                     // Plain pools
-                    return [2 /*return*/, _b.sent()];
+                    return [2 /*return*/, _c.sent()];
                 }
             });
         }); };
@@ -696,6 +962,30 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.gaugeDepositIsApproved = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, utils_1.hasAllowance)([this.lpToken], [lpTokenAmount], curve_1.curve.signerAddress, this.gauge)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.gaugeDepositApproveEstimateGas = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.lpToken], [lpTokenAmount], this.gauge)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.gaugeDepositApprove = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.lpToken], [lpTokenAmount], this.gauge)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         this.gaugeDepositEstimateGas = function (lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
             var _lpTokenAmount;
             return __generator(this, function (_a) {
@@ -749,10 +1039,10 @@ var Pool = /** @class */ (function () {
                 addresses[_a] = arguments[_a];
             }
             return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0: return [4 /*yield*/, this._balances.apply(this, __spreadArray([__spreadArray(__spreadArray(['lpToken', 'gauge'], this.underlyingCoins, true), this.coins, true), __spreadArray(__spreadArray([this.lpToken, this.gauge], this.underlyingCoinAddresses, true), this.coinAddresses, true)], addresses, false))];
-                        case 1: return [2 /*return*/, _b.sent()];
+                        case 1: return [2 /*return*/, _c.sent()];
                     }
                 });
             });
@@ -763,10 +1053,10 @@ var Pool = /** @class */ (function () {
                 addresses[_a] = arguments[_a];
             }
             return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0: return [4 /*yield*/, this._balances.apply(this, __spreadArray([['lpToken', 'gauge'], [this.lpToken, this.gauge]], addresses, false))];
-                        case 1: return [2 /*return*/, _b.sent()];
+                        case 1: return [2 /*return*/, _c.sent()];
                     }
                 });
             });
@@ -777,10 +1067,10 @@ var Pool = /** @class */ (function () {
                 addresses[_a] = arguments[_a];
             }
             return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0: return [4 /*yield*/, this._balances.apply(this, __spreadArray([this.underlyingCoins, this.underlyingCoinAddresses], addresses, false))];
-                        case 1: return [2 /*return*/, _b.sent()];
+                        case 1: return [2 /*return*/, _c.sent()];
                     }
                 });
             });
@@ -791,10 +1081,10 @@ var Pool = /** @class */ (function () {
                 addresses[_a] = arguments[_a];
             }
             return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0: return [4 /*yield*/, this._balances.apply(this, __spreadArray([this.coins, this.coinAddresses], addresses, false))];
-                        case 1: return [2 /*return*/, _b.sent()];
+                        case 1: return [2 /*return*/, _c.sent()];
                     }
                 });
             });
@@ -805,10 +1095,10 @@ var Pool = /** @class */ (function () {
                 addresses[_a] = arguments[_a];
             }
             return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0: return [4 /*yield*/, this._balances.apply(this, __spreadArray([__spreadArray(__spreadArray([], this.underlyingCoins, true), this.coins, true), __spreadArray(__spreadArray([], this.underlyingCoinAddresses, true), this.coinAddresses, true)], addresses, false))];
-                        case 1: return [2 /*return*/, _b.sent()];
+                        case 1: return [2 /*return*/, _c.sent()];
                     }
                 });
             });
@@ -828,40 +1118,73 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.exchangeIsApproved = function (inputCoin, amount) { return __awaiter(_this, void 0, void 0, function () {
+            var i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = this._getCoinIdx(inputCoin);
+                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.underlyingCoinAddresses[i]], [amount], curve_1.curve.signerAddress, this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.exchangeApproveEstimateGas = function (inputCoin, amount) { return __awaiter(_this, void 0, void 0, function () {
+            var i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = this._getCoinIdx(inputCoin);
+                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.underlyingCoinAddresses[i]], [amount], this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.exchangeApprove = function (inputCoin, amount) { return __awaiter(_this, void 0, void 0, function () {
+            var i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = this._getCoinIdx(inputCoin);
+                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.underlyingCoinAddresses[i]], [amount], this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         this.exchangeEstimateGas = function (inputCoin, outputCoin, amount, maxSlippage) {
             if (maxSlippage === void 0) { maxSlippage = 0.01; }
             return __awaiter(_this, void 0, void 0, function () {
-                var i, j, inputCoinBalance, _a, _b, _amount, _expected, _minRecvAmount, contract, exchangeMethod, value;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
+                var i, j, inputCoinBalance, _a, _c, _amount, _expected, _minRecvAmount, contract, exchangeMethod, value;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
                         case 0:
                             if (this.name === 'tricrypto2') {
                                 throw Error("Use exchangeTricryptoEstimateGas method for tricrypto2 pool instead");
                             }
                             i = this._getCoinIdx(inputCoin);
                             j = this._getCoinIdx(outputCoin);
-                            _b = (_a = Object).values;
+                            _c = (_a = Object).values;
                             return [4 /*yield*/, this.underlyingCoinBalances()];
                         case 1:
-                            inputCoinBalance = _b.apply(_a, [_c.sent()])[i];
+                            inputCoinBalance = _c.apply(_a, [_d.sent()])[i];
                             if (Number(inputCoinBalance) < Number(amount)) {
                                 throw Error("Not enough " + this.underlyingCoins[i] + ". Actual: " + inputCoinBalance + ", required: " + amount);
                             }
                             return [4 /*yield*/, (0, utils_1.hasAllowance)([this.underlyingCoinAddresses[i]], [amount], curve_1.curve.signerAddress, this.swap)];
                         case 2:
-                            if (!(_c.sent())) {
+                            if (!(_d.sent())) {
                                 throw Error("Token allowance is needed to estimate gas");
                             }
                             _amount = ethers_1.ethers.utils.parseUnits(amount, this.underlyingDecimals[i]);
                             return [4 /*yield*/, this._getExchangeOutput(i, j, _amount)];
                         case 3:
-                            _expected = _c.sent();
+                            _expected = _d.sent();
                             _minRecvAmount = _expected.mul((1 - maxSlippage) * 100).div(100);
                             contract = curve_1.curve.contracts[this.swap].contract;
                             exchangeMethod = Object.prototype.hasOwnProperty.call(contract, 'exchange_underlying') ? 'exchange_underlying' : 'exchange';
                             value = (0, utils_1.isEth)(this.underlyingCoinAddresses[i]) ? _amount : ethers_1.ethers.BigNumber.from(0);
                             return [4 /*yield*/, contract.estimateGas[exchangeMethod](i, j, _amount, _minRecvAmount, __assign(__assign({}, curve_1.curve.constantOptions), { value: value }))];
-                        case 4: return [2 /*return*/, (_c.sent()).toNumber()];
+                        case 4: return [2 /*return*/, (_d.sent()).toNumber()];
                     }
                 });
             });
@@ -901,40 +1224,88 @@ var Pool = /** @class */ (function () {
                 });
             });
         };
+        this.exchangeTricryptoIsApproved = function (inputCoin, amount, useEth) {
+            if (useEth === void 0) { useEth = false; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var i;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            i = this._getCoinIdx(inputCoin);
+                            if (i === 2 && useEth)
+                                return [2 /*return*/, true];
+                            return [4 /*yield*/, (0, utils_1.hasAllowance)([this.underlyingCoinAddresses[i]], [amount], curve_1.curve.signerAddress, this.swap)];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                });
+            });
+        };
+        this.exchangeTricryptoApproveEstimateGas = function (inputCoin, amount, useEth) {
+            if (useEth === void 0) { useEth = false; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var i;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            i = this._getCoinIdx(inputCoin);
+                            if (i === 2 && useEth)
+                                return [2 /*return*/, 0];
+                            return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.underlyingCoinAddresses[i]], [amount], this.swap)];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                });
+            });
+        };
+        this.exchangeTricryptoApprove = function (inputCoin, amount, useEth) {
+            if (useEth === void 0) { useEth = false; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var i;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            i = this._getCoinIdx(inputCoin);
+                            if (i === 2 && useEth)
+                                return [2 /*return*/, []];
+                            return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.underlyingCoinAddresses[i]], [amount], this.swap)];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                });
+            });
+        };
         this.exchangeTricryptoEstimateGas = function (inputCoin, outputCoin, amount, maxSlippage, useEth) {
             if (maxSlippage === void 0) { maxSlippage = 0.01; }
             if (useEth === void 0) { useEth = false; }
             return __awaiter(_this, void 0, void 0, function () {
-                var i, j, inputCoinBalance, _a, _b, _amount, _expected, _minRecvAmount, contract, value;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
+                var i, j, inputCoinBalance, _a, _c, _amount, _expected, _minRecvAmount, contract, value;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
                         case 0:
                             if (this.name !== 'tricrypto2') {
                                 throw Error("This method is for only tricrypto2 pool");
                             }
                             i = this._getCoinIdx(inputCoin);
                             j = this._getCoinIdx(outputCoin);
-                            _b = (_a = Object).values;
+                            _c = (_a = Object).values;
                             return [4 /*yield*/, this.underlyingCoinBalances()];
                         case 1:
-                            inputCoinBalance = _b.apply(_a, [_c.sent()])[i];
+                            inputCoinBalance = _c.apply(_a, [_d.sent()])[i];
                             if (Number(inputCoinBalance) < Number(amount)) {
                                 throw Error("Not enough " + this.underlyingCoins[i] + ". Actual: " + inputCoinBalance + ", required: " + amount);
                             }
                             return [4 /*yield*/, (0, utils_1.hasAllowance)([this.underlyingCoinAddresses[i]], [amount], curve_1.curve.signerAddress, this.swap)];
                         case 2:
-                            if (!(_c.sent())) {
+                            if (!(_d.sent())) {
                                 throw Error("Token allowance is needed to estimate gas");
                             }
                             _amount = ethers_1.ethers.utils.parseUnits(amount, this.underlyingDecimals[i]);
                             return [4 /*yield*/, this._getExchangeOutput(i, j, _amount)];
                         case 3:
-                            _expected = _c.sent();
+                            _expected = _d.sent();
                             _minRecvAmount = _expected.mul((1 - maxSlippage) * 100).div(100);
                             contract = curve_1.curve.contracts[this.swap].contract;
                             value = useEth && i == 2 ? _amount : ethers_1.ethers.BigNumber.from(0);
                             return [4 /*yield*/, contract.estimateGas.exchange(i, j, _amount, _minRecvAmount, useEth, __assign(__assign({}, curve_1.curve.constantOptions), { value: value }))];
-                        case 4: return [2 /*return*/, (_c.sent()).toNumber()];
+                        case 4: return [2 /*return*/, (_d.sent()).toNumber()];
                     }
                 });
             });
@@ -992,36 +1363,69 @@ var Pool = /** @class */ (function () {
                 }
             });
         }); };
+        this.exchangeWrappedIsApproved = function (inputCoin, amount) { return __awaiter(_this, void 0, void 0, function () {
+            var i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = this._getCoinIdx(inputCoin);
+                        return [4 /*yield*/, (0, utils_1.hasAllowance)([this.coinAddresses[i]], [amount], curve_1.curve.signerAddress, this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.exchangeWrappedApproveEstimateGas = function (inputCoin, amount) { return __awaiter(_this, void 0, void 0, function () {
+            var i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = this._getCoinIdx(inputCoin);
+                        return [4 /*yield*/, (0, utils_1.ensureAllowanceEstimateGas)([this.coinAddresses[i]], [amount], this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.exchangeWrappedApprove = function (inputCoin, amount) { return __awaiter(_this, void 0, void 0, function () {
+            var i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = this._getCoinIdx(inputCoin);
+                        return [4 /*yield*/, (0, utils_1.ensureAllowance)([this.coinAddresses[i]], [amount], this.swap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
         this.exchangeWrappedEstimateGas = function (inputCoin, outputCoin, amount, maxSlippage) {
             if (maxSlippage === void 0) { maxSlippage = 0.01; }
             return __awaiter(_this, void 0, void 0, function () {
-                var i, j, inputCoinBalance, _a, _b, _amount, _expected, _minRecvAmount, contract, value;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
+                var i, j, inputCoinBalance, _a, _c, _amount, _expected, _minRecvAmount, contract, value;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
                         case 0:
                             i = this._getCoinIdx(inputCoin, false);
                             j = this._getCoinIdx(outputCoin, false);
-                            _b = (_a = Object).values;
+                            _c = (_a = Object).values;
                             return [4 /*yield*/, this.coinBalances()];
                         case 1:
-                            inputCoinBalance = _b.apply(_a, [_c.sent()])[i];
+                            inputCoinBalance = _c.apply(_a, [_d.sent()])[i];
                             if (Number(inputCoinBalance) < Number(amount)) {
                                 throw Error("Not enough " + this.coins[i] + ". Actual: " + inputCoinBalance + ", required: " + amount);
                             }
                             return [4 /*yield*/, (0, utils_1.hasAllowance)([this.coinAddresses[i]], [amount], curve_1.curve.signerAddress, this.swap)];
                         case 2:
-                            if (!(_c.sent())) {
+                            if (!(_d.sent())) {
                                 throw Error("Token allowance is needed to estimate gas");
                             }
                             _amount = ethers_1.ethers.utils.parseUnits(amount, this.decimals[i]);
                             return [4 /*yield*/, this._getExchangeOutputWrapped(i, j, _amount)];
                         case 3:
-                            _expected = _c.sent();
+                            _expected = _d.sent();
                             _minRecvAmount = _expected.mul((1 - maxSlippage) * 100).div(100);
                             contract = curve_1.curve.contracts[this.swap].contract;
                             value = (0, utils_1.isEth)(this.coinAddresses[i]) ? _amount : ethers_1.ethers.BigNumber.from(0);
                             return [4 /*yield*/, contract.estimateGas.exchange(i, j, _amount, _minRecvAmount, __assign(__assign({}, curve_1.curve.constantOptions), { value: value }))];
-                        case 4: return [2 /*return*/, (_c.sent()).toNumber()];
+                        case 4: return [2 /*return*/, (_d.sent()).toNumber()];
                     }
                 });
             });
@@ -1063,9 +1467,9 @@ var Pool = /** @class */ (function () {
                 addresses[_a] = arguments[_a];
             }
             return __awaiter(_this, void 0, void 0, function () {
-                var votingEscrowContract, gaugeContract, contractCalls, response, _b, veTotalSupply, gaugeTotalSupply, resultBN, result, _c, _d, entry;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
+                var votingEscrowContract, gaugeContract, contractCalls, response, _c, veTotalSupply, gaugeTotalSupply, resultBN, result, _d, _e, entry;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
                         case 0:
                             if (addresses.length == 1 && Array.isArray(addresses[0]))
                                 addresses = addresses[0];
@@ -1077,15 +1481,15 @@ var Pool = /** @class */ (function () {
                             });
                             return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
                         case 1:
-                            response = (_e.sent()).map(function (value) { return (0, utils_1.toBN)(value); });
-                            _b = response.splice(0, 2), veTotalSupply = _b[0], gaugeTotalSupply = _b[1];
+                            response = (_f.sent()).map(function (value) { return (0, utils_1.toBN)(value); });
+                            _c = response.splice(0, 2), veTotalSupply = _c[0], gaugeTotalSupply = _c[1];
                             resultBN = {};
                             addresses.forEach(function (acct, i) {
                                 resultBN[acct] = response[i].div(veTotalSupply).times(gaugeTotalSupply);
                             });
                             result = {};
-                            for (_c = 0, _d = Object.entries(resultBN); _c < _d.length; _c++) {
-                                entry = _d[_c];
+                            for (_d = 0, _e = Object.entries(resultBN); _d < _e.length; _d++) {
+                                entry = _e[_d];
                                 result[entry[0]] = (0, utils_1.toStringFromBN)(entry[1]);
                             }
                             return [2 /*return*/, result];
@@ -1099,9 +1503,9 @@ var Pool = /** @class */ (function () {
                 accounts[_a] = arguments[_a];
             }
             return __awaiter(_this, void 0, void 0, function () {
-                var votingEscrowContract, lpTokenContract, gaugeContract, contractCalls, response, _b, veTotalSupply, gaugeTotalSupply, votingPower, totalBalance, _c, accounts_1, acct, totalPower, optimalBN, _d, accounts_2, acct, amount, _e, accounts_3, acct, optimal, _f, _g, entry;
-                return __generator(this, function (_h) {
-                    switch (_h.label) {
+                var votingEscrowContract, lpTokenContract, gaugeContract, contractCalls, 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 (_k) {
+                    switch (_k.label) {
                         case 0:
                             if (accounts.length == 1 && Array.isArray(accounts[0]))
                                 accounts = accounts[0];
@@ -1114,12 +1518,12 @@ var Pool = /** @class */ (function () {
                             });
                             return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
                         case 1:
-                            response = (_h.sent()).map(function (value) { return (0, utils_1.toBN)(value); });
-                            _b = response.splice(0, 2), veTotalSupply = _b[0], gaugeTotalSupply = _b[1];
+                            response = (_k.sent()).map(function (value) { return (0, utils_1.toBN)(value); });
+                            _c = response.splice(0, 2), veTotalSupply = _c[0], gaugeTotalSupply = _c[1];
                             votingPower = {};
                             totalBalance = (0, utils_1.BN)(0);
-                            for (_c = 0, accounts_1 = accounts; _c < accounts_1.length; _c++) {
-                                acct = accounts_1[_c];
+                            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);
@@ -1127,8 +1531,8 @@ var Pool = /** @class */ (function () {
                             totalPower = Object.values(votingPower).reduce(function (sum, item) { return sum.plus(item); });
                             optimalBN = Object.fromEntries(accounts.map(function (acc) { return [acc, (0, utils_1.BN)(0)]; }));
                             if (totalBalance.lt(gaugeTotalSupply.times(totalPower).div(veTotalSupply))) {
-                                for (_d = 0, accounts_2 = accounts; _d < accounts_2.length; _d++) {
-                                    acct = accounts_2[_d];
+                                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;
@@ -1140,16 +1544,16 @@ var Pool = /** @class */ (function () {
                             }
                             else {
                                 if (totalPower.lt(0)) {
-                                    for (_e = 0, accounts_3 = accounts; _e < accounts_3.length; _e++) {
-                                        acct = accounts_3[_e];
+                                    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 (_f = 0, _g = Object.entries(optimalBN); _f < _g.length; _f++) {
-                                entry = _g[_f];
+                            for (_g = 0, _h = Object.entries(optimalBN); _g < _h.length; _g++) {
+                                entry = _h[_g];
                                 optimal[entry[0]] = (0, utils_1.toStringFromBN)(entry[1]);
                             }
                             return [2 /*return*/, optimal];
@@ -1159,8 +1563,8 @@ var Pool = /** @class */ (function () {
         };
         this.boost = function (address) { return __awaiter(_this, void 0, void 0, function () {
             var gaugeContract, _a, workingBalance, balance, boost;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
                         return [4 /*yield*/, curve_1.curve.multicallProvider.all([
@@ -1168,7 +1572,7 @@ var Pool = /** @class */ (function () {
                                 gaugeContract.balanceOf(address),
                             ])];
                     case 1:
-                        _a = (_b.sent()).map(function (value) { return Number(ethers_1.ethers.utils.formatUnits(value)); }), workingBalance = _a[0], balance = _a[1];
+                        _a = (_c.sent()).map(function (value) { return Number(ethers_1.ethers.utils.formatUnits(value)); }), workingBalance = _a[0], balance = _a[1];
                         boost = workingBalance / (0.4 * balance);
                         return [2 /*return*/, boost.toFixed(4).replace(/([0-9])0+$/, '$1')];
                 }
@@ -1176,8 +1580,8 @@ var Pool = /** @class */ (function () {
         }); };
         this.getApy = function () { return __awaiter(_this, void 0, void 0, function () {
             var swapContract, gaugeContract, gaugeControllerContract, _a, inflation, weight, workingSupply, virtualPrice, rate, crvRate, baseApy, boostedApy;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         swapContract = curve_1.curve.contracts[this.swap].multicallContract;
                         gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
@@ -1189,11 +1593,11 @@ var Pool = /** @class */ (function () {
                                 swapContract.get_virtual_price(),
                             ])];
                     case 1:
-                        _a = (_b.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflation = _a[0], weight = _a[1], workingSupply = _a[2], virtualPrice = _a[3];
+                        _a = (_c.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflation = _a[0], weight = _a[1], workingSupply = _a[2], virtualPrice = _a[3];
                         rate = inflation.times(weight).times(31536000).div(workingSupply).times(0.4).div(virtualPrice);
                         return [4 /*yield*/, (0, utils_1.getCrvRate)()];
                     case 2:
-                        crvRate = _b.sent();
+                        crvRate = _c.sent();
                         baseApy = rate.times(crvRate);
                         boostedApy = baseApy.times(2.5);
                         return [2 /*return*/, [baseApy.toFixed(4), boostedApy.toFixed(4)]];
@@ -1224,37 +1628,37 @@ var Pool = /** @class */ (function () {
             return idx;
         };
         this._getRates = function () { return __awaiter(_this, void 0, void 0, function () {
-            var _rates, i, addr, _a, _b, _c, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+            var _rates, i, addr, _a, _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
                         _rates = [];
                         i = 0;
-                        _e.label = 1;
+                        _f.label = 1;
                     case 1:
                         if (!(i < this.coinAddresses.length)) return [3 /*break*/, 9];
                         addr = this.coinAddresses[i];
                         if (!this.useLending[i]) return [3 /*break*/, 7];
                         if (!['compound', 'usdt', 'ib'].includes(this.name)) return [3 /*break*/, 3];
-                        _b = (_a = _rates).push;
+                        _c = (_a = _rates).push;
                         return [4 /*yield*/, curve_1.curve.contracts[addr].contract.exchangeRateStored()];
                     case 2:
-                        _b.apply(_a, [_e.sent()]);
+                        _c.apply(_a, [_f.sent()]);
                         return [3 /*break*/, 6];
                     case 3:
                         if (!['y', 'busd', 'pax'].includes(this.name)) return [3 /*break*/, 5];
-                        _d = (_c = _rates).push;
+                        _e = (_d = _rates).push;
                         return [4 /*yield*/, curve_1.curve.contracts[addr].contract.getPricePerFullShare()];
                     case 4:
-                        _d.apply(_c, [_e.sent()]);
+                        _e.apply(_d, [_f.sent()]);
                         return [3 /*break*/, 6];
                     case 5:
                         _rates.push(ethers_1.ethers.BigNumber.from(10).pow(18)); // Aave ratio 1:1
-                        _e.label = 6;
+                        _f.label = 6;
                     case 6: return [3 /*break*/, 8];
                     case 7:
                         _rates.push(ethers_1.ethers.BigNumber.from(10).pow(18));
-                        _e.label = 8;
+                        _f.label = 8;
                     case 8:
                         i++;
                         return [3 /*break*/, 1];
@@ -1268,9 +1672,9 @@ var Pool = /** @class */ (function () {
                 addresses[_a - 2] = arguments[_a];
             }
             return __awaiter(_this, void 0, void 0, function () {
-                var coinNames, coinAddresses, i, rawBalances, balances, _b, addresses_1, address, _c, coinNames_1, coinName;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
+                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 = [];
@@ -1288,13 +1692,13 @@ var Pool = /** @class */ (function () {
                             addresses = (0, utils_1._prepareAddresses)(addresses);
                             return [4 /*yield*/, (0, utils_1._getBalances)(coinAddresses, addresses)];
                         case 1:
-                            rawBalances = _d.sent();
+                            rawBalances = _e.sent();
                             balances = {};
-                            for (_b = 0, addresses_1 = addresses; _b < addresses_1.length; _b++) {
-                                address = addresses_1[_b];
+                            for (_c = 0, addresses_1 = addresses; _c < addresses_1.length; _c++) {
+                                address = addresses_1[_c];
                                 balances[address] = {};
-                                for (_c = 0, coinNames_1 = coinNames; _c < coinNames_1.length; _c++) {
-                                    coinName = coinNames_1[_c];
+                                for (_d = 0, coinNames_1 = coinNames; _d < coinNames_1.length; _d++) {
+                                    coinName = coinNames_1[_d];
                                     balances[address][coinName] = rawBalances[address].shift();
                                 }
                             }
@@ -1303,6 +1707,18 @@ var Pool = /** @class */ (function () {
                 });
             });
         };
+        this._balancedAmounts = function (poolBalances, walletBalances) {
+            var poolBalancesRatios = poolBalances.map(function (b) { return b / poolBalances.reduce(function (a, b) { return a + b; }); });
+            // Cross factors for each wallet balance used as reference to see the
+            // max that can be used according to the lowest relative wallet balance
+            var balancesAmountsForEachScenario = walletBalances.map(function (_, i) { return (walletBalances.map(function (_, j) { return (poolBalancesRatios[j] * walletBalances[i] / poolBalancesRatios[i]); })); });
+            var firstCoinBalanceForEachScenario = balancesAmountsForEachScenario.map(function (_a) {
+                var a = _a[0];
+                return a;
+            });
+            var scenarioWithLowestBalances = firstCoinBalanceForEachScenario.indexOf(Math.min.apply(Math, firstCoinBalanceForEachScenario));
+            return balancesAmountsForEachScenario[scenarioWithLowestBalances].map(String);
+        };
         this._calcLpTokenAmount = function (_amounts, isDeposit) {
             if (isDeposit === void 0) { isDeposit = true; }
             return __awaiter(_this, void 0, void 0, function () {
@@ -1457,25 +1873,25 @@ var Pool = /** @class */ (function () {
             if (estimateGas === void 0) { estimateGas = false; }
             return __awaiter(_this, void 0, void 0, function () {
                 var coinAddresses, _minMintAmount, _a, contract, ethIndex, value, gas, gasLimit;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0:
                             coinAddresses = useUnderlying ? this.underlyingCoinAddresses : this.coinAddresses;
                             if (!!estimateGas) return [3 /*break*/, 2];
                             return [4 /*yield*/, (0, utils_1._ensureAllowance)(coinAddresses, _amounts, this.swap)];
                         case 1:
-                            _b.sent();
-                            _b.label = 2;
+                            _c.sent();
+                            _c.label = 2;
                         case 2:
                             if (!useUnderlying) return [3 /*break*/, 4];
                             return [4 /*yield*/, this._calcLpTokenAmountWithUnderlying(_amounts)];
                         case 3:
-                            _a = _b.sent();
+                            _a = _c.sent();
                             return [3 /*break*/, 6];
                         case 4: return [4 /*yield*/, this._calcLpTokenAmount(_amounts)];
                         case 5:
-                            _a = _b.sent();
-                            _b.label = 6;
+                            _a = _c.sent();
+                            _c.label = 6;
                         case 6:
                             _minMintAmount = _a;
                             _minMintAmount = _minMintAmount.mul(99).div(100);
@@ -1484,33 +1900,33 @@ var Pool = /** @class */ (function () {
                             value = _amounts[ethIndex] || ethers_1.ethers.BigNumber.from(0);
                             return [4 /*yield*/, contract.estimateGas.add_liquidity(_amounts, _minMintAmount, useUnderlying, __assign(__assign({}, curve_1.curve.constantOptions), { value: value }))];
                         case 7:
-                            gas = _b.sent();
+                            gas = _c.sent();
                             if (estimateGas) {
                                 return [2 /*return*/, gas.toNumber()];
                             }
                             gasLimit = gas.mul(130).div(100);
                             return [4 /*yield*/, contract.add_liquidity(_amounts, _minMintAmount, useUnderlying, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit, value: value }))];
-                        case 8: return [2 /*return*/, (_b.sent()).hash];
+                        case 8: return [2 /*return*/, (_c.sent()).hash];
                     }
                 });
             });
         };
         this._calcExpectedAmounts = function (_lpTokenAmount) { return __awaiter(_this, void 0, void 0, function () {
-            var coinBalancesBN, i, _balance, totalSupplyBN, _a, expectedAmountsBN, _b, coinBalancesBN_1, coinBalance;
+            var coinBalancesBN, i, _balance, totalSupplyBN, _a, expectedAmountsBN, _c, coinBalancesBN_1, coinBalance;
             var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         coinBalancesBN = [];
                         i = 0;
-                        _c.label = 1;
+                        _d.label = 1;
                     case 1:
                         if (!(i < this.coinAddresses.length)) return [3 /*break*/, 4];
                         return [4 /*yield*/, curve_1.curve.contracts[this.swap].contract.balances(i, curve_1.curve.constantOptions)];
                     case 2:
-                        _balance = _c.sent();
+                        _balance = _d.sent();
                         coinBalancesBN.push((0, utils_1.toBN)(_balance, this.decimals[i]));
-                        _c.label = 3;
+                        _d.label = 3;
                     case 3:
                         i++;
                         return [3 /*break*/, 1];
@@ -1518,10 +1934,10 @@ var Pool = /** @class */ (function () {
                         _a = utils_1.toBN;
                         return [4 /*yield*/, curve_1.curve.contracts[this.lpToken].contract.totalSupply(curve_1.curve.constantOptions)];
                     case 5:
-                        totalSupplyBN = _a.apply(void 0, [_c.sent()]);
+                        totalSupplyBN = _a.apply(void 0, [_d.sent()]);
                         expectedAmountsBN = [];
-                        for (_b = 0, coinBalancesBN_1 = coinBalancesBN; _b < coinBalancesBN_1.length; _b++) {
-                            coinBalance = coinBalancesBN_1[_b];
+                        for (_c = 0, coinBalancesBN_1 = coinBalancesBN; _c < coinBalancesBN_1.length; _c++) {
+                            coinBalance = coinBalancesBN_1[_c];
                             expectedAmountsBN.push(coinBalance.times((0, utils_1.toBN)(_lpTokenAmount)).div(totalSupplyBN));
                         }
                         return [2 /*return*/, expectedAmountsBN.map(function (amount, i) { return (0, utils_1.fromBN)(amount, _this.decimals[i]); })];
@@ -1679,30 +2095,30 @@ var Pool = /** @class */ (function () {
             if (estimateGas === void 0) { estimateGas = false; }
             return __awaiter(_this, void 0, void 0, function () {
                 var _minAmounts, _a, contract, gas, gasLimit;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0:
                             if (!useUnderlying) return [3 /*break*/, 2];
                             return [4 /*yield*/, this._calcMinUnderlyingAmounts(_lpTokenAmount)];
                         case 1:
-                            _a = _b.sent();
+                            _a = _c.sent();
                             return [3 /*break*/, 4];
                         case 2: return [4 /*yield*/, this._calcMinAmounts(_lpTokenAmount)];
                         case 3:
-                            _a = _b.sent();
-                            _b.label = 4;
+                            _a = _c.sent();
+                            _c.label = 4;
                         case 4:
                             _minAmounts = _a;
                             contract = curve_1.curve.contracts[this.swap].contract;
                             return [4 /*yield*/, contract.estimateGas.remove_liquidity(_lpTokenAmount, _minAmounts, useUnderlying, curve_1.curve.constantOptions)];
                         case 5:
-                            gas = _b.sent();
+                            gas = _c.sent();
                             if (estimateGas) {
                                 return [2 /*return*/, gas.toNumber()];
                             }
                             gasLimit = gas.mul(130).div(100);
                             return [4 /*yield*/, contract.remove_liquidity(_lpTokenAmount, _minAmounts, useUnderlying, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                        case 6: return [2 /*return*/, (_b.sent()).hash];
+                        case 6: return [2 /*return*/, (_c.sent()).hash];
                     }
                 });
             });
@@ -1803,31 +2219,31 @@ var Pool = /** @class */ (function () {
             if (estimateGas === void 0) { estimateGas = false; }
             return __awaiter(_this, void 0, void 0, function () {
                 var _maxBurnAmount, _a, contract, gas, gasLimit;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0:
                             if (!useUnderlying) return [3 /*break*/, 2];
                             return [4 /*yield*/, this._calcLpTokenAmountWithUnderlying(_amounts, false)];
                         case 1:
-                            _a = _b.sent();
+                            _a = _c.sent();
                             return [3 /*break*/, 4];
                         case 2: return [4 /*yield*/, this._calcLpTokenAmount(_amounts, false)];
                         case 3:
-                            _a = _b.sent();
-                            _b.label = 4;
+                            _a = _c.sent();
+                            _c.label = 4;
                         case 4:
                             _maxBurnAmount = _a;
                             _maxBurnAmount = _maxBurnAmount.mul(101).div(100);
                             contract = curve_1.curve.contracts[this.swap].contract;
                             return [4 /*yield*/, contract.estimateGas.remove_liquidity_imbalance(_amounts, _maxBurnAmount, useUnderlying, curve_1.curve.constantOptions)];
                         case 5:
-                            gas = _b.sent();
+                            gas = _c.sent();
                             if (estimateGas) {
                                 return [2 /*return*/, gas.toNumber()];
                             }
                             gasLimit = gas.mul(130).div(100);
                             return [4 /*yield*/, contract.remove_liquidity_imbalance(_amounts, _maxBurnAmount, useUnderlying, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                        case 6: return [2 /*return*/, (_b.sent()).hash];
+                        case 6: return [2 /*return*/, (_c.sent()).hash];
                     }
                 });
             });
@@ -1932,31 +2348,31 @@ var Pool = /** @class */ (function () {
             if (estimateGas === void 0) { estimateGas = false; }
             return __awaiter(_this, void 0, void 0, function () {
                 var _minAmount, _a, contract, gas, gasLimit;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0:
                             if (!(this.name === 'ib')) return [3 /*break*/, 2];
                             return [4 /*yield*/, this._calcWithdrawOneCoin(_lpTokenAmount, i, useUnderlying)];
                         case 1:
-                            _a = _b.sent();
+                            _a = _c.sent();
                             return [3 /*break*/, 4];
                         case 2: return [4 /*yield*/, this._calcWithdrawOneCoinSwap(_lpTokenAmount, i)];
                         case 3:
-                            _a = _b.sent();
-                            _b.label = 4;
+                            _a = _c.sent();
+                            _c.label = 4;
                         case 4:
                             _minAmount = _a;
                             _minAmount = _minAmount.mul(99).div(100);
                             contract = curve_1.curve.contracts[this.swap].contract;
                             return [4 /*yield*/, contract.estimateGas.remove_liquidity_one_coin(_lpTokenAmount, i, _minAmount, useUnderlying, curve_1.curve.constantOptions)];
                         case 5:
-                            gas = _b.sent();
+                            gas = _c.sent();
                             if (estimateGas) {
                                 return [2 /*return*/, gas.toNumber()];
                             }
                             gasLimit = gas.mul(130).div(100);
                             return [4 /*yield*/, contract.remove_liquidity_one_coin(_lpTokenAmount, i, _minAmount, useUnderlying, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
-                        case 6: return [2 /*return*/, (_b.sent()).hash];
+                        case 6: return [2 /*return*/, (_c.sent()).hash];
                     }
                 });
             });
@@ -2000,18 +2416,27 @@ var Pool = /** @class */ (function () {
         this.basePool = poolData.base_pool || '';
         this.isFactory = poolData.is_factory || false;
         this.estimateGas = {
+            addLiquidityApprove: this.addLiquidityApproveEstimateGas,
             addLiquidity: this.addLiquidityEstimateGas,
+            addLiquidityWrappedApprove: this.addLiquidityWrappedApproveEstimateGas,
             addLiquidityWrapped: this.addLiquidityWrappedEstimateGas,
+            gaugeDepositApprove: this.gaugeDepositApproveEstimateGas,
             gaugeDeposit: this.gaugeDepositEstimateGas,
             gaugeWithdraw: this.gaugeWithdrawEstimateGas,
+            removeLiquidityApprove: this.removeLiquidityApproveEstimateGas,
             removeLiquidity: this.removeLiquidityEstimateGas,
             removeLiquidityWrapped: this.removeLiquidityWrappedEstimateGas,
+            removeLiquidityImbalanceApprove: this.removeLiquidityImbalanceApproveEstimateGas,
             removeLiquidityImbalance: this.removeLiquidityImbalanceEstimateGas,
             removeLiquidityImbalanceWrapped: this.removeLiquidityImbalanceWrappedEstimateGas,
+            removeLiquidityOneCoinApprove: this.removeLiquidityOneCoinApproveEstimateGas,
             removeLiquidityOneCoin: this.removeLiquidityOneCoinEstimateGas,
             removeLiquidityOneCoinWrapped: this.removeLiquidityOneCoinWrappedEstimateGas,
+            exchangeApprove: this.exchangeApproveEstimateGas,
             exchange: this.exchangeEstimateGas,
+            exchangeTricryptoApprove: this.exchangeTricryptoApproveEstimateGas,
             exchangeTricrypto: this.exchangeTricryptoEstimateGas,
+            exchangeWrappedApprove: this.exchangeWrappedApproveEstimateGas,
             exchangeWrapped: this.exchangeWrappedEstimateGas,
         };
         if (this.isMeta) {
@@ -2027,8 +2452,8 @@ exports.Pool = Pool;
 // --------- Exchange Using All Pools ---------
 var _getBestPoolAndOutput = function (inputCoinAddress, outputCoinAddress, inputCoinDecimals, amount) { return __awaiter(void 0, void 0, void 0, function () {
     var tricryptoCoins, addressProviderContract, registryExchangeAddress, registryExchangeContract, _amount, _a, poolAddress, output;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
+    return __generator(this, function (_c) {
+        switch (_c.label) {
             case 0:
                 tricryptoCoins = [coins_1.COINS.usdt.toLowerCase(), coins_1.COINS.wbtc.toLowerCase(), coins_1.COINS.weth.toLowerCase()];
                 if (tricryptoCoins.includes(inputCoinAddress.toLowerCase()) && tricryptoCoins.includes(outputCoinAddress.toLowerCase())) {
@@ -2037,27 +2462,27 @@ var _getBestPoolAndOutput = function (inputCoinAddress, outputCoinAddress, input
                 addressProviderContract = curve_1.curve.contracts[curve_1.ALIASES.address_provider].contract;
                 return [4 /*yield*/, addressProviderContract.get_address(2, curve_1.curve.constantOptions)];
             case 1:
-                registryExchangeAddress = _b.sent();
+                registryExchangeAddress = _c.sent();
                 registryExchangeContract = new ethers_1.ethers.Contract(registryExchangeAddress, registry_exchange_json_1.default, curve_1.curve.signer || curve_1.curve.provider);
                 _amount = ethers_1.ethers.utils.parseUnits(amount.toString(), inputCoinDecimals);
                 return [4 /*yield*/, registryExchangeContract.get_best_rate(inputCoinAddress, outputCoinAddress, _amount, curve_1.curve.constantOptions)];
             case 2:
-                _a = _b.sent(), poolAddress = _a[0], output = _a[1];
+                _a = _c.sent(), poolAddress = _a[0], output = _a[1];
                 return [2 /*return*/, { poolAddress: poolAddress, output: output }];
         }
     });
 }); };
 exports._getBestPoolAndOutput = _getBestPoolAndOutput;
 var getBestPoolAndOutput = function (inputCoin, outputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, _c, poolAddress, _output, output;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
+    var _a, inputCoinAddress, outputCoinAddress, _c, inputCoinDecimals, outputCoinDecimals, _d, poolAddress, _output, output;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
             case 0:
                 _a = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
-                _b = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
+                _c = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _c[0], outputCoinDecimals = _c[1];
                 return [4 /*yield*/, (0, exports._getBestPoolAndOutput)(inputCoinAddress, outputCoinAddress, inputCoinDecimals, amount)];
             case 1:
-                _c = _d.sent(), poolAddress = _c.poolAddress, _output = _c.output;
+                _d = _e.sent(), poolAddress = _d.poolAddress, _output = _d.output;
                 output = ethers_1.ethers.utils.formatUnits(_output, outputCoinDecimals);
                 return [2 /*return*/, { poolAddress: poolAddress, output: output }];
         }
@@ -2076,35 +2501,35 @@ exports.exchangeExpected = exchangeExpected;
 var exchangeEstimateGas = function (inputCoin, outputCoin, amount, maxSlippage) {
     if (maxSlippage === void 0) { maxSlippage = 0.01; }
     return __awaiter(void 0, void 0, void 0, function () {
-        var _a, inputCoinAddress, outputCoinAddress, inputCoinDecimals, addressProviderContract, registryAddress, registryContract, poolAddress, poolName, _b, _i, _j, is_underlying, i, j, pool;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
+        var _a, inputCoinAddress, outputCoinAddress, inputCoinDecimals, addressProviderContract, registryAddress, registryContract, poolAddress, poolName, _c, _i, _j, is_underlying, i, j, pool;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     _a = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
                     inputCoinDecimals = (0, utils_1._getCoinDecimals)(inputCoinAddress)[0];
                     addressProviderContract = curve_1.curve.contracts[curve_1.ALIASES.address_provider].contract;
                     return [4 /*yield*/, addressProviderContract.get_registry()];
                 case 1:
-                    registryAddress = _c.sent();
+                    registryAddress = _d.sent();
                     registryContract = new ethers_1.ethers.Contract(registryAddress, registry_json_1.default, curve_1.curve.signer);
                     return [4 /*yield*/, (0, exports._getBestPoolAndOutput)(inputCoinAddress, outputCoinAddress, inputCoinDecimals, amount)];
                 case 2:
-                    poolAddress = (_c.sent()).poolAddress;
+                    poolAddress = (_d.sent()).poolAddress;
                     if (poolAddress === "0x0000000000000000000000000000000000000000") {
                         throw new Error("This pair can't be exchanged");
                     }
                     poolName = (0, utils_1.getPoolNameBySwapAddress)(poolAddress);
                     return [4 /*yield*/, registryContract.get_coin_indices(poolAddress, inputCoinAddress, outputCoinAddress)];
                 case 3:
-                    _b = _c.sent(), _i = _b[0], _j = _b[1], is_underlying = _b[2];
+                    _c = _d.sent(), _i = _c[0], _j = _c[1], is_underlying = _c[2];
                     i = Number(_i.toString());
                     j = Number(_j.toString());
                     pool = new Pool(poolName);
                     if (!is_underlying) return [3 /*break*/, 5];
                     return [4 /*yield*/, pool.estimateGas.exchange(i, j, amount, maxSlippage)];
-                case 4: return [2 /*return*/, _c.sent()];
+                case 4: return [2 /*return*/, _d.sent()];
                 case 5: return [4 /*yield*/, pool.estimateGas.exchangeWrapped(i, j, amount, maxSlippage)];
-                case 6: return [2 /*return*/, _c.sent()];
+                case 6: return [2 /*return*/, _d.sent()];
             }
         });
     });
@@ -2113,35 +2538,35 @@ exports.exchangeEstimateGas = exchangeEstimateGas;
 var exchange = function (inputCoin, outputCoin, amount, maxSlippage) {
     if (maxSlippage === void 0) { maxSlippage = 0.01; }
     return __awaiter(void 0, void 0, void 0, function () {
-        var _a, inputCoinAddress, outputCoinAddress, inputCoinDecimals, addressProviderContract, registryAddress, registryContract, poolAddress, poolName, _b, _i, _j, is_underlying, i, j, pool;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
+        var _a, inputCoinAddress, outputCoinAddress, inputCoinDecimals, addressProviderContract, registryAddress, registryContract, poolAddress, poolName, _c, _i, _j, is_underlying, i, j, pool;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     _a = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
                     inputCoinDecimals = (0, utils_1._getCoinDecimals)(inputCoinAddress)[0];
                     addressProviderContract = curve_1.curve.contracts[curve_1.ALIASES.address_provider].contract;
                     return [4 /*yield*/, addressProviderContract.get_registry()];
                 case 1:
-                    registryAddress = _c.sent();
+                    registryAddress = _d.sent();
                     registryContract = new ethers_1.ethers.Contract(registryAddress, registry_json_1.default, curve_1.curve.signer);
                     return [4 /*yield*/, (0, exports._getBestPoolAndOutput)(inputCoinAddress, outputCoinAddress, inputCoinDecimals, amount)];
                 case 2:
-                    poolAddress = (_c.sent()).poolAddress;
+                    poolAddress = (_d.sent()).poolAddress;
                     if (poolAddress === "0x0000000000000000000000000000000000000000") {
                         throw new Error("This pair can't be exchanged");
                     }
                     poolName = (0, utils_1.getPoolNameBySwapAddress)(poolAddress);
                     return [4 /*yield*/, registryContract.get_coin_indices(poolAddress, inputCoinAddress, outputCoinAddress)];
                 case 3:
-                    _b = _c.sent(), _i = _b[0], _j = _b[1], is_underlying = _b[2];
+                    _c = _d.sent(), _i = _c[0], _j = _c[1], is_underlying = _c[2];
                     i = Number(_i.toString());
                     j = Number(_j.toString());
                     pool = new Pool(poolName);
                     if (!is_underlying) return [3 /*break*/, 5];
                     return [4 /*yield*/, pool.exchange(i, j, amount, maxSlippage)];
-                case 4: return [2 /*return*/, _c.sent()];
+                case 4: return [2 /*return*/, _d.sent()];
                 case 5: return [4 /*yield*/, pool.exchangeWrapped(i, j, amount, maxSlippage)];
-                case 6: return [2 /*return*/, _c.sent()];
+                case 6: return [2 /*return*/, _d.sent()];
             }
         });
     });
@@ -2150,13 +2575,13 @@ exports.exchange = exchange;
 // --------- Cross-Asset Exchange ---------
 var crossAssetExchangeAvailable = function (inputCoin, outputCoin) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, inputCoinAddress, outputCoinAddress, routerContract;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
+    return __generator(this, function (_c) {
+        switch (_c.label) {
             case 0:
                 _a = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
                 return [4 /*yield*/, curve_1.curve.contracts[curve_1.ALIASES.router].contract];
             case 1:
-                routerContract = _b.sent();
+                routerContract = _c.sent();
                 return [2 /*return*/, routerContract.can_route(inputCoinAddress, outputCoinAddress, curve_1.curve.constantOptions)];
         }
     });
@@ -2174,24 +2599,24 @@ var _getSmallAmountForCoin = function (coinAddress) {
 };
 exports._getSmallAmountForCoin = _getSmallAmountForCoin;
 var _crossAssetExchangeInfo = function (inputCoinAddress, outputCoinAddress, inputCoinDecimals, outputCoinDecimals, amount) { return __awaiter(void 0, void 0, void 0, function () {
-    var routerContract, _amount, amountBN, _a, route, indices, _expected, expectedBN, exchangeRateBN, _smallAmount, smallAmountBN, _b, _expectedSmall, expectedSmallBN, exchangeSmallRateBN, slippage;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
+    var routerContract, _amount, amountBN, _a, route, indices, _expected, expectedBN, exchangeRateBN, _smallAmount, smallAmountBN, _c, _expectedSmall, expectedSmallBN, exchangeSmallRateBN, slippage;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
             case 0: return [4 /*yield*/, curve_1.curve.contracts[curve_1.ALIASES.router].contract];
             case 1:
-                routerContract = _c.sent();
+                routerContract = _d.sent();
                 _amount = ethers_1.ethers.utils.parseUnits(amount, inputCoinDecimals);
                 amountBN = (0, utils_1.toBN)(_amount, inputCoinDecimals);
                 return [4 /*yield*/, routerContract.get_exchange_routing(inputCoinAddress, outputCoinAddress, _amount, curve_1.curve.constantOptions)];
             case 2:
-                _a = _c.sent(), route = _a[0], indices = _a[1], _expected = _a[2];
+                _a = _d.sent(), route = _a[0], indices = _a[1], _expected = _a[2];
                 expectedBN = (0, utils_1.toBN)(_expected, outputCoinDecimals);
                 exchangeRateBN = expectedBN.div(amountBN);
                 _smallAmount = ethers_1.ethers.utils.parseUnits((0, exports._getSmallAmountForCoin)(inputCoinAddress), inputCoinDecimals);
                 smallAmountBN = (0, utils_1.toBN)(_smallAmount, inputCoinDecimals);
                 return [4 /*yield*/, routerContract.get_exchange_routing(inputCoinAddress, outputCoinAddress, _smallAmount, curve_1.curve.constantOptions)];
             case 3:
-                _b = _c.sent(), _expectedSmall = _b[2];
+                _c = _d.sent(), _expectedSmall = _c[2];
                 expectedSmallBN = (0, utils_1.toBN)(_expectedSmall, outputCoinDecimals);
                 exchangeSmallRateBN = expectedSmallBN.div(smallAmountBN);
                 slippage = 1 - exchangeRateBN.div(exchangeSmallRateBN).toNumber();
@@ -2201,15 +2626,15 @@ var _crossAssetExchangeInfo = function (inputCoinAddress, outputCoinAddress, inp
 }); };
 exports._crossAssetExchangeInfo = _crossAssetExchangeInfo;
 var crossAssetExchangeOutputAndSlippage = function (inputCoin, outputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, _c, _expected, slippage, output;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
+    var _a, inputCoinAddress, outputCoinAddress, _c, inputCoinDecimals, outputCoinDecimals, _d, _expected, slippage, output;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
             case 0:
                 _a = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
-                _b = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
+                _c = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _c[0], outputCoinDecimals = _c[1];
                 return [4 /*yield*/, (0, exports._crossAssetExchangeInfo)(inputCoinAddress, outputCoinAddress, inputCoinDecimals, outputCoinDecimals, amount)];
             case 1:
-                _c = _d.sent(), _expected = _c._expected, slippage = _c.slippage;
+                _d = _e.sent(), _expected = _d._expected, slippage = _d.slippage;
                 output = ethers_1.ethers.utils.formatUnits(_expected, outputCoinDecimals);
                 return [2 /*return*/, { output: output, slippage: slippage }];
         }
@@ -2217,19 +2642,19 @@ var crossAssetExchangeOutputAndSlippage = function (inputCoin, outputCoin, amoun
 }); };
 exports.crossAssetExchangeOutputAndSlippage = crossAssetExchangeOutputAndSlippage;
 var crossAssetExchangeExpected = function (inputCoin, outputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, routerContract, _amount, _c, _expected;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
+    var _a, inputCoinAddress, outputCoinAddress, _c, inputCoinDecimals, outputCoinDecimals, routerContract, _amount, _d, _expected;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
             case 0:
                 _a = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
-                _b = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
+                _c = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _c[0], outputCoinDecimals = _c[1];
                 return [4 /*yield*/, curve_1.curve.contracts[curve_1.ALIASES.router].contract];
             case 1:
-                routerContract = _d.sent();
+                routerContract = _e.sent();
                 _amount = ethers_1.ethers.utils.parseUnits(amount, inputCoinDecimals);
                 return [4 /*yield*/, routerContract.get_exchange_routing(inputCoinAddress, outputCoinAddress, _amount, curve_1.curve.constantOptions)];
             case 2:
-                _c = _d.sent(), _expected = _c[2];
+                _d = _e.sent(), _expected = _d[2];
                 return [2 /*return*/, ethers_1.ethers.utils.formatUnits(_expected, outputCoinDecimals)];
         }
     });
@@ -2238,38 +2663,38 @@ exports.crossAssetExchangeExpected = crossAssetExchangeExpected;
 var crossAssetExchangeEstimateGas = function (inputCoin, outputCoin, amount, maxSlippage) {
     if (maxSlippage === void 0) { maxSlippage = 0.02; }
     return __awaiter(void 0, void 0, void 0, function () {
-        var _a, inputCoinAddress, outputCoinAddress, inputCoinBalance, _b, inputCoinDecimals, outputCoinDecimals, _amount, _c, route, indices, _expected, minRecvAmountBN, _minRecvAmount, value, routerContract;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
+        var _a, inputCoinAddress, outputCoinAddress, inputCoinBalance, _c, inputCoinDecimals, outputCoinDecimals, _amount, _d, route, indices, _expected, minRecvAmountBN, _minRecvAmount, value, routerContract;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
                 case 0: return [4 /*yield*/, (0, exports.crossAssetExchangeAvailable)(inputCoin, outputCoin)];
                 case 1:
-                    if (!(_d.sent()))
+                    if (!(_e.sent()))
                         throw Error("Such exchange is not available");
                     _a = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
                     return [4 /*yield*/, (0, utils_1._getBalances)([inputCoinAddress], [curve_1.curve.signerAddress])];
                 case 2:
-                    inputCoinBalance = (_d.sent())[curve_1.curve.signerAddress];
+                    inputCoinBalance = (_e.sent())[curve_1.curve.signerAddress];
                     if (Number(inputCoinBalance) < Number(amount)) {
                         throw Error("Not enough " + inputCoin + ". Actual: " + inputCoinBalance + ", required: " + amount);
                     }
                     return [4 /*yield*/, (0, utils_1.hasAllowance)([inputCoinAddress], [amount], curve_1.curve.signerAddress, curve_1.ALIASES.router)];
                 case 3:
-                    if (!(_d.sent())) {
+                    if (!(_e.sent())) {
                         throw Error("Token allowance is needed to estimate gas");
                     }
-                    _b = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
+                    _c = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _c[0], outputCoinDecimals = _c[1];
                     _amount = ethers_1.ethers.utils.parseUnits(amount, inputCoinDecimals);
                     return [4 /*yield*/, (0, exports._crossAssetExchangeInfo)(inputCoinAddress, outputCoinAddress, inputCoinDecimals, outputCoinDecimals, amount)];
                 case 4:
-                    _c = _d.sent(), route = _c.route, indices = _c.indices, _expected = _c._expected;
+                    _d = _e.sent(), route = _d.route, indices = _d.indices, _expected = _d._expected;
                     minRecvAmountBN = (0, utils_1.toBN)(_expected, outputCoinDecimals).times((1 - maxSlippage));
                     _minRecvAmount = (0, utils_1.fromBN)(minRecvAmountBN, outputCoinDecimals);
                     value = (0, utils_1.isEth)(inputCoinAddress) ? _amount : 0;
                     return [4 /*yield*/, curve_1.curve.contracts[curve_1.ALIASES.router].contract];
                 case 5:
-                    routerContract = _d.sent();
+                    routerContract = _e.sent();
                     return [4 /*yield*/, routerContract.estimateGas.exchange(_amount, route, indices, _minRecvAmount, __assign(__assign({}, curve_1.curve.constantOptions), { value: value }))];
-                case 6: return [2 /*return*/, (_d.sent()).toNumber()];
+                case 6: return [2 /*return*/, (_e.sent()).toNumber()];
             }
         });
     });
@@ -2278,36 +2703,36 @@ exports.crossAssetExchangeEstimateGas = crossAssetExchangeEstimateGas;
 var crossAssetExchange = function (inputCoin, outputCoin, amount, maxSlippage) {
     if (maxSlippage === void 0) { maxSlippage = 0.02; }
     return __awaiter(void 0, void 0, void 0, function () {
-        var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, _amount, _c, route, indices, _expected, minRecvAmountBN, _minRecvAmount, value, routerContract, gasLimit;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
+        var _a, inputCoinAddress, outputCoinAddress, _c, inputCoinDecimals, outputCoinDecimals, _amount, _d, route, indices, _expected, minRecvAmountBN, _minRecvAmount, value, routerContract, gasLimit;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
                 case 0: return [4 /*yield*/, (0, exports.crossAssetExchangeAvailable)(inputCoin, outputCoin)];
                 case 1:
-                    if (!(_d.sent()))
+                    if (!(_e.sent()))
                         throw Error("Such exchange is not available");
                     _a = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
-                    _b = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
+                    _c = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _c[0], outputCoinDecimals = _c[1];
                     _amount = ethers_1.ethers.utils.parseUnits(amount, inputCoinDecimals);
                     return [4 /*yield*/, (0, exports._crossAssetExchangeInfo)(inputCoinAddress, outputCoinAddress, inputCoinDecimals, outputCoinDecimals, amount)];
                 case 2:
-                    _c = _d.sent(), route = _c.route, indices = _c.indices, _expected = _c._expected;
+                    _d = _e.sent(), route = _d.route, indices = _d.indices, _expected = _d._expected;
                     minRecvAmountBN = (0, utils_1.toBN)(_expected, outputCoinDecimals).times((1 - maxSlippage));
                     _minRecvAmount = (0, utils_1.fromBN)(minRecvAmountBN, outputCoinDecimals);
                     value = (0, utils_1.isEth)(inputCoinAddress) ? _amount : 0;
                     return [4 /*yield*/, curve_1.curve.contracts[curve_1.ALIASES.router].contract];
                 case 3:
-                    routerContract = _d.sent();
+                    routerContract = _e.sent();
                     return [4 /*yield*/, (0, utils_1._ensureAllowance)([inputCoinAddress], [_amount], curve_1.ALIASES.router)];
                 case 4:
-                    _d.sent();
+                    _e.sent();
                     return [4 /*yield*/, curve_1.curve.updateFeeData()];
                 case 5:
-                    _d.sent();
+                    _e.sent();
                     return [4 /*yield*/, routerContract.estimateGas.exchange(_amount, route, indices, _minRecvAmount, __assign(__assign({}, curve_1.curve.constantOptions), { value: value }))];
                 case 6:
-                    gasLimit = (_d.sent()).mul(130).div(100);
+                    gasLimit = (_e.sent()).mul(130).div(100);
                     return [4 /*yield*/, routerContract.exchange(_amount, route, indices, _minRecvAmount, __assign(__assign({}, curve_1.curve.options), { value: value, gasLimit: gasLimit }))];
-                case 7: return [2 /*return*/, (_d.sent()).hash];
+                case 7: return [2 /*return*/, (_e.sent()).hash];
             }
         });
     });