@curvefi/api 2.4.0 → 2.4.3

package/lib/constants/aliases.js

@@ -23,7 +23,7 @@ exports.ALIASES_POLYGON = (0, utils_1.lowerCaseValues)({
     "router": "0xfA9a30350048B2BF66865ee20363067c66f67e58",
     "deposit_and_stake": "0x43FF7b96808988C9d19C1d05Ef19658B03e8a143",
     "factory": '0x722272d36ef0da72ff51c5a65db7b870e2e8d4ee',
-    "crypto_factory": '0xF18056Bbd320E96A48e3Fbf8bC061322531aac99',
+    "crypto_factory": "0xE5De15A9C9bBedb4F5EC13B131E61245f2983A69",
     "registry_exchange": "",
 });
 exports.ALIASES_AVALANCHE = (0, utils_1.lowerCaseValues)({

package/lib/constants/pools/ethereum.js

@@ -1272,6 +1272,7 @@ exports.POOLS_DATA_ETHEREUM = (0, utils_1.lowerCasePoolDataAddresses)({
         token_address: '0x3D229E1B4faab62F621eF2F6A610961f7BD7b23B',
         gauge_address: '0x65CA7Dc5CB661fC58De57B1E1aF404649a27AD35',
         is_crypto: true,
+        is_plain: true,
         underlying_coins: ['USDC', 'EURS'],
         wrapped_coins: ['USDC', 'EURS'],
         underlying_coin_addresses: [

package/lib/curve.js

@@ -451,7 +451,7 @@ var Curve = /** @class */ (function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
-                        if (this.chainId !== 1 && this.chainId !== 1337)
+                        if (this.chainId !== 1 && this.chainId !== 137)
                             return [2 /*return*/];
                         if (!useApi) return [3 /*break*/, 2];
                         _a = this.constants;

package/lib/factory/constants.d.ts

@@ -8,8 +8,14 @@ export declare const implementationBasePoolIdDictAvalanche: IDict<string>;
 export declare const basePoolIdZapDictEthereum: IDict<string>;
 export declare const basePoolIdZapDictPolygon: IDict<string>;
 export declare const basePoolIdZapDictAvalanche: IDict<string>;
-export declare const WETH_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
-export declare const ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export declare const NATIVE_TOKEN_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export declare const NATIVE_TOKENS: {
+    [index: number]: {
+        symbol: string;
+        wrappedSymbol: string;
+        wrappedAddress: string;
+    };
+};
 export declare const FACTORY_CONSTANTS: {
     [index: number]: {
         implementationABIDict: IDict<any>;

package/lib/factory/constants.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FACTORY_CONSTANTS = exports.ETH_ADDRESS = exports.WETH_ADDRESS = exports.basePoolIdZapDictAvalanche = exports.basePoolIdZapDictPolygon = exports.basePoolIdZapDictEthereum = exports.implementationBasePoolIdDictAvalanche = exports.implementationBasePoolIdDictPolygon = exports.implementationBasePoolIdDictEthereum = exports.implementationABIDictAvalanche = exports.implementationABIDictPolygon = exports.implementationABIDictEthereum = void 0;
+exports.FACTORY_CONSTANTS = exports.NATIVE_TOKENS = exports.NATIVE_TOKEN_ADDRESS = exports.basePoolIdZapDictAvalanche = exports.basePoolIdZapDictPolygon = exports.basePoolIdZapDictEthereum = exports.implementationBasePoolIdDictAvalanche = exports.implementationBasePoolIdDictPolygon = exports.implementationBasePoolIdDictEthereum = exports.implementationABIDictAvalanche = exports.implementationABIDictPolygon = exports.implementationABIDictEthereum = void 0;
 var swap_json_1 = __importDefault(require("../constants/abis/factoryPools/swap.json"));
 var MetaUSD_json_1 = __importDefault(require("../constants/abis/factory-v2/MetaUSD.json"));
 var MetaUSDBalances_json_1 = __importDefault(require("../constants/abis/factory-v2/MetaUSDBalances.json"));
@@ -121,8 +121,19 @@ exports.basePoolIdZapDictAvalanche = {
     aave: "0x001E3BA199B4FF4B5B6e97aCD96daFC0E2e4156e".toLowerCase(),
     ren: "0xEeB3DDBcc4174e0b3fd1C13aD462b95D11Ef42C3".toLowerCase(),
 };
-exports.WETH_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
-exports.ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+exports.NATIVE_TOKEN_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+exports.NATIVE_TOKENS = {
+    1: {
+        symbol: 'ETH',
+        wrappedSymbol: 'WETH',
+        wrappedAddress: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+    },
+    137: {
+        symbol: 'MATIC',
+        wrappedSymbol: 'WMATIC',
+        wrappedAddress: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
+    },
+};
 exports.FACTORY_CONSTANTS = {
     1: {
         implementationABIDict: exports.implementationABIDictEthereum,

package/lib/factory/factory-api.js

@@ -162,10 +162,11 @@ function getFactoryPoolsDataFromApi(isCrypto) {
                         var coinAddresses = pool.coins.map(function (c) { return c.address.toLowerCase(); });
                         var coinNames = pool.coins.map(function (c) { return c.symbol; });
                         var coinDecimals = pool.coins.map(function (c) { return Number(c.decimals); });
+                        var nativeToken = constants_1.NATIVE_TOKENS[_this.chainId];
                         if (isCrypto) {
-                            var cryptoCoinNames = pool.coins.map(function (c) { return c.symbol === "ETH" ? "WETH" : c.symbol; });
-                            var underlyingCoinNames = pool.coins.map(function (c) { return c.symbol === "WETH" ? "ETH" : c.symbol; });
-                            var underlyingCoinAddresses = pool.coins.map(function (c) { return c.address.toLowerCase() === constants_1.WETH_ADDRESS ? constants_1.ETH_ADDRESS : c.address.toLowerCase(); });
+                            var cryptoCoinNames = pool.coins.map(function (c) { return c.symbol === nativeToken.symbol ? nativeToken.wrappedSymbol : c.symbol; });
+                            var underlyingCoinNames = pool.coins.map(function (c) { return c.symbol === nativeToken.wrappedSymbol ? nativeToken.symbol : c.symbol; });
+                            var underlyingCoinAddresses = coinAddresses.map(function (addr) { return addr === nativeToken.wrappedAddress ? constants_1.NATIVE_TOKEN_ADDRESS : addr; });
                             FACTORY_POOLS_DATA[pool.id] = {
                                 name: pool.name.split(": ")[1].trim(),
                                 full_name: pool.name,

package/lib/factory/factory-crypto.js

@@ -197,8 +197,9 @@ function setCryptoFactoryCoinsContracts(coinAddresses) {
 }
 function getCryptoFactoryUnderlyingCoinAddresses(coinAddresses) {
     return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
         return __generator(this, function (_a) {
-            return [2 /*return*/, coinAddresses.map(function (coins) { return coins.map(function (c) { return c === constants_1.WETH_ADDRESS ? "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" : c; }); })];
+            return [2 /*return*/, coinAddresses.map(function (coins) { return coins.map(function (c) { return c === constants_1.NATIVE_TOKENS[_this.chainId].wrappedAddress ? constants_1.NATIVE_TOKEN_ADDRESS : c; }); })];
         });
     });
 }
@@ -221,11 +222,11 @@ function getExistingCoinAddressNameDict() {
         _loop_1(poolData);
     }
     if (this.chainId === 1)
-        dict["0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"] = "ETH";
+        dict[constants_1.NATIVE_TOKEN_ADDRESS] = "ETH";
     if (this.chainId === 137)
-        dict["0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"] = "MATIC";
+        dict[constants_1.NATIVE_TOKEN_ADDRESS] = "MATIC";
     if (this.chainId === 43114)
-        dict["0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"] = "AVAX";
+        dict[constants_1.NATIVE_TOKEN_ADDRESS] = "AVAX";
     return dict;
 }
 function getCoinAddressNameDict(coinAddresses, existingCoinAddrNameDict) {
@@ -259,6 +260,7 @@ function getCoinAddressNameDict(coinAddresses, existingCoinAddrNameDict) {
                     newCoinAddresses.forEach(function (addr, i) {
                         coinAddrNamesDict[addr] = names[i];
                     });
+                    coinAddrNamesDict[constants_1.NATIVE_TOKEN_ADDRESS] = constants_1.NATIVE_TOKENS[this.chainId].symbol;
                     return [2 /*return*/, coinAddrNamesDict];
             }
         });
@@ -266,18 +268,18 @@ function getCoinAddressNameDict(coinAddresses, existingCoinAddrNameDict) {
 }
 function getCoinAddressDecimalsDict(coinAddresses, existingCoinAddressDecimalsDict) {
     return __awaiter(this, void 0, void 0, function () {
-        var flattenedCoinAddresses, newCoinAddresses, coinAddrNamesDict, _i, flattenedCoinAddresses_3, addr, calls, decimals;
+        var flattenedCoinAddresses, newCoinAddresses, coinAddressDecimalsDict, _i, flattenedCoinAddresses_3, addr, calls, decimals;
         var _this = this;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     flattenedCoinAddresses = Array.from(new Set(deepFlatten(coinAddresses)));
                     newCoinAddresses = [];
-                    coinAddrNamesDict = {};
+                    coinAddressDecimalsDict = {};
                     for (_i = 0, flattenedCoinAddresses_3 = flattenedCoinAddresses; _i < flattenedCoinAddresses_3.length; _i++) {
                         addr = flattenedCoinAddresses_3[_i];
                         if (addr in existingCoinAddressDecimalsDict) {
-                            coinAddrNamesDict[addr] = existingCoinAddressDecimalsDict[addr];
+                            coinAddressDecimalsDict[addr] = existingCoinAddressDecimalsDict[addr];
                         }
                         else {
                             newCoinAddresses.push(addr);
@@ -290,10 +292,10 @@ function getCoinAddressDecimalsDict(coinAddresses, existingCoinAddressDecimalsDi
                 case 1:
                     decimals = (_a.sent()).map(function (_d) { return Number(ethers_1.ethers.utils.formatUnits(_d, 0)); });
                     newCoinAddresses.forEach(function (addr, i) {
-                        coinAddrNamesDict[addr] = decimals[i];
+                        coinAddressDecimalsDict[addr] = decimals[i];
                     });
-                    coinAddrNamesDict['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'] = 18;
-                    return [2 /*return*/, coinAddrNamesDict];
+                    coinAddressDecimalsDict[constants_1.NATIVE_TOKEN_ADDRESS] = 18;
+                    return [2 /*return*/, coinAddressDecimalsDict];
             }
         });
     });

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;
@@ -1900,7 +1826,7 @@ var PoolTemplate = /** @class */ (function () {
                     case 12:
                         _amounts = amounts.map(function (amount, i) { return (0, utils_1.parseUnits)(amount, decimals[i]); });
                         contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.deposit_and_stake].contract;
-                        useUnderlying = isUnderlying && (this.isLending || this.isCrypto) && !this.zap;
+                        useUnderlying = isUnderlying && (this.isLending || (this.isCrypto && !this.isPlain)) && !this.zap;
                         if (!isUnderlying) return [3 /*break*/, 14];
                         _k = (_j = ethers_1.ethers.utils).parseUnits;
                         return [4 /*yield*/, this.depositAndStakeExpected(amounts)];
@@ -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) {
-                            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");
@@ -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/package.json

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