@curvefi/api 2.4.1 → 2.4.2

package/lib/pools/PoolTemplate.d.ts

@@ -238,6 +238,4 @@ export declare class PoolTemplate {
     private _balances;
     private _underlyingPrices;
     private _wrappedPrices;
-    private _withdrawCryptoBonus;
-    private _withdrawBonus;
 }

package/lib/pools/PoolTemplate.js

@@ -842,6 +842,7 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
+        // Used by mixin. Don't delete it!!!
         this._underlyingPrices = function () { return __awaiter(_this, void 0, void 0, function () {
             var promises, _i, _a, addr;
             return __generator(this, function (_c) {
@@ -857,6 +858,7 @@ var PoolTemplate = /** @class */ (function () {
                 }
             });
         }); };
+        // Used by mixin. Don't delete it!!!
         // NOTE! It may crash!
         this._wrappedPrices = function () { return __awaiter(_this, void 0, void 0, function () {
             var promises, _i, _a, addr;
@@ -873,82 +875,6 @@ var PoolTemplate = /** @class */ (function () {
                 }
             });
         }); };
-        this._withdrawCryptoBonus = 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.withdrawExpected(String(lpTokenAmount))];
-                        case 5:
-                            _c = _d.sent();
-                            return [3 /*break*/, 8];
-                        case 6: return [4 /*yield*/, this.withdrawWrappedExpected(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((totalAmountUSD - balancedTotalAmountsUSD) / totalAmountUSD * 100)];
-                    }
-                });
-            });
-        };
-        // TODO make the same as _withdrawCryptoBonus
-        this._withdrawBonus = function (totalAmount, expected, useUnderlying) {
-            if (useUnderlying === void 0) { useUnderlying = true; }
-            return __awaiter(_this, void 0, void 0, function () {
-                var poolBalances, _a, poolTotalBalance, poolBalancesRatios, balancedAmounts, balancedExpected, _c, _d, _e;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
-                        case 0:
-                            if (!useUnderlying) return [3 /*break*/, 2];
-                            return [4 /*yield*/, this.stats.underlyingBalances()];
-                        case 1:
-                            _a = (_f.sent()).map(Number);
-                            return [3 /*break*/, 4];
-                        case 2: return [4 /*yield*/, this.stats.wrappedBalances()];
-                        case 3:
-                            _a = (_f.sent()).map(Number);
-                            _f.label = 4;
-                        case 4:
-                            poolBalances = _a;
-                            poolTotalBalance = poolBalances.reduce(function (a, b) { return a + b; });
-                            poolBalancesRatios = poolBalances.map(function (b) { return b / poolTotalBalance; });
-                            balancedAmounts = poolBalancesRatios.map(function (r) { return String(r * totalAmount); });
-                            if (!useUnderlying) return [3 /*break*/, 6];
-                            _d = Number;
-                            return [4 /*yield*/, this.withdrawImbalanceExpected(balancedAmounts)];
-                        case 5:
-                            _c = _d.apply(void 0, [_f.sent()]);
-                            return [3 /*break*/, 8];
-                        case 6:
-                            _e = Number;
-                            return [4 /*yield*/, this.withdrawImbalanceWrappedExpected(balancedAmounts)];
-                        case 7:
-                            _c = _e.apply(void 0, [_f.sent()]);
-                            _f.label = 8;
-                        case 8:
-                            balancedExpected = _c;
-                            return [2 /*return*/, String((balancedExpected - expected) / balancedExpected * 100)];
-                    }
-                });
-            });
-        };
         var poolData = __assign(__assign(__assign({}, curve_1.curve.constants.POOLS_DATA), curve_1.curve.constants.FACTORY_POOLS_DATA), curve_1.curve.constants.CRYPTO_FACTORY_POOLS_DATA)[id];
         this.id = id;
         this.name = poolData.name;
@@ -2041,22 +1967,11 @@ var PoolTemplate = /** @class */ (function () {
             });
         });
     };
+    // OVERRIDE
     PoolTemplate.prototype.withdrawImbalanceBonus = function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var totalAmount, expected, _a;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isCrypto)
-                            throw Error("withdrawImbalanceBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        totalAmount = amounts.map(utils_1.checkNumber).map(Number).reduce(function (a, b) { return a + b; });
-                        _a = Number;
-                        return [4 /*yield*/, this.withdrawImbalanceExpected(amounts)];
-                    case 1:
-                        expected = _a.apply(void 0, [_c.sent()]);
-                        return [4 /*yield*/, this._withdrawBonus(totalAmount, expected)];
-                    case 2: return [2 /*return*/, _c.sent()];
-                }
+            return __generator(this, function (_a) {
+                throw Error("withdrawImbalanceBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
             });
         });
     };
@@ -2154,22 +2069,11 @@ var PoolTemplate = /** @class */ (function () {
             });
         });
     };
+    // OVERRIDE
     PoolTemplate.prototype.withdrawImbalanceWrappedBonus = function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var totalAmount, expected, _a;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isCrypto)
-                            throw Error("withdrawImbalanceWrappedBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
-                        totalAmount = amounts.map(utils_1.checkNumber).map(Number).reduce(function (a, b) { return a + b; });
-                        _a = Number;
-                        return [4 /*yield*/, this.withdrawImbalanceWrappedExpected(amounts)];
-                    case 1:
-                        expected = _a.apply(void 0, [_c.sent()]);
-                        return [4 /*yield*/, this._withdrawBonus(totalAmount, expected, false)];
-                    case 2: return [2 /*return*/, _c.sent()];
-                }
+            return __generator(this, function (_a) {
+                throw Error("withdrawImbalanceWrappedBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
             });
         });
     };
@@ -2215,25 +2119,11 @@ var PoolTemplate = /** @class */ (function () {
             });
         });
     };
+    // OVERRIDE
     PoolTemplate.prototype.withdrawOneCoinBonus = function (lpTokenAmount, coin) {
         return __awaiter(this, void 0, void 0, function () {
-            var totalAmount, _a, coinPrice;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = Number;
-                        return [4 /*yield*/, this.withdrawOneCoinExpected(lpTokenAmount, coin)];
-                    case 1:
-                        totalAmount = _a.apply(void 0, [_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._withdrawCryptoBonus(totalAmount * coinPrice, Number(lpTokenAmount))];
-                    case 3: return [2 /*return*/, _c.sent()];
-                    case 4: return [4 /*yield*/, this._withdrawBonus(totalAmount, Number(lpTokenAmount))];
-                    case 5: return [2 /*return*/, _c.sent()];
-                }
+            return __generator(this, function (_a) {
+                throw Error("withdrawOneCoinBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
             });
         });
     };
@@ -2318,28 +2208,11 @@ var PoolTemplate = /** @class */ (function () {
             });
         });
     };
+    // OVERRIDE
     PoolTemplate.prototype.withdrawOneCoinWrappedBonus = function (lpTokenAmount, coin) {
         return __awaiter(this, void 0, void 0, function () {
-            var totalAmount, _a, coinPrice;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.isFake || this.isPlain) {
-                            throw Error("".concat(this.name, " pool doesn't have this method"));
-                        }
-                        _a = Number;
-                        return [4 /*yield*/, this.withdrawOneCoinWrappedExpected(lpTokenAmount, coin)];
-                    case 1:
-                        totalAmount = _a.apply(void 0, [_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._withdrawCryptoBonus(totalAmount * coinPrice, Number(lpTokenAmount))];
-                    case 3: return [2 /*return*/, _c.sent()];
-                    case 4: return [4 /*yield*/, this._withdrawBonus(totalAmount, Number(lpTokenAmount), false)];
-                    case 5: return [2 /*return*/, _c.sent()];
-                }
+            return __generator(this, function (_a) {
+                throw Error("withdrawOneCoinWrappedBonus method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, ")"));
             });
         });
     };

package/lib/pools/mixins/depositBonusMixins.js

@@ -37,6 +37,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.depositWrappedBonusCryptoMixin = exports.depositBonusCryptoMixin = exports.depositWrappedBonusMixin = exports.depositBonusMixin = void 0;
+var ethers_1 = require("ethers");
+var curve_1 = require("../../curve");
 var utils_1 = require("../../utils");
 // @ts-ignore
 exports.depositBonusMixin = {
@@ -71,25 +73,38 @@ exports.depositBonusMixin = {
 exports.depositWrappedBonusMixin = {
     depositWrappedBonus: function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var totalAmount, expected, _a, poolBalances, poolTotalBalance, poolBalancesRatios, balancedAmounts, balancedExpected, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var vp, basePoolAddress, _a, _b, _c, prices, totalValue, expected, _d, poolBalances, poolValues, poolTotalValue, poolRatios, balancedValues, balancedAmounts, balancedExpected, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
-                        totalAmount = amounts.map(utils_1.checkNumber).map(Number).reduce(function (a, b) { return a + b; });
+                        vp = 1;
+                        if (!this.isMeta) return [3 /*break*/, 2];
+                        basePoolAddress = curve_1.curve.constants.POOLS_DATA[this.basePool].swap_address;
                         _a = Number;
-                        return [4 /*yield*/, this.depositWrappedExpected(amounts)];
+                        _c = (_b = ethers_1.ethers.utils).formatUnits;
+                        return [4 /*yield*/, curve_1.curve.contracts[basePoolAddress].contract.get_virtual_price(curve_1.curve.constantOptions)];
                     case 1:
-                        expected = _a.apply(void 0, [_c.sent()]);
-                        return [4 /*yield*/, this.stats.wrappedBalances()];
+                        vp = _a.apply(void 0, [_c.apply(_b, [_f.sent()])]);
+                        _f.label = 2;
                     case 2:
-                        poolBalances = (_c.sent()).map(Number);
-                        poolTotalBalance = poolBalances.reduce(function (a, b) { return a + b; });
-                        poolBalancesRatios = poolBalances.map(function (b) { return b / poolTotalBalance; });
-                        balancedAmounts = poolBalancesRatios.map(function (r) { return r * totalAmount; });
-                        _b = Number;
-                        return [4 /*yield*/, this.depositWrappedExpected(balancedAmounts)];
+                        prices = this.wrappedCoins.map(function (_, i, arr) { return i === arr.length - 1 ? vp : 1; });
+                        totalValue = amounts.map(utils_1.checkNumber).map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
+                        _d = Number;
+                        return [4 /*yield*/, this.depositWrappedExpected(amounts)];
                     case 3:
-                        balancedExpected = _b.apply(void 0, [_c.sent()]);
+                        expected = _d.apply(void 0, [_f.sent()]);
+                        return [4 /*yield*/, this.stats.wrappedBalances()];
+                    case 4:
+                        poolBalances = (_f.sent()).map(Number);
+                        poolValues = poolBalances.map(function (b, i) { return b * prices[i]; });
+                        poolTotalValue = poolValues.reduce(function (a, b) { return a + b; });
+                        poolRatios = poolValues.map(function (b) { return b / poolTotalValue; });
+                        balancedValues = poolRatios.map(function (r) { return r * totalValue; });
+                        balancedAmounts = balancedValues.map(function (a, i) { return a / prices[i]; });
+                        _e = Number;
+                        return [4 /*yield*/, this.depositWrappedExpected(balancedAmounts)];
+                    case 5:
+                        balancedExpected = _e.apply(void 0, [_f.sent()]);
                         return [2 /*return*/, String((expected - balancedExpected) / expected * 100)];
                 }
             });
@@ -133,29 +148,40 @@ exports.depositBonusCryptoMixin = {
 exports.depositWrappedBonusCryptoMixin = {
     depositWrappedBonus: function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var prices, totalAmountUSD, expected, _a, poolBalances, poolBalancesUSD, poolTotalBalance, poolBalancesRatios, balancedAmountsUSD, balancedAmounts, balancedExpected, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var prices, vp, basePoolAddress, _a, _b, _c, totalAmountUSD, expected, _d, poolBalances, poolBalancesUSD, poolTotalBalance, poolBalancesRatios, balancedAmountsUSD, balancedAmounts, balancedExpected, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0: return [4 /*yield*/, this._wrappedPrices()];
                     case 1:
-                        prices = _c.sent();
-                        totalAmountUSD = amounts.map(utils_1.checkNumber).map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
+                        prices = _f.sent();
+                        vp = 1;
+                        if (!this.isMeta) return [3 /*break*/, 3];
+                        basePoolAddress = curve_1.curve.constants.POOLS_DATA[this.basePool].swap_address;
                         _a = Number;
-                        return [4 /*yield*/, this.depositWrappedExpected(amounts)];
+                        _c = (_b = ethers_1.ethers.utils).formatUnits;
+                        return [4 /*yield*/, curve_1.curve.contracts[basePoolAddress].contract.get_virtual_price(curve_1.curve.constantOptions)];
                     case 2:
-                        expected = _a.apply(void 0, [_c.sent()]);
-                        return [4 /*yield*/, this.stats.wrappedBalances()];
+                        vp = _a.apply(void 0, [_c.apply(_b, [_f.sent()])]);
+                        _f.label = 3;
                     case 3:
-                        poolBalances = (_c.sent()).map(Number);
+                        prices = prices.map(function (p, i) { return i === prices.length - 1 ? p * vp : p; });
+                        totalAmountUSD = amounts.map(utils_1.checkNumber).map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
+                        _d = Number;
+                        return [4 /*yield*/, this.depositWrappedExpected(amounts)];
+                    case 4:
+                        expected = _d.apply(void 0, [_f.sent()]);
+                        return [4 /*yield*/, this.stats.wrappedBalances()];
+                    case 5:
+                        poolBalances = (_f.sent()).map(Number);
                         poolBalancesUSD = poolBalances.map(function (b, i) { return 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 a / prices[i]; });
-                        _b = Number;
+                        _e = Number;
                         return [4 /*yield*/, this.depositWrappedExpected(balancedAmounts)];
-                    case 4:
-                        balancedExpected = _b.apply(void 0, [_c.sent()]);
+                    case 6:
+                        balancedExpected = _e.apply(void 0, [_f.sent()]);
                         return [2 /*return*/, String((expected - balancedExpected) / expected * 100)];
                 }
             });

package/lib/pools/mixins/withdrawBonusMixins.d.ts

@@ -0,0 +1,7 @@
+import { PoolTemplate } from "../PoolTemplate";
+export declare const withdrawImbalanceBonusMixin: PoolTemplate;
+export declare const withdrawImbalanceWrappedBonusMixin: PoolTemplate;
+export declare const withdrawOneCoinBonusMixin: PoolTemplate;
+export declare const withdrawOneCoinWrappedBonusMixin: PoolTemplate;
+export declare const withdrawOneCoinCryptoBonusMixin: PoolTemplate;
+export declare const withdrawOneCoinWrappedCryptoBonusMixin: PoolTemplate;

package/lib/pools/mixins/withdrawBonusMixins.js

@@ -0,0 +1,216 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawOneCoinWrappedCryptoBonusMixin = exports.withdrawOneCoinCryptoBonusMixin = exports.withdrawOneCoinWrappedBonusMixin = exports.withdrawOneCoinBonusMixin = exports.withdrawImbalanceWrappedBonusMixin = exports.withdrawImbalanceBonusMixin = void 0;
+var ethers_1 = require("ethers");
+var curve_1 = require("../../curve");
+var utils_1 = require("../../utils");
+// @ts-ignore
+exports.withdrawImbalanceBonusMixin = {
+    withdrawImbalanceBonus: function (amounts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var totalAmount, lpTokenAmount, balancedAmounts, balancedTotalAmount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        totalAmount = amounts.map(utils_1.checkNumber).map(Number).reduce(function (a, b) { return a + b; });
+                        return [4 /*yield*/, this.withdrawImbalanceExpected(amounts)];
+                    case 1:
+                        lpTokenAmount = _a.sent();
+                        return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
+                    case 2:
+                        balancedAmounts = _a.sent();
+                        balancedTotalAmount = balancedAmounts.map(Number).reduce(function (a, b) { return a + b; });
+                        return [2 /*return*/, String((totalAmount - balancedTotalAmount) / Math.max(totalAmount, balancedTotalAmount) * 100)];
+                }
+            });
+        });
+    },
+};
+// @ts-ignore
+exports.withdrawImbalanceWrappedBonusMixin = {
+    withdrawImbalanceWrappedBonus: function (amounts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var vp, basePoolAddress, _a, _b, _c, prices, totalValue, lpTokenAmount, _d, balancedAmounts, balancedTotalValue;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        vp = 1;
+                        if (!this.isMeta) return [3 /*break*/, 2];
+                        basePoolAddress = curve_1.curve.constants.POOLS_DATA[this.basePool].swap_address;
+                        _a = Number;
+                        _c = (_b = ethers_1.ethers.utils).formatUnits;
+                        return [4 /*yield*/, curve_1.curve.contracts[basePoolAddress].contract.get_virtual_price(curve_1.curve.constantOptions)];
+                    case 1:
+                        vp = _a.apply(void 0, [_c.apply(_b, [_e.sent()])]);
+                        _e.label = 2;
+                    case 2:
+                        prices = this.wrappedCoins.map(function (_, i, arr) { return i === arr.length - 1 ? vp : 1; });
+                        totalValue = amounts.map(utils_1.checkNumber).map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
+                        _d = Number;
+                        return [4 /*yield*/, this.withdrawImbalanceWrappedExpected(amounts)];
+                    case 3:
+                        lpTokenAmount = _d.apply(void 0, [_e.sent()]);
+                        return [4 /*yield*/, this.withdrawWrappedExpected(lpTokenAmount)];
+                    case 4:
+                        balancedAmounts = _e.sent();
+                        balancedTotalValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
+                        return [2 /*return*/, String((totalValue - balancedTotalValue) / Math.max(totalValue, balancedTotalValue) * 100)];
+                }
+            });
+        });
+    },
+};
+// @ts-ignore
+exports.withdrawOneCoinBonusMixin = {
+    withdrawOneCoinBonus: function (lpTokenAmount, coin) {
+        return __awaiter(this, void 0, void 0, function () {
+            var totalAmount, _a, balancedAmounts, balancedTotalAmount;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = Number;
+                        return [4 /*yield*/, this.withdrawOneCoinExpected(lpTokenAmount, coin)];
+                    case 1:
+                        totalAmount = _a.apply(void 0, [_b.sent()]);
+                        return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
+                    case 2:
+                        balancedAmounts = _b.sent();
+                        balancedTotalAmount = balancedAmounts.map(Number).reduce(function (a, b) { return a + b; });
+                        return [2 /*return*/, String((totalAmount - balancedTotalAmount) / Math.max(totalAmount, balancedTotalAmount) * 100)];
+                }
+            });
+        });
+    },
+};
+// @ts-ignore
+exports.withdrawOneCoinWrappedBonusMixin = {
+    withdrawOneCoinWrappedBonus: function (lpTokenAmount, coin) {
+        return __awaiter(this, void 0, void 0, function () {
+            var vp, basePoolAddress, _a, _b, _c, prices, coinAmount, _d, totalValue, balancedAmounts, balancedTotalValue;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        vp = 1;
+                        if (!this.isMeta) return [3 /*break*/, 2];
+                        basePoolAddress = curve_1.curve.constants.POOLS_DATA[this.basePool].swap_address;
+                        _a = Number;
+                        _c = (_b = ethers_1.ethers.utils).formatUnits;
+                        return [4 /*yield*/, curve_1.curve.contracts[basePoolAddress].contract.get_virtual_price(curve_1.curve.constantOptions)];
+                    case 1:
+                        vp = _a.apply(void 0, [_c.apply(_b, [_e.sent()])]);
+                        _e.label = 2;
+                    case 2:
+                        prices = this.wrappedCoins.map(function (_, i, arr) { return i === arr.length - 1 ? vp : 1; });
+                        _d = Number;
+                        return [4 /*yield*/, this.withdrawOneCoinWrappedExpected(lpTokenAmount, coin)];
+                    case 3:
+                        coinAmount = _d.apply(void 0, [_e.sent()]);
+                        totalValue = coinAmount * prices[this._getCoinIdx(coin)];
+                        return [4 /*yield*/, this.withdrawWrappedExpected(lpTokenAmount)];
+                    case 4:
+                        balancedAmounts = _e.sent();
+                        balancedTotalValue = balancedAmounts.map(Number).reduce(function (s, a, i) { return s + (a * prices[i]); }, 0);
+                        return [2 /*return*/, String((totalValue - balancedTotalValue) / Math.max(totalValue, balancedTotalValue) * 100)];
+                }
+            });
+        });
+    },
+};
+// @ts-ignore
+exports.withdrawOneCoinCryptoBonusMixin = {
+    withdrawOneCoinBonus: function (lpTokenAmount, coin) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prices, coinPrice, totalAmount, _a, totalAmountUSD, balancedAmounts, balancedTotalAmountsUSD;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._underlyingPrices()];
+                    case 1:
+                        prices = _b.sent();
+                        coinPrice = prices[this._getCoinIdx(coin)];
+                        _a = Number;
+                        return [4 /*yield*/, this.withdrawOneCoinExpected(lpTokenAmount, coin)];
+                    case 2:
+                        totalAmount = _a.apply(void 0, [_b.sent()]);
+                        totalAmountUSD = totalAmount * coinPrice;
+                        return [4 /*yield*/, this.withdrawExpected(lpTokenAmount)];
+                    case 3:
+                        balancedAmounts = _b.sent();
+                        balancedTotalAmountsUSD = balancedAmounts.reduce(function (s, b, i) { return s + (Number(b) * prices[i]); }, 0);
+                        return [2 /*return*/, String((totalAmountUSD - balancedTotalAmountsUSD) / Math.max(totalAmountUSD, balancedTotalAmountsUSD) * 100)];
+                }
+            });
+        });
+    },
+};
+// @ts-ignore
+exports.withdrawOneCoinWrappedCryptoBonusMixin = {
+    withdrawOneCoinWrappedBonus: function (lpTokenAmount, coin) {
+        return __awaiter(this, void 0, void 0, function () {
+            var vp, basePoolAddress, _a, _b, _c, prices, coinPrice, totalAmount, _d, totalAmountUSD, balancedAmounts, balancedTotalAmountsUSD;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        vp = 1;
+                        if (!this.isMeta) return [3 /*break*/, 2];
+                        basePoolAddress = curve_1.curve.constants.POOLS_DATA[this.basePool].swap_address;
+                        _a = Number;
+                        _c = (_b = ethers_1.ethers.utils).formatUnits;
+                        return [4 /*yield*/, curve_1.curve.contracts[basePoolAddress].contract.get_virtual_price(curve_1.curve.constantOptions)];
+                    case 1:
+                        vp = _a.apply(void 0, [_c.apply(_b, [_e.sent()])]);
+                        _e.label = 2;
+                    case 2: return [4 /*yield*/, this._wrappedPrices()];
+                    case 3:
+                        prices = (_e.sent()).map(function (p, i) { return i === prices.length - 1 ? p * vp : p; });
+                        coinPrice = prices[this._getCoinIdx(coin)];
+                        _d = Number;
+                        return [4 /*yield*/, this.withdrawOneCoinWrappedExpected(lpTokenAmount, coin)];
+                    case 4:
+                        totalAmount = _d.apply(void 0, [_e.sent()]);
+                        totalAmountUSD = totalAmount * coinPrice;
+                        return [4 /*yield*/, this.withdrawWrappedExpected(lpTokenAmount)];
+                    case 5:
+                        balancedAmounts = _e.sent();
+                        balancedTotalAmountsUSD = balancedAmounts.reduce(function (s, b, i) { return s + (Number(b) * prices[i]); }, 0);
+                        return [2 /*return*/, String((totalAmountUSD - balancedTotalAmountsUSD) / Math.max(totalAmountUSD, balancedTotalAmountsUSD) * 100)];
+                }
+            });
+        });
+    },
+};

package/lib/pools/poolConstructor.js

@@ -26,6 +26,7 @@ var depositWrappedMixins_1 = require("./mixins/depositWrappedMixins");
 var withdrawExpectedMixins_1 = require("./mixins/withdrawExpectedMixins");
 var withdrawMixins_1 = require("./mixins/withdrawMixins");
 var withdrawWrappedMixins_1 = require("./mixins/withdrawWrappedMixins");
+var withdrawBonusMixins_1 = require("./mixins/withdrawBonusMixins");
 var withdrawImbalanceMixins_1 = require("./mixins/withdrawImbalanceMixins");
 var withdrawImbalanceWrappedMixins_1 = require("./mixins/withdrawImbalanceWrappedMixins");
 var withdrawOneCoinExpectedMixins_1 = require("./mixins/withdrawOneCoinExpectedMixins");
@@ -128,6 +129,24 @@ var getPool = function (poolId) {
     else {
         Object.assign(Pool.prototype, withdrawMixins_1.withdrawPlainMixin);
     }
+    // withdrawImbalanceBonus and withdrawOneCoinBonus
+    if (!poolDummy.isCrypto) {
+        Object.assign(Pool.prototype, withdrawBonusMixins_1.withdrawImbalanceBonusMixin);
+        Object.assign(Pool.prototype, withdrawBonusMixins_1.withdrawOneCoinBonusMixin);
+    }
+    else {
+        Object.assign(Pool.prototype, withdrawBonusMixins_1.withdrawOneCoinCryptoBonusMixin);
+    }
+    // withdrawImbalanceWrappedBonus and withdrawOneCoinWrappedBonus
+    if (!poolDummy.isPlain && !poolDummy.isFake) {
+        if (!poolDummy.isCrypto) {
+            Object.assign(Pool.prototype, withdrawBonusMixins_1.withdrawImbalanceWrappedBonusMixin);
+            Object.assign(Pool.prototype, withdrawBonusMixins_1.withdrawOneCoinWrappedBonusMixin);
+        }
+        else {
+            Object.assign(Pool.prototype, withdrawBonusMixins_1.withdrawOneCoinWrappedCryptoBonusMixin);
+        }
+    }
     // withdrawWrapped and withdrawWrappedEstimateGas
     if (!poolDummy.isPlain && !poolDummy.isFake) {
         if ((poolDummy.isLending || poolDummy.isCrypto) && !poolDummy.zap) {

package/package.json

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