@curvefi/api 2.61.14 → 2.62.0

package/README.md

@@ -1607,7 +1607,9 @@ import curve from "@curvefi/api";
     // factory-v2-221
     const pool = curve.getPool(poolId);
 
-    await pool.depositAndStake([10, 10, 10]); // Initial amounts for stable pool must be equal
+    const amounts = await pool.getSeedAmounts(10);
+    // [ '10.0', '10.0', '10.0' ]
+    await pool.depositAndStake(amounts);
     const balances = await pool.stats.underlyingBalances();
     // [ '10.0', '10.0', '10.0' ]
 })()
@@ -1748,17 +1750,19 @@ import curve from "@curvefi/api";
     const pool = curve.getPool(poolId);
 
     // Deposit & Stake Wrapped
-    
-    await pool.depositAndStakeWrapped([10, 10]); // Initial wrapped amounts for stable metapool must be equal
+
+    const amounts = await pool.getSeedAmounts(10);
+    // [ '10', '9.666800376685890985' ]
+    await pool.depositAndStakeWrapped(amounts);
     const balances = await pool.stats.wrappedBalances();
-    // [ '10.0', '10.0' ]
+    // [ '10', '9.666800376685890985' ]
 
     // Or deposit & Stake Underlying
 
-    // const amounts = pool.metaUnderlyingSeedAmounts(30);
-    // [ '30', '10.000000000000000000', '10.000000', '10.000000' ]
+    // const amounts = pool.getSeedAmounts(10, true);  // useUnderlying = true
+    // [ '10', '3.690404151768511181', '3.713621', '2.595975' ]
     // await pool.depositAndStake(amounts);
-    // [ '30.0', '9.272021785560442569', '8.927595', '11.800485' ]
+    // [ '10', '3.690404151768511181', '3.713621', '2.595975' ]
 })()
 ```
 
@@ -1891,7 +1895,7 @@ import curve from "@curvefi/api";
     // factory-crypto-155
     const pool = curve.getPool(poolId);
 
-    const amounts = await pool.cryptoSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
+    const amounts = await pool.getSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
     // [ '30', '0.02' ]
     await pool.depositAndStake(amounts);
     const underlyingBalances = await pool.stats.underlyingBalances();
@@ -1943,7 +1947,7 @@ import curve from "@curvefi/api";
     // factory-twocrypto-155
     const pool = curve.getPool(poolId);
 
-    const amounts = await pool.cryptoSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
+    const amounts = await pool.getSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
     // [ '30', '0.02' ]
     await pool.depositAndStake(amounts);
     const underlyingBalances = await pool.stats.underlyingBalances();
@@ -2030,7 +2034,7 @@ import curve from "@curvefi/api";
     // factory-tricrypto-2
     const pool = curve.getPool(poolId);
 
-    const amounts = await pool.cryptoSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
+    const amounts = await pool.getSeedAmounts(30); // Initial amounts for crypto pools must have the ratio corresponding to initialPrice
     // [ '30', '0.017647058823529412', '0.00111111' ]
     await pool.depositAndStake(amounts);
     const underlyingBalances = await pool.stats.underlyingBalances();

package/lib/pools/PoolTemplate.d.ts

@@ -112,8 +112,7 @@ export declare class PoolTemplate {
     private _calcLpTokenAmount;
     private calcLpTokenAmount;
     private calcLpTokenAmountWrapped;
-    metaUnderlyingSeedAmounts(amount1: number | string): string[];
-    cryptoSeedAmounts(amount1: number | string): Promise<string[]>;
+    getSeedAmounts(amount1: number | string, useUnderlying?: boolean): Promise<string[]>;
     depositBalancedAmounts(): Promise<string[]>;
     depositExpected(amounts: (number | string)[]): Promise<string>;
     private _balancedAmountsWithSameValue;
@@ -260,7 +259,7 @@ export declare class PoolTemplate {
     private _getCoinIdx;
     private _getRates;
     private _balances;
-    private _stored_rates;
+    private _storedRatesBN;
     private _underlyingPrices;
     private _wrappedPrices;
     private getGaugeStatus;

package/lib/pools/PoolTemplate.js

@@ -412,7 +412,7 @@ var PoolTemplate = /** @class */ (function () {
             if (isDeposit === void 0) { isDeposit = true; }
             if (useUnderlying === void 0) { useUnderlying = true; }
             return __awaiter(_this, void 0, void 0, function () {
-                var e_2, lpContract, _lpTotalSupply, decimals_1, amounts, seedAmounts_1, contract, basePool, e_3, lpContract, _lpTotalSupply, decimals_2, amounts_1, seedAmounts_2, _amounts18Decimals;
+                var e_2, lpContract, _lpTotalSupply, decimals_1, amounts, seedAmounts_1, contract, basePool, e_3, lpContract, _lpTotalSupply, decimals_2, amounts, seedAmounts_2, _amounts18Decimals;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
                         case 0:
@@ -434,7 +434,7 @@ var PoolTemplate = /** @class */ (function () {
                                 throw Error("Initial deposit for crypto meta pools must be in wrapped coins");
                             decimals_1 = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
                             amounts = _amounts.map(function (_a, i) { return curve.formatUnits(_a, decimals_1[i]); });
-                            return [4 /*yield*/, this.cryptoSeedAmounts(amounts[0])];
+                            return [4 /*yield*/, this.getSeedAmounts(amounts[0])];
                         case 5:
                             seedAmounts_1 = _c.sent();
                             amounts.forEach(function (a, i) {
@@ -443,7 +443,7 @@ var PoolTemplate = /** @class */ (function () {
                             });
                             return [2 /*return*/, parseUnits(Math.pow(amounts.map(Number).reduce(function (a, b) { return a * b; }), 1 / amounts.length))];
                         case 6:
-                            _c.trys.push([6, 13, , 15]);
+                            _c.trys.push([6, 13, , 16]);
                             contract = curve.contracts[curve.constants.ALIASES.stable_calc].contract;
                             if (!(curve.constants.ALIASES.stable_calc === curve.constants.ZERO_ADDRESS || this.id.startsWith("factory-stable-ng"))) return [3 /*break*/, 8];
                             return [4 /*yield*/, this._pureCalcLpTokenAmount(_amounts, isDeposit, useUnderlying)];
@@ -455,7 +455,7 @@ var PoolTemplate = /** @class */ (function () {
                         case 9: return [2 /*return*/, _c.sent()];
                         case 10: return [4 /*yield*/, contract.calc_token_amount(this.address, this.lpToken, _amounts.concat(Array(10 - _amounts.length).fill(curve.parseUnits("0"))), _amounts.length, isDeposit, useUnderlying && this.isLending)];
                         case 11: return [2 /*return*/, _c.sent()];
-                        case 12: return [3 /*break*/, 15];
+                        case 12: return [3 /*break*/, 16];
                         case 13:
                             e_3 = _c.sent();
                             if (!isDeposit)
@@ -467,25 +467,17 @@ var PoolTemplate = /** @class */ (function () {
                             if (_lpTotalSupply > curve.parseUnits("0"))
                                 throw e_3; // Already seeded
                             decimals_2 = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
-                            amounts_1 = _amounts.map(function (_a, i) { return curve.formatUnits(_a, decimals_2[i]); });
-                            if (this.isMeta && useUnderlying) {
-                                seedAmounts_2 = this.metaUnderlyingSeedAmounts(amounts_1[0]);
-                                amounts_1.forEach(function (a, i) {
-                                    if (!BN(a).eq(BN(seedAmounts_2[i])))
-                                        throw Error("Amounts must be = ".concat(seedAmounts_2));
-                                });
-                            }
-                            else {
-                                if (_amounts[0] <= curve.parseUnits("0"))
-                                    throw Error("Initial deposit amounts must be > 0");
-                                amounts_1.forEach(function (a) {
-                                    if (a !== amounts_1[0])
-                                        throw Error("Initial deposit amounts must be equal");
-                                });
-                            }
-                            _amounts18Decimals = amounts_1.map(function (a) { return parseUnits(a); });
+                            amounts = _amounts.map(function (_a, i) { return curve.formatUnits(_a, decimals_2[i]); });
+                            return [4 /*yield*/, this.getSeedAmounts(amounts[0])];
+                        case 15:
+                            seedAmounts_2 = _c.sent();
+                            amounts.forEach(function (a, i) {
+                                if (!BN(a).eq(BN(seedAmounts_2[i])))
+                                    throw Error("Amounts must be = ".concat(seedAmounts_2));
+                            });
+                            _amounts18Decimals = amounts.map(function (a) { return parseUnits(a); });
                             return [2 /*return*/, _amounts18Decimals.reduce(function (_a, _b) { return _a + _b; })];
-                        case 15: return [2 /*return*/];
+                        case 16: return [2 /*return*/];
                     }
                 });
             });
@@ -1110,11 +1102,27 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
-        this._stored_rates = function () { return __awaiter(_this, void 0, void 0, function () {
+        this._storedRatesBN = function (useUnderlying) { return __awaiter(_this, void 0, void 0, function () {
+            var _vp, isUseStoredRates, _stored_rates;
+            var _this = this;
             return __generator(this, function (_c) {
                 switch (_c.label) {
-                    case 0: return [4 /*yield*/, curve.contracts[this.address].contract.stored_rates()];
-                    case 1: return [2 /*return*/, _c.sent()];
+                    case 0:
+                        if (!this.isMeta) return [3 /*break*/, 2];
+                        if (useUnderlying)
+                            return [2 /*return*/, this.underlyingCoins.map(function () { return BN(1); })];
+                        return [4 /*yield*/, curve.contracts[curve.getPoolsData()[this.basePool].swap_address].contract.get_virtual_price()];
+                    case 1:
+                        _vp = _c.sent();
+                        return [2 /*return*/, [BN(1), toBN(_vp)]];
+                    case 2:
+                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        if (!isUseStoredRates) return [3 /*break*/, 4];
+                        return [4 /*yield*/, curve.contracts[this.address].contract.stored_rates()];
+                    case 3:
+                        _stored_rates = _c.sent();
+                        return [2 /*return*/, _stored_rates.map(function (_r, i) { return toBN(_r, 36 - _this.wrappedDecimals[i]); })];
+                    case 4: return [2 /*return*/, this.wrappedCoins.map(function () { return BN(1); })];
                 }
             });
         }); };
@@ -1374,32 +1382,18 @@ var PoolTemplate = /** @class */ (function () {
         });
     };
     // ---------------- DEPOSIT ----------------
-    PoolTemplate.prototype.metaUnderlyingSeedAmounts = function (amount1) {
-        if (this.isCrypto)
-            throw Error("Use cryptoSeedAmounts method for ".concat(this.name, " pool"));
-        if (!this.isMeta)
-            throw Error("metaUnderlyingSeedAmounts method exists only for meta stable pools");
-        var amount1BN = BN(amount1);
-        if (amount1BN.lte(0))
-            throw Error("Initial deposit amounts must be > 0");
-        var amounts = [_cutZeros(amount1BN.toFixed(this.underlyingDecimals[0]))];
-        for (var i = 1; i < this.underlyingDecimals.length; i++) {
-            amounts.push(amount1BN.div(this.underlyingDecimals.length - 1).toFixed(this.underlyingDecimals[i]));
-        }
-        return amounts;
-    };
-    PoolTemplate.prototype.cryptoSeedAmounts = function (amount1) {
+    PoolTemplate.prototype.getSeedAmounts = function (amount1, useUnderlying) {
+        if (useUnderlying === void 0) { useUnderlying = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var decimals, amount1BN, priceScaleBN, _c, priceScaleBN;
+            var amount1BN, decimals, priceScaleBN, _c, priceScaleBN, amounts, basePool, basePoolBalancesBN, totalBN, i, storedRatesBN, i;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
-                        if (!this.isCrypto)
-                            throw Error("cryptoSeedAmounts method doesn't exist for stable pools");
-                        decimals = this.isMeta ? this.wrappedDecimals : this.underlyingDecimals;
                         amount1BN = BN(amount1);
                         if (amount1BN.lte(0))
                             throw Error("Initial deposit amounts must be > 0");
+                        if (!this.isCrypto) return [3 /*break*/, 5];
+                        decimals = this.isMeta ? this.wrappedDecimals : this.underlyingDecimals;
                         if (!(decimals.length === 2)) return [3 /*break*/, 2];
                         _c = toBN;
                         return [4 /*yield*/, curve.contracts[this.address].contract.price_scale(curve.constantOptions)];
@@ -1419,7 +1413,26 @@ var PoolTemplate = /** @class */ (function () {
                                 _cutZeros(amount1BN.div(priceScaleBN[0]).toFixed(decimals[1])),
                                 _cutZeros(amount1BN.div(priceScaleBN[1]).toFixed(decimals[2])),
                             ]];
-                    case 4: throw Error("cryptoSeedAmounts method doesn't exist for pools with N coins > 3");
+                    case 4: throw Error("getSeedAmounts method doesn't exist for crypto pools with N coins > 3");
+                    case 5:
+                        amounts = [_cutZeros(amount1BN.toFixed(this.wrappedDecimals[0]))];
+                        if (!(this.isMeta && useUnderlying)) return [3 /*break*/, 7];
+                        basePool = new PoolTemplate(this.basePool);
+                        return [4 /*yield*/, basePool.stats.underlyingBalances()];
+                    case 6:
+                        basePoolBalancesBN = (_d.sent()).map(BN);
+                        totalBN = basePoolBalancesBN.reduce(function (a, b) { return a.plus(b); });
+                        for (i = 1; i < this.underlyingDecimals.length; i++) {
+                            amounts.push(amount1BN.times(basePoolBalancesBN[i - 1]).div(totalBN).toFixed(this.underlyingDecimals[i]));
+                        }
+                        return [2 /*return*/, amounts.map(_cutZeros)];
+                    case 7: return [4 /*yield*/, this._storedRatesBN(false)];
+                    case 8:
+                        storedRatesBN = _d.sent();
+                        for (i = 1; i < this.wrappedDecimals.length; i++) {
+                            amounts.push(amount1BN.times(storedRatesBN[0]).div(storedRatesBN[i]).toFixed(this.wrappedDecimals[i]));
+                        }
+                        return [2 /*return*/, amounts.map(_cutZeros)];
                 }
             });
         });
@@ -1470,46 +1483,34 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.depositBonus = function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var amountsBN, prices, isUseStoredRates, result, pricesBN, balancesBN, balancedAmounts, expectedBN, _c, balancedExpectedBN, _d;
-            var _this = this;
+            var amountsBN, pricesBN, balancesBN, balancedAmounts, expectedBN, _c, balancedExpectedBN, _d;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
                         amountsBN = amounts.map(BN);
-                        prices = [];
-                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        pricesBN = [];
                         if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this._underlyingPrices()];
                     case 1:
-                        prices = _e.sent();
-                        return [3 /*break*/, 5];
-                    case 2:
-                        if (!isUseStoredRates) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this._stored_rates()];
+                        pricesBN = (_e.sent()).map(BN);
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._storedRatesBN(true)];
                     case 3:
-                        result = _e.sent();
-                        result.forEach(function (item, index) {
-                            prices.push(Number(item) / (Math.pow(10, (36 - _this.underlyingDecimals[index]))));
-                        });
-                        return [3 /*break*/, 5];
-                    case 4:
-                        prices = this.underlyingCoins.map(function () { return 1; });
-                        _e.label = 5;
+                        pricesBN = _e.sent();
+                        _e.label = 4;
+                    case 4: return [4 /*yield*/, this.stats.underlyingBalances()];
                     case 5:
-                        pricesBN = prices.map(BN);
-                        return [4 /*yield*/, this.stats.underlyingBalances()];
-                    case 6:
                         balancesBN = (_e.sent()).map(BN);
                         balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
                         _c = BN;
                         return [4 /*yield*/, this.depositExpected(amounts)];
-                    case 7:
+                    case 6:
                         expectedBN = _c.apply(void 0, [_e.sent()]);
                         _d = BN;
                         return [4 /*yield*/, this.depositExpected(balancedAmounts)];
-                    case 8:
+                    case 7:
                         balancedExpectedBN = _d.apply(void 0, [_e.sent()]);
-                        return [2 /*return*/, String(expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100))];
+                        return [2 /*return*/, expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100).toString()];
                 }
             });
         });
@@ -2468,40 +2469,30 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.withdrawImbalanceBonus = function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var prices, isUseStoredRates, result, value, lpTokenAmount, balancedAmounts, balancedValue;
-            var _this = this;
+            var pricesBN, valueBN, lpTokenAmount, balancedAmounts, balancedValueBN;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        prices = [];
-                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        pricesBN = [];
                         if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this._underlyingPrices()];
                     case 1:
-                        prices = _c.sent();
-                        return [3 /*break*/, 5];
-                    case 2:
-                        if (!isUseStoredRates) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this._stored_rates()];
+                        pricesBN = (_c.sent()).map(BN);
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._storedRatesBN(true)];
                     case 3:
-                        result = _c.sent();
-                        result.forEach(function (item, index) {
-                            prices.push(Number(item) / (Math.pow(10, (36 - _this.underlyingDecimals[index]))));
-                        });
-                        return [3 /*break*/, 5];
+                        pricesBN = _c.sent();
+                        _c.label = 4;
                     case 4:
-                        prices = this.underlyingCoins.map(function () { return 1; });
-                        _c.label = 5;
-                    case 5:
-                        value = amounts.map(checkNumber).map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
+                        valueBN = amounts.map(BN).reduce(function (sBN, aBN, i) { return pricesBN[i].times(aBN).plus(sBN); }, BN(0));
                         return [4 /*yield*/, this.withdrawImbalanceExpected(amounts)];
-                    case 6:
+                    case 5:
                         lpTokenAmount = _c.sent();
                         return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
-                    case 7:
+                    case 6:
                         balancedAmounts = _c.sent();
-                        balancedValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [2 /*return*/, String((value - balancedValue) / balancedValue * 100)];
+                        balancedValueBN = balancedAmounts.map(BN).reduce(function (sBN, aBN, i) { return pricesBN[i].times(aBN).plus(sBN); }, BN(0));
+                        return [2 /*return*/, valueBN.minus(balancedValueBN).div(balancedValueBN).times(100).toString()];
                 }
             });
         });
@@ -2666,42 +2657,32 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.withdrawOneCoinBonus = function (lpTokenAmount, coin) {
         return __awaiter(this, void 0, void 0, function () {
-            var prices, isUseStoredRates, result, coinPrice, amount, _c, value, balancedAmounts, balancedValue;
-            var _this = this;
+            var pricesBN, coinPriceBN, amountBN, _c, valueBN, balancedAmounts, balancedValueBN;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
-                        prices = [];
-                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        pricesBN = [];
                         if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this._underlyingPrices()];
                     case 1:
-                        prices = _d.sent();
-                        return [3 /*break*/, 5];
-                    case 2:
-                        if (!isUseStoredRates) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this._stored_rates()];
+                        pricesBN = (_d.sent()).map(BN);
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._storedRatesBN(true)];
                     case 3:
-                        result = _d.sent();
-                        result.forEach(function (item, index) {
-                            prices.push(Number(item) / (Math.pow(10, (36 - _this.underlyingDecimals[index]))));
-                        });
-                        return [3 /*break*/, 5];
+                        pricesBN = _d.sent();
+                        _d.label = 4;
                     case 4:
-                        prices = this.underlyingCoins.map(function () { return 1; });
-                        _d.label = 5;
-                    case 5:
-                        coinPrice = prices[this._getCoinIdx(coin)];
-                        _c = Number;
+                        coinPriceBN = pricesBN[this._getCoinIdx(coin)];
+                        _c = BN;
                         return [4 /*yield*/, this.withdrawOneCoinExpected(lpTokenAmount, coin)];
-                    case 6:
-                        amount = _c.apply(void 0, [_d.sent()]);
-                        value = amount * coinPrice;
+                    case 5:
+                        amountBN = _c.apply(void 0, [_d.sent()]);
+                        valueBN = amountBN.times(coinPriceBN);
                         return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
-                    case 7:
+                    case 6:
                         balancedAmounts = _d.sent();
-                        balancedValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
-                        return [2 /*return*/, String((value - balancedValue) / balancedValue * 100)];
+                        balancedValueBN = balancedAmounts.map(BN).reduce(function (sBN, aBN, i) { return pricesBN[i].times(aBN).plus(sBN); }, BN(0));
+                        return [2 /*return*/, valueBN.minus(balancedValueBN).div(balancedValueBN).times(100).toString()];
                 }
             });
         });

package/lib/utils.js

@@ -69,7 +69,7 @@ export var ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 export var MAX_ALLOWANCE = BigInt("115792089237316195423570985008687907853269984665640564039457584007913129639935"); // 2**256 - 1
 // Formatting numbers
 export var _cutZeros = function (strn) {
-    return strn.replace(/0+$/gi, '').replace(/\.$/gi, '');
+    return strn.replace(/(\.\d*[1-9])0+$/gi, '$1').replace(/\.0+$/gi, '');
 };
 export var checkNumber = function (n) {
     if (Number(n) !== Number(n))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curvefi/api",
-  "version": "2.61.14",
+  "version": "2.62.0",
   "description": "JavaScript library for curve.fi",
   "main": "lib/index.js",
   "author": "Macket",