@curvefi/api 2.3.4 → 2.4.2

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");
@@ -72,12 +73,12 @@ var getPool = function (poolId) {
     // depositBonus and depositWrappedBonus
     if (poolDummy.isCrypto) {
         Object.assign(Pool.prototype, depositBonusMixins_1.depositBonusCryptoMixin);
-        if (!poolDummy.isFake)
+        if (!poolDummy.isPlain && !poolDummy.isFake)
             Object.assign(Pool.prototype, depositBonusMixins_1.depositWrappedBonusCryptoMixin);
     }
     else {
         Object.assign(Pool.prototype, depositBonusMixins_1.depositBonusMixin);
-        if (!poolDummy.isFake)
+        if (!poolDummy.isPlain && !poolDummy.isFake)
             Object.assign(Pool.prototype, depositBonusMixins_1.depositWrappedBonusMixin);
     }
     // deposit and depositEstimateGas
@@ -87,18 +88,20 @@ var getPool = function (poolId) {
     else if (poolDummy.zap && poolId !== 'susd') {
         Object.assign(Pool.prototype, depositMixins_1.depositZapMixin);
     }
-    else if (poolDummy.isLending || poolDummy.isCrypto) {
+    else if (poolDummy.isLending || (poolDummy.isCrypto && !poolDummy.isPlain)) {
         Object.assign(Pool.prototype, depositMixins_1.depositLendingOrCryptoMixin);
     }
     else {
         Object.assign(Pool.prototype, depositMixins_1.depositPlainMixin);
     }
     // depositWrapped and depositWrappedEstimateGas
-    if ((poolDummy.isLending || poolDummy.isCrypto) && !poolDummy.zap) {
-        Object.assign(Pool.prototype, depositWrappedMixins_1.depositWrapped3argsMixin);
-    }
-    else if (!poolDummy.isPlain && !poolDummy.isFake) {
-        Object.assign(Pool.prototype, depositWrappedMixins_1.depositWrapped2argsMixin);
+    if (!poolDummy.isPlain && !poolDummy.isFake) {
+        if ((poolDummy.isLending || poolDummy.isCrypto) && !poolDummy.zap) {
+            Object.assign(Pool.prototype, depositWrappedMixins_1.depositWrapped3argsMixin);
+        }
+        else {
+            Object.assign(Pool.prototype, depositWrappedMixins_1.depositWrapped2argsMixin);
+        }
     }
     // withdrawExpected
     if (poolDummy.isFake) {
@@ -107,7 +110,7 @@ var getPool = function (poolId) {
     else if (poolDummy.isMeta) {
         Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawExpectedMetaMixin);
     }
-    else if (poolDummy.isLending || poolDummy.isCrypto) {
+    else if (poolDummy.isLending || (poolDummy.isCrypto && !poolDummy.isPlain)) {
         Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawExpectedLendingOrCryptoMixin);
     }
     else {
@@ -120,20 +123,40 @@ var getPool = function (poolId) {
     else if (poolDummy.zap && poolId !== 'susd') {
         Object.assign(Pool.prototype, withdrawMixins_1.withdrawZapMixin);
     }
-    else if (poolDummy.isLending || poolDummy.isCrypto) {
+    else if (poolDummy.isLending || (poolDummy.isCrypto && !poolDummy.isPlain)) {
         Object.assign(Pool.prototype, withdrawMixins_1.withdrawLendingOrCryptoMixin);
     }
     else {
         Object.assign(Pool.prototype, withdrawMixins_1.withdrawPlainMixin);
     }
-    // withdrawWrapped and withdrawWrappedEstimateGas
-    if ((poolDummy.isLending || poolDummy.isCrypto) && !poolDummy.zap) {
-        Object.assign(Pool.prototype, withdrawWrappedMixins_1.withdrawWrapped3argsMixin);
-        Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawWrappedExpectedMixin);
+    // withdrawImbalanceBonus and withdrawOneCoinBonus
+    if (!poolDummy.isCrypto) {
+        Object.assign(Pool.prototype, withdrawBonusMixins_1.withdrawImbalanceBonusMixin);
+        Object.assign(Pool.prototype, withdrawBonusMixins_1.withdrawOneCoinBonusMixin);
     }
-    else if (!poolDummy.isPlain && !poolDummy.isFake) {
-        Object.assign(Pool.prototype, withdrawWrappedMixins_1.withdrawWrapped2argsMixin);
-        Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawWrappedExpectedMixin);
+    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) {
+            Object.assign(Pool.prototype, withdrawWrappedMixins_1.withdrawWrapped3argsMixin);
+            Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawWrappedExpectedMixin);
+        }
+        else {
+            Object.assign(Pool.prototype, withdrawWrappedMixins_1.withdrawWrapped2argsMixin);
+            Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawWrappedExpectedMixin);
+        }
     }
     // withdrawImbalance and withdrawImbalanceEstimateGas
     if (!poolDummy.isCrypto) {
@@ -179,7 +202,7 @@ var getPool = function (poolId) {
     else if (poolDummy.zap) { // including susd
         Object.assign(Pool.prototype, withdrawOneCoinMixins_1.withdrawOneCoinZapMixin);
     }
-    else if (poolDummy.isLending || poolDummy.isCrypto) {
+    else if (poolDummy.isLending || (poolDummy.isCrypto && !poolDummy.isPlain)) {
         Object.assign(Pool.prototype, withdrawOneCoinMixins_1.withdrawOneCoinLendingOrCryptoMixin);
     }
     else {

package/lib/utils.js

@@ -464,6 +464,7 @@ var _getUsdRate = function (assetId) { return __awaiter(void 0, void 0, void 0,
                     throw Error('curve object is not initialized');
                 }
                 assetId = {
+                    'CRV': 'curve-dao-token',
                     'EUR': curve_1.curve.constants.COINS.eurt,
                     'BTC': 'bitcoin',
                     'ETH': 'ethereum',

package/package.json

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