@curvefi/api 1.16.0 → 1.16.1

package/lib/pools.d.ts

@@ -161,7 +161,11 @@ export declare class Pool {
     private _getCoinIdx;
     private _getRates;
     private _balances;
+    private _underlyingPrices;
+    private _wrappedPrices;
+    private _addLiquidityCryptoSlippage;
     private _addLiquiditySlippage;
+    private _removeLiquidityCryptoSlippage;
     private _removeLiquiditySlippage;
     private _balancedAmounts;
     private _calcLpTokenAmount;

package/lib/pools.js

@@ -382,17 +382,29 @@ var Pool = /** @class */ (function () {
             });
         }); };
         this.addLiquiditySlippage = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
-            var totalAmount, expected, _a;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var prices_1, totalAmountUSD, expected_1, _a, totalAmount, expected, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        totalAmount = amounts.reduce(function (s, a) { return s + Number(a); }, 0);
+                        if (!this.isCrypto) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._underlyingPrices()];
+                    case 1:
+                        prices_1 = _d.sent();
+                        totalAmountUSD = amounts.reduce(function (s, a, i) { return s + (Number(a) * prices_1[i]); }, 0);
                         _a = Number;
                         return [4 /*yield*/, this.addLiquidityExpected(amounts)];
-                    case 1:
-                        expected = _a.apply(void 0, [_c.sent()]);
+                    case 2:
+                        expected_1 = _a.apply(void 0, [_d.sent()]);
+                        return [4 /*yield*/, this._addLiquidityCryptoSlippage(totalAmountUSD, expected_1)];
+                    case 3: return [2 /*return*/, _d.sent()];
+                    case 4:
+                        totalAmount = amounts.reduce(function (s, a) { return s + Number(a); }, 0);
+                        _c = Number;
+                        return [4 /*yield*/, this.addLiquidityExpected(amounts)];
+                    case 5:
+                        expected = _c.apply(void 0, [_d.sent()]);
                         return [4 /*yield*/, this._addLiquiditySlippage(totalAmount, expected)];
-                    case 2: return [2 /*return*/, _c.sent()];
+                    case 6: return [2 /*return*/, _d.sent()];
                 }
             });
         }); };
@@ -474,7 +486,7 @@ var Pool = /** @class */ (function () {
             });
         }); };
         this.balancedAmounts = function () { return __awaiter(_this, void 0, void 0, function () {
-            var poolBalances, walletBalances, _a, _c;
+            var poolBalances, walletBalances, _a, _c, prices_2, poolBalancesUSD, walletBalancesUSD, balancedAmountsUSD;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0: return [4 /*yield*/, this.getPoolBalances()];
@@ -484,7 +496,15 @@ var Pool = /** @class */ (function () {
                         return [4 /*yield*/, this.underlyingCoinBalances()];
                     case 2:
                         walletBalances = _c.apply(_a, [_d.sent()]).map(Number);
-                        return [2 /*return*/, this._balancedAmounts(poolBalances, walletBalances, this.underlyingDecimals)];
+                        if (!this.isCrypto) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._underlyingPrices()];
+                    case 3:
+                        prices_2 = _d.sent();
+                        poolBalancesUSD = poolBalances.map(function (b, i) { return b * prices_2[i]; });
+                        walletBalancesUSD = walletBalances.map(function (b, i) { return b * prices_2[i]; });
+                        balancedAmountsUSD = this._balancedAmounts(poolBalancesUSD, walletBalancesUSD, this.underlyingDecimals);
+                        return [2 /*return*/, balancedAmountsUSD.map(function (b, i) { return String(Math.min(Number(b) / prices_2[i], poolBalances[i])); })];
+                    case 4: return [2 /*return*/, this._balancedAmounts(poolBalances, walletBalances, this.underlyingDecimals)];
                 }
             });
         }); };
@@ -522,7 +542,7 @@ var Pool = /** @class */ (function () {
             });
         }); };
         this.balancedWrappedAmounts = function () { return __awaiter(_this, void 0, void 0, function () {
-            var poolBalances, walletBalances, _a, _c;
+            var poolBalances, walletBalances, _a, _c, prices_3, poolBalancesUSD, walletBalancesUSD, balancedAmountsUSD;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
@@ -536,7 +556,15 @@ var Pool = /** @class */ (function () {
                         return [4 /*yield*/, this.coinBalances()];
                     case 2:
                         walletBalances = _c.apply(_a, [_d.sent()]).map(Number);
-                        return [2 /*return*/, this._balancedAmounts(poolBalances, walletBalances, this.decimals)];
+                        if (!this.isCrypto) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._wrappedPrices()];
+                    case 3:
+                        prices_3 = _d.sent();
+                        poolBalancesUSD = poolBalances.map(function (b, i) { return b * prices_3[i]; });
+                        walletBalancesUSD = walletBalances.map(function (b, i) { return b * prices_3[i]; });
+                        balancedAmountsUSD = this._balancedAmounts(poolBalancesUSD, walletBalancesUSD, this.decimals);
+                        return [2 /*return*/, balancedAmountsUSD.map(function (b, i) { return String(Math.min(Number(b) / prices_3[i], poolBalances[i])); })];
+                    case 4: return [2 /*return*/, this._balancedAmounts(poolBalances, walletBalances, this.decimals)];
                 }
             });
         }); };
@@ -555,20 +583,32 @@ var Pool = /** @class */ (function () {
             });
         }); };
         this.addLiquidityWrappedSlippage = function (amounts) { return __awaiter(_this, void 0, void 0, function () {
-            var totalAmount, expected, _a;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var prices_4, totalAmountUSD, expected_2, _a, totalAmount, expected, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         if (this.isFake) {
                             throw Error("".concat(this.name, " pool doesn't have this method"));
                         }
-                        totalAmount = amounts.reduce(function (s, a) { return s + Number(a); }, 0);
+                        if (!this.isCrypto) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._wrappedPrices()];
+                    case 1:
+                        prices_4 = _d.sent();
+                        totalAmountUSD = amounts.reduce(function (s, a, i) { return s + (Number(a) * prices_4[i]); }, 0);
                         _a = Number;
                         return [4 /*yield*/, this.addLiquidityWrappedExpected(amounts)];
-                    case 1:
-                        expected = _a.apply(void 0, [_c.sent()]);
+                    case 2:
+                        expected_2 = _a.apply(void 0, [_d.sent()]);
+                        return [4 /*yield*/, this._addLiquidityCryptoSlippage(totalAmountUSD, expected_2, false)];
+                    case 3: return [2 /*return*/, _d.sent()];
+                    case 4:
+                        totalAmount = amounts.reduce(function (s, a) { return s + Number(a); }, 0);
+                        _c = Number;
+                        return [4 /*yield*/, this.addLiquidityWrappedExpected(amounts)];
+                    case 5:
+                        expected = _c.apply(void 0, [_d.sent()]);
                         return [4 /*yield*/, this._addLiquiditySlippage(totalAmount, expected, false)];
-                    case 2: return [2 /*return*/, _c.sent()];
+                    case 6: return [2 /*return*/, _d.sent()];
                 }
             });
         }); };
@@ -1153,7 +1193,7 @@ var Pool = /** @class */ (function () {
             });
         }); };
         this.removeLiquidityOneCoinSlippage = function (lpTokenAmount, coin) { return __awaiter(_this, void 0, void 0, function () {
-            var totalAmount, _a;
+            var totalAmount, _a, coinPrice;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -1161,8 +1201,14 @@ var Pool = /** @class */ (function () {
                         return [4 /*yield*/, this.removeLiquidityOneCoinExpected(lpTokenAmount, coin)];
                     case 1:
                         totalAmount = _a.apply(void 0, [_c.sent()]);
-                        return [4 /*yield*/, this._removeLiquiditySlippage(totalAmount, Number(lpTokenAmount))];
-                    case 2: return [2 /*return*/, _c.sent()];
+                        if (!this.isCrypto) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._underlyingPrices()];
+                    case 2:
+                        coinPrice = (_c.sent())[this._getCoinIdx(coin)];
+                        return [4 /*yield*/, this._removeLiquidityCryptoSlippage(totalAmount * coinPrice, Number(lpTokenAmount))];
+                    case 3: return [2 /*return*/, _c.sent()];
+                    case 4: return [4 /*yield*/, this._removeLiquiditySlippage(totalAmount, Number(lpTokenAmount))];
+                    case 5: return [2 /*return*/, _c.sent()];
                 }
             });
         }); };
@@ -1286,7 +1332,7 @@ var Pool = /** @class */ (function () {
             });
         }); };
         this.removeLiquidityOneCoinWrappedSlippage = function (lpTokenAmount, coin) { return __awaiter(_this, void 0, void 0, function () {
-            var totalAmount, _a;
+            var totalAmount, _a, coinPrice;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -1297,8 +1343,14 @@ var Pool = /** @class */ (function () {
                         return [4 /*yield*/, this.removeLiquidityOneCoinWrappedExpected(lpTokenAmount, coin)];
                     case 1:
                         totalAmount = _a.apply(void 0, [_c.sent()]);
-                        return [4 /*yield*/, this._removeLiquiditySlippage(totalAmount, Number(lpTokenAmount), false)];
-                    case 2: return [2 /*return*/, _c.sent()];
+                        if (!this.isCrypto) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._underlyingPrices()];
+                    case 2:
+                        coinPrice = (_c.sent())[this._getCoinIdx(coin, false)];
+                        return [4 /*yield*/, this._removeLiquidityCryptoSlippage(totalAmount * coinPrice, Number(lpTokenAmount))];
+                    case 3: return [2 /*return*/, _c.sent()];
+                    case 4: return [4 /*yield*/, this._removeLiquiditySlippage(totalAmount, Number(lpTokenAmount), false)];
+                    case 5: return [2 /*return*/, _c.sent()];
                 }
             });
         }); };
@@ -2121,6 +2173,90 @@ var Pool = /** @class */ (function () {
                 });
             });
         };
+        this._underlyingPrices = function () { return __awaiter(_this, void 0, void 0, function () {
+            var promises, _i, _a, addr;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        promises = [];
+                        for (_i = 0, _a = this.underlyingCoinAddresses; _i < _a.length; _i++) {
+                            addr = _a[_i];
+                            promises.push((0, utils_1._getUsdRate)(addr));
+                        }
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        }); };
+        // NOTE! It may crash!
+        this._wrappedPrices = function () { return __awaiter(_this, void 0, void 0, function () {
+            var promises, _i, _a, addr;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        promises = [];
+                        for (_i = 0, _a = this.coinAddresses; _i < _a.length; _i++) {
+                            addr = _a[_i];
+                            promises.push((0, utils_1._getUsdRate)(addr));
+                        }
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        }); };
+        this._addLiquidityCryptoSlippage = function (totalAmountUSD, expected, useUnderlying) {
+            if (useUnderlying === void 0) { useUnderlying = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var poolBalances, _a, prices, _c, poolBalancesUSD, poolTotalBalance, poolBalancesRatios, balancedAmountsUSD, balancedAmounts, balancedExpected, _d, _e, _f;
+                return __generator(this, function (_h) {
+                    switch (_h.label) {
+                        case 0:
+                            if (!useUnderlying) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.getPoolBalances()];
+                        case 1:
+                            _a = (_h.sent()).map(Number);
+                            return [3 /*break*/, 4];
+                        case 2: return [4 /*yield*/, this.getPoolWrappedBalances()];
+                        case 3:
+                            _a = (_h.sent()).map(Number);
+                            _h.label = 4;
+                        case 4:
+                            poolBalances = _a;
+                            if (!useUnderlying) return [3 /*break*/, 6];
+                            return [4 /*yield*/, this._underlyingPrices()];
+                        case 5:
+                            _c = _h.sent();
+                            return [3 /*break*/, 8];
+                        case 6: return [4 /*yield*/, this._wrappedPrices()];
+                        case 7:
+                            _c = _h.sent();
+                            _h.label = 8;
+                        case 8:
+                            prices = _c;
+                            poolBalancesUSD = poolBalances.map(function (b, i) { return Number(b) * prices[i]; });
+                            poolTotalBalance = poolBalancesUSD.reduce(function (a, b) { return a + b; });
+                            poolBalancesRatios = poolBalancesUSD.map(function (b) { return b / poolTotalBalance; });
+                            balancedAmountsUSD = poolBalancesRatios.map(function (r) { return r * totalAmountUSD; });
+                            balancedAmounts = balancedAmountsUSD.map(function (a, i) { return String(a / prices[i]); });
+                            if (!useUnderlying) return [3 /*break*/, 10];
+                            _e = Number;
+                            return [4 /*yield*/, this.addLiquidityExpected(balancedAmounts)];
+                        case 9:
+                            _d = _e.apply(void 0, [_h.sent()]);
+                            return [3 /*break*/, 12];
+                        case 10:
+                            _f = Number;
+                            return [4 /*yield*/, this.addLiquidityWrappedExpected(balancedAmounts)];
+                        case 11:
+                            _d = _f.apply(void 0, [_h.sent()]);
+                            _h.label = 12;
+                        case 12:
+                            balancedExpected = _d;
+                            return [2 /*return*/, String((balancedExpected - expected) / balancedExpected)];
+                    }
+                });
+            });
+        };
         this._addLiquiditySlippage = function (totalAmount, expected, useUnderlying) {
             if (useUnderlying === void 0) { useUnderlying = true; }
             return __awaiter(_this, void 0, void 0, function () {
@@ -2161,6 +2297,41 @@ var Pool = /** @class */ (function () {
                 });
             });
         };
+        this._removeLiquidityCryptoSlippage = function (totalAmountUSD, lpTokenAmount, useUnderlying) {
+            if (useUnderlying === void 0) { useUnderlying = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var prices, _a, balancedAmounts, _c, balancedTotalAmountsUSD;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            if (!useUnderlying) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this._underlyingPrices()];
+                        case 1:
+                            _a = _d.sent();
+                            return [3 /*break*/, 4];
+                        case 2: return [4 /*yield*/, this._wrappedPrices()];
+                        case 3:
+                            _a = _d.sent();
+                            _d.label = 4;
+                        case 4:
+                            prices = _a;
+                            if (!useUnderlying) return [3 /*break*/, 6];
+                            return [4 /*yield*/, this.removeLiquidityExpected(String(lpTokenAmount))];
+                        case 5:
+                            _c = _d.sent();
+                            return [3 /*break*/, 8];
+                        case 6: return [4 /*yield*/, this.removeLiquidityWrappedExpected(String(lpTokenAmount))];
+                        case 7:
+                            _c = _d.sent();
+                            _d.label = 8;
+                        case 8:
+                            balancedAmounts = _c;
+                            balancedTotalAmountsUSD = balancedAmounts.reduce(function (s, b, i) { return s + (Number(b) * prices[i]); }, 0);
+                            return [2 /*return*/, String((balancedTotalAmountsUSD - totalAmountUSD) / balancedTotalAmountsUSD)];
+                    }
+                });
+            });
+        };
         this._removeLiquiditySlippage = function (totalAmount, expected, useUnderlying) {
             if (useUnderlying === void 0) { useUnderlying = true; }
             return __awaiter(_this, void 0, void 0, function () {
@@ -2202,7 +2373,8 @@ var Pool = /** @class */ (function () {
             });
         };
         this._balancedAmounts = function (poolBalances, walletBalances, decimals) {
-            var poolBalancesRatios = poolBalances.map(function (b) { return b / poolBalances.reduce(function (a, b) { return a + b; }); });
+            var poolTotalLiquidity = poolBalances.reduce(function (a, b) { return a + b; });
+            var poolBalancesRatios = poolBalances.map(function (b) { return b / poolTotalLiquidity; });
             // 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 balancedAmountsForEachScenario = walletBalances.map(function (_, i) { return (walletBalances.map(function (_, j) { return (poolBalancesRatios[j] * walletBalances[i] / poolBalancesRatios[i]); })); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curvefi/api",
-  "version": "1.16.0",
+  "version": "1.16.1",
   "description": "JavaScript library for curve.fi",
   "main": "lib/index.js",
   "scripts": {