@curvefi/api 2.3.2 → 2.4.0

package/lib/pools/PoolTemplate.js

@@ -67,16 +67,22 @@ var external_api_1 = require("../external-api");
 var utils_1 = require("../utils");
 var curve_1 = require("../curve");
 var ERC20_json_1 = __importDefault(require("../constants/abis/ERC20.json"));
+var DAY = 86400;
+var WEEK = 7 * DAY;
+var MONTH = 30 * DAY;
+var YEAR = 365 * DAY;
 var PoolTemplate = /** @class */ (function () {
     function PoolTemplate(id) {
         var _this = this;
         this.statsParameters = function () { return __awaiter(_this, void 0, void 0, function () {
-            var multicallContract, calls, additionalCalls, _a, _virtualPrice, _fee, _adminFee, _A, _gamma, _c, virtualPrice, fee, adminFee, A, gamma, A_PRECISION, _d, _future_A, _initial_A, _future_A_time, _initial_A_time, _e, future_A, initial_A, future_A_time, initial_A_time;
+            var multicallContract, lpMulticallContract, calls, additionalCalls, _a, _lpTokenSupply, _virtualPrice, _fee, _adminFee, _A, _gamma, _c, lpTokenSupply, virtualPrice, fee, adminFee, A, gamma, A_PRECISION, _d, _future_A, _initial_A, _future_A_time, _initial_A_time, _e, future_A, initial_A, future_A_time, initial_A_time;
             return __generator(this, function (_f) {
                 switch (_f.label) {
                     case 0:
                         multicallContract = curve_1.curve.contracts[this.address].multicallContract;
+                        lpMulticallContract = curve_1.curve.contracts[this.lpToken].multicallContract;
                         calls = [
+                            lpMulticallContract.totalSupply(),
                             multicallContract.get_virtual_price(),
                             multicallContract.fee(),
                             multicallContract.admin_fee(),
@@ -90,14 +96,15 @@ var PoolTemplate = /** @class */ (function () {
                         }
                         return [4 /*yield*/, curve_1.curve.multicallProvider.all(calls)];
                     case 1:
-                        _a = _f.sent(), _virtualPrice = _a[0], _fee = _a[1], _adminFee = _a[2], _A = _a[3], _gamma = _a[4];
+                        _a = _f.sent(), _lpTokenSupply = _a[0], _virtualPrice = _a[1], _fee = _a[2], _adminFee = _a[3], _A = _a[4], _gamma = _a[5];
                         _c = [
+                            ethers_1.ethers.utils.formatUnits(_lpTokenSupply),
                             ethers_1.ethers.utils.formatUnits(_virtualPrice),
                             ethers_1.ethers.utils.formatUnits(_fee, 8),
                             ethers_1.ethers.utils.formatUnits(_adminFee.mul(_fee)),
                             ethers_1.ethers.utils.formatUnits(_A, 0),
                             _gamma ? ethers_1.ethers.utils.formatUnits(_gamma) : _gamma,
-                        ], virtualPrice = _c[0], fee = _c[1], adminFee = _c[2], A = _c[3], gamma = _c[4];
+                        ], lpTokenSupply = _c[0], virtualPrice = _c[1], fee = _c[2], adminFee = _c[3], A = _c[4], gamma = _c[5];
                         A_PRECISION = curve_1.curve.chainId === 1 && ['compound', 'usdt', 'y', 'busd', 'susd', 'pax', 'ren', 'sbtc', 'hbtc', '3pool'].includes(this.id) ? 1 : 100;
                         return [4 /*yield*/, curve_1.curve.multicallProvider.all(additionalCalls)];
                     case 2:
@@ -108,7 +115,7 @@ var PoolTemplate = /** @class */ (function () {
                             _future_A_time ? Number(ethers_1.ethers.utils.formatUnits(_future_A_time, 0)) * 1000 : undefined,
                             _initial_A_time ? Number(ethers_1.ethers.utils.formatUnits(_initial_A_time, 0)) * 1000 : undefined,
                         ], future_A = _e[0], initial_A = _e[1], future_A_time = _e[2], initial_A_time = _e[3];
-                        return [2 /*return*/, { virtualPrice: virtualPrice, fee: fee, adminFee: adminFee, A: A, future_A: future_A, initial_A: initial_A, future_A_time: future_A_time, initial_A_time: initial_A_time, gamma: gamma }];
+                        return [2 /*return*/, { lpTokenSupply: lpTokenSupply, virtualPrice: virtualPrice, fee: fee, adminFee: adminFee, A: A, future_A: future_A, initial_A: initial_A, future_A_time: future_A_time, initial_A_time: initial_A_time, gamma: gamma }];
                 }
             });
         }); };
@@ -313,6 +320,182 @@ var PoolTemplate = /** @class */ (function () {
                 }
             });
         }); };
+        // ---------------- CRV PROFIT, CLAIM, BOOSTING ----------------
+        this.crvProfit = function (address) {
+            if (address === void 0) { address = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var inflationRateBN, workingSupplyBN, workingBalanceBN, gaugeContract, crvContract, currentWeek, _a, gaugeContract, gaugeControllerContract, weightBN, crvPrice, dailyIncome, weeklyIncome, monthlyIncome, annualIncome;
+                var _c, _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
+                                throw Error("".concat(this.name, " doesn't have gauge"));
+                            address = address || curve_1.curve.signerAddress;
+                            if (!address)
+                                throw Error("Need to connect wallet or pass address into args");
+                            if (!(curve_1.curve.chainId !== 1)) return [3 /*break*/, 4];
+                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
+                            crvContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.crv].contract;
+                            currentWeek = Math.floor(Date.now() / 1000 / WEEK);
+                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
+                                    gaugeContract.inflation_rate(currentWeek),
+                                    gaugeContract.working_balances(address),
+                                    gaugeContract.working_supply(),
+                                ])];
+                        case 1:
+                            _c = (_e.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflationRateBN = _c[0], workingBalanceBN = _c[1], workingSupplyBN = _c[2];
+                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 3];
+                            _a = utils_1.toBN;
+                            return [4 /*yield*/, crvContract.balanceOf(this.gauge, curve_1.curve.constantOptions)];
+                        case 2:
+                            inflationRateBN = _a.apply(void 0, [_e.sent()]).div(WEEK);
+                            _e.label = 3;
+                        case 3: return [3 /*break*/, 6];
+                        case 4:
+                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
+                            gaugeControllerContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.gauge_controller].multicallContract;
+                            weightBN = void 0;
+                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
+                                    gaugeContract.inflation_rate(),
+                                    gaugeControllerContract.gauge_relative_weight(this.gauge),
+                                    gaugeContract.working_balances(address),
+                                    gaugeContract.working_supply(),
+                                ])];
+                        case 5:
+                            _d = (_e.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflationRateBN = _d[0], weightBN = _d[1], workingBalanceBN = _d[2], workingSupplyBN = _d[3];
+                            inflationRateBN = inflationRateBN.times(weightBN);
+                            _e.label = 6;
+                        case 6: return [4 /*yield*/, (0, utils_1._getUsdRate)('CRV')];
+                        case 7:
+                            crvPrice = _e.sent();
+                            if (workingSupplyBN.eq(0))
+                                return [2 /*return*/, {
+                                        day: "0.0",
+                                        week: "0.0",
+                                        month: "0.0",
+                                        year: "0.0",
+                                        token: curve_1.curve.constants.ALIASES.crv,
+                                        symbol: 'CRV',
+                                        price: crvPrice,
+                                    }];
+                            dailyIncome = inflationRateBN.times(DAY).times(workingBalanceBN).div(workingSupplyBN);
+                            weeklyIncome = inflationRateBN.times(WEEK).times(workingBalanceBN).div(workingSupplyBN);
+                            monthlyIncome = inflationRateBN.times(MONTH).times(workingBalanceBN).div(workingSupplyBN);
+                            annualIncome = inflationRateBN.times(YEAR).times(workingBalanceBN).div(workingSupplyBN);
+                            return [2 /*return*/, {
+                                    day: dailyIncome.toString(),
+                                    week: weeklyIncome.toString(),
+                                    month: monthlyIncome.toString(),
+                                    year: annualIncome.toString(),
+                                    token: curve_1.curve.constants.ALIASES.crv,
+                                    symbol: 'CRV',
+                                    price: crvPrice,
+                                }];
+                    }
+                });
+            });
+        };
+        this.boost = function (address) {
+            if (address === void 0) { address = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var gaugeContract, _a, workingBalanceBN, balanceBN, boostBN;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (curve_1.curve.chainId !== 1)
+                                throw Error("Boosting is available only on Ethereum network");
+                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
+                                throw Error("".concat(this.name, " doesn't have gauge"));
+                            address = address || curve_1.curve.signerAddress;
+                            if (!address)
+                                throw Error("Need to connect wallet or pass address into args");
+                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
+                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
+                                    gaugeContract.working_balances(address),
+                                    gaugeContract.balanceOf(address),
+                                ])];
+                        case 1:
+                            _a = (_c.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), workingBalanceBN = _a[0], balanceBN = _a[1];
+                            boostBN = workingBalanceBN.div(0.4).div(balanceBN);
+                            return [2 /*return*/, boostBN.toFixed(4).replace(/([0-9])0+$/, '$1')];
+                    }
+                });
+            });
+        };
+        this.currentCrvApy = function (address) {
+            if (address === void 0) { address = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _a, baseApy, maxApy, boost;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            address = address || curve_1.curve.signerAddress;
+                            if (!address)
+                                throw Error("Need to connect wallet or pass address into args");
+                            return [4 /*yield*/, this.statsTokenApy()];
+                        case 1:
+                            _a = _c.sent(), baseApy = _a[0], maxApy = _a[1];
+                            if (curve_1.curve.chainId !== 1)
+                                return [2 /*return*/, baseApy];
+                            return [4 /*yield*/, this.boost(address)];
+                        case 2:
+                            boost = _c.sent();
+                            if (boost == "2.5")
+                                return [2 /*return*/, maxApy];
+                            if (boost === "NaN")
+                                return [2 /*return*/, "NaN"];
+                            return [2 /*return*/, (0, utils_1.BN)(baseApy).times((0, utils_1.BN)(boost)).toFixed(4).replace(/([0-9])0+$/, '$1')];
+                    }
+                });
+            });
+        };
+        this.maxBoostedStake = function () {
+            var addresses = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                addresses[_i] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function () {
+                var votingEscrowContract, gaugeContract, contractCalls, _response, responseBN, _a, veTotalSupplyBN, gaugeTotalSupplyBN, resultBN, result, _c, _d, entry;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            if (curve_1.curve.chainId !== 1)
+                                throw Error("Boosting is available only on Ethereum network");
+                            if (this.gauge === ethers_1.ethers.constants.AddressZero)
+                                throw Error("".concat(this.name, " doesn't have gauge"));
+                            if (addresses.length == 1 && Array.isArray(addresses[0]))
+                                addresses = addresses[0];
+                            if (addresses.length === 0 && curve_1.curve.signerAddress !== '')
+                                addresses = [curve_1.curve.signerAddress];
+                            if (addresses.length === 0)
+                                throw Error("Need to connect wallet or pass addresses into args");
+                            votingEscrowContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.voting_escrow].multicallContract;
+                            gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
+                            contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
+                            addresses.forEach(function (account) {
+                                contractCalls.push(votingEscrowContract.balanceOf(account));
+                            });
+                            return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
+                        case 1:
+                            _response = _e.sent();
+                            responseBN = _response.map(function (value) { return (0, utils_1.toBN)(value); });
+                            _a = responseBN.splice(0, 2), veTotalSupplyBN = _a[0], gaugeTotalSupplyBN = _a[1];
+                            resultBN = {};
+                            addresses.forEach(function (acct, i) {
+                                resultBN[acct] = responseBN[i].div(veTotalSupplyBN).times(gaugeTotalSupplyBN);
+                            });
+                            result = {};
+                            for (_c = 0, _d = Object.entries(resultBN); _c < _d.length; _c++) {
+                                entry = _d[_c];
+                                result[entry[0]] = (0, utils_1.toStringFromBN)(entry[1]);
+                            }
+                            return [2 /*return*/, addresses.length === 1 ? result[addresses[0]] : result];
+                    }
+                });
+            });
+        };
+        // ---------------- REWARDS PROFIT, CLAIM ----------------
         this.rewardTokens = (0, memoizee_1.default)(function () { return __awaiter(_this, void 0, void 0, function () {
             var gaugeContract, gaugeMulticallContract, rewardCount, _a, _c, _d, tokenCalls, i, tokens, tokenInfoCalls, _i, tokens_1, token, tokenMulticallContract, tokenInfo_1, i, rewardContract, method, token, tokenMulticallContract, _e, symbol, decimals;
             return __generator(this, function (_f) {
@@ -379,46 +562,117 @@ var PoolTemplate = /** @class */ (function () {
             promise: true,
             maxAge: 30 * 60 * 1000, // 30m
         });
-        // ---------------- ... ----------------
-        this.gaugeMaxBoostedDeposit = function () {
-            var addresses = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                addresses[_i] = arguments[_i];
-            }
+        this.rewardsProfit = function (address) {
+            if (address === void 0) { address = ""; }
             return __awaiter(_this, void 0, void 0, function () {
-                var votingEscrowContract, gaugeContract, contractCalls, _response, responseBN, _a, veTotalSupplyBN, gaugeTotalSupplyBN, resultBN, result, _c, _d, entry;
+                var rewardTokens, gaugeContract, result, calls, _i, rewardTokens_2, rewardToken, res, balanceBN, totalSupplyBN, _a, rewardTokens_3, rewardToken, _rewardData, periodFinish, inflationRateBN, tokenPrice, rewardToken, sRewardContract, _c, _inflationRate, _periodFinish, _balance, _totalSupply, periodFinish, inflationRateBN, balanceBN, totalSupplyBN, tokenPrice, _d, rewardTokens_4, rewardToken, tokenPrice;
                 return __generator(this, function (_e) {
                     switch (_e.label) {
                         case 0:
                             if (this.gauge === ethers_1.ethers.constants.AddressZero)
                                 throw Error("".concat(this.name, " doesn't have gauge"));
-                            if (addresses.length == 1 && Array.isArray(addresses[0]))
-                                addresses = addresses[0];
-                            votingEscrowContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.voting_escrow].multicallContract;
+                            address = address || curve_1.curve.signerAddress;
+                            if (!address)
+                                throw Error("Need to connect wallet or pass address into args");
+                            return [4 /*yield*/, this.rewardTokens()];
+                        case 1:
+                            rewardTokens = _e.sent();
                             gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                            contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
-                            addresses.forEach(function (account) {
-                                contractCalls.push(votingEscrowContract.balanceOf(account));
+                            result = [];
+                            if (!('reward_data(address)' in curve_1.curve.contracts[this.gauge].contract)) return [3 /*break*/, 7];
+                            calls = [gaugeContract.balanceOf(address), gaugeContract.totalSupply()];
+                            for (_i = 0, rewardTokens_2 = rewardTokens; _i < rewardTokens_2.length; _i++) {
+                                rewardToken = rewardTokens_2[_i];
+                                calls.push(gaugeContract.reward_data(rewardToken.token));
+                            }
+                            return [4 /*yield*/, curve_1.curve.multicallProvider.all(calls)];
+                        case 2:
+                            res = _e.sent();
+                            balanceBN = (0, utils_1.toBN)(res.shift());
+                            totalSupplyBN = (0, utils_1.toBN)(res.shift());
+                            _a = 0, rewardTokens_3 = rewardTokens;
+                            _e.label = 3;
+                        case 3:
+                            if (!(_a < rewardTokens_3.length)) return [3 /*break*/, 6];
+                            rewardToken = rewardTokens_3[_a];
+                            _rewardData = res.shift();
+                            periodFinish = Number(ethers_1.ethers.utils.formatUnits(_rewardData.period_finish, 0)) * 1000;
+                            inflationRateBN = periodFinish > Date.now() ? (0, utils_1.toBN)(_rewardData.rate, rewardToken.decimals) : (0, utils_1.BN)(0);
+                            return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken.token)];
+                        case 4:
+                            tokenPrice = _e.sent();
+                            result.push({
+                                day: inflationRateBN.times(DAY).times(balanceBN).div(totalSupplyBN).toString(),
+                                week: inflationRateBN.times(WEEK).times(balanceBN).div(totalSupplyBN).toString(),
+                                month: inflationRateBN.times(MONTH).times(balanceBN).div(totalSupplyBN).toString(),
+                                year: inflationRateBN.times(YEAR).times(balanceBN).div(totalSupplyBN).toString(),
+                                token: rewardToken.token,
+                                symbol: rewardToken.symbol,
+                                price: tokenPrice,
                             });
-                            return [4 /*yield*/, curve_1.curve.multicallProvider.all(contractCalls)];
-                        case 1:
-                            _response = _e.sent();
-                            responseBN = _response.map(function (value) { return (0, utils_1.toBN)(value); });
-                            _a = responseBN.splice(0, 2), veTotalSupplyBN = _a[0], gaugeTotalSupplyBN = _a[1];
-                            resultBN = {};
-                            addresses.forEach(function (acct, i) {
-                                resultBN[acct] = responseBN[i].div(veTotalSupplyBN).times(gaugeTotalSupplyBN);
+                            _e.label = 5;
+                        case 5:
+                            _a++;
+                            return [3 /*break*/, 3];
+                        case 6: return [3 /*break*/, 14];
+                        case 7:
+                            if (!(this.sRewardContract && "rewardRate()" in curve_1.curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1)) return [3 /*break*/, 10];
+                            rewardToken = rewardTokens[0];
+                            sRewardContract = curve_1.curve.contracts[this.sRewardContract].multicallContract;
+                            return [4 /*yield*/, curve_1.curve.multicallProvider.all([
+                                    sRewardContract.rewardRate(),
+                                    sRewardContract.periodFinish(),
+                                    gaugeContract.balanceOf(address),
+                                    gaugeContract.totalSupply(),
+                                ])];
+                        case 8:
+                            _c = _e.sent(), _inflationRate = _c[0], _periodFinish = _c[1], _balance = _c[2], _totalSupply = _c[3];
+                            periodFinish = Number(ethers_1.ethers.utils.formatUnits(_periodFinish, 0)) * 1000;
+                            inflationRateBN = periodFinish > Date.now() ? (0, utils_1.toBN)(_inflationRate, rewardToken.decimals) : (0, utils_1.BN)(0);
+                            balanceBN = (0, utils_1.toBN)(_balance);
+                            totalSupplyBN = (0, utils_1.toBN)(_totalSupply);
+                            return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken.token)];
+                        case 9:
+                            tokenPrice = _e.sent();
+                            result.push({
+                                day: inflationRateBN.times(DAY).times(balanceBN).div(totalSupplyBN).toString(),
+                                week: inflationRateBN.times(WEEK).times(balanceBN).div(totalSupplyBN).toString(),
+                                month: inflationRateBN.times(MONTH).times(balanceBN).div(totalSupplyBN).toString(),
+                                year: inflationRateBN.times(YEAR).times(balanceBN).div(totalSupplyBN).toString(),
+                                token: rewardToken.token,
+                                symbol: rewardToken.symbol,
+                                price: tokenPrice,
                             });
-                            result = {};
-                            for (_c = 0, _d = Object.entries(resultBN); _c < _d.length; _c++) {
-                                entry = _d[_c];
-                                result[entry[0]] = (0, utils_1.toStringFromBN)(entry[1]);
-                            }
-                            return [2 /*return*/, result];
+                            return [3 /*break*/, 14];
+                        case 10:
+                            if (!['aave', 'saave', 'ankreth'].includes(this.id)) return [3 /*break*/, 14];
+                            _d = 0, rewardTokens_4 = rewardTokens;
+                            _e.label = 11;
+                        case 11:
+                            if (!(_d < rewardTokens_4.length)) return [3 /*break*/, 14];
+                            rewardToken = rewardTokens_4[_d];
+                            return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken.token)];
+                        case 12:
+                            tokenPrice = _e.sent();
+                            result.push({
+                                day: "0",
+                                week: "0",
+                                month: "0",
+                                year: "0",
+                                token: rewardToken.token,
+                                symbol: rewardToken.symbol,
+                                price: tokenPrice,
+                            });
+                            _e.label = 13;
+                        case 13:
+                            _d++;
+                            return [3 /*break*/, 11];
+                        case 14: return [2 /*return*/, result];
                     }
                 });
             });
         };
+        // ---------------- ... ----------------
         this.gaugeOptimalDeposits = function () {
             var accounts = [];
             for (var _i = 0; _i < arguments.length; _i++) {
@@ -486,25 +740,6 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
-        this.boost = function (address) { return __awaiter(_this, void 0, void 0, function () {
-            var gaugeContract, _a, workingBalance, balance, boost;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (this.gauge === ethers_1.ethers.constants.AddressZero)
-                            throw Error("".concat(this.name, " doesn't have gauge"));
-                        gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                        return [4 /*yield*/, curve_1.curve.multicallProvider.all([
-                                gaugeContract.working_balances(address),
-                                gaugeContract.balanceOf(address),
-                            ])];
-                    case 1:
-                        _a = (_c.sent()).map(function (value) { return Number(ethers_1.ethers.utils.formatUnits(value)); }), workingBalance = _a[0], balance = _a[1];
-                        boost = workingBalance / (0.4 * balance);
-                        return [2 /*return*/, boost.toFixed(4).replace(/([0-9])0+$/, '$1')];
-                }
-            });
-        }); };
         this._getCoinIdx = function (coin, useUnderlying) {
             if (useUnderlying === void 0) { useUnderlying = true; }
             if (typeof coin === 'number') {
@@ -1225,9 +1460,9 @@ var PoolTemplate = /** @class */ (function () {
     PoolTemplate.prototype.claimableRewards = function (address) {
         if (address === void 0) { address = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var gaugeContract, rewardTokens, rewards, _i, rewardTokens_2, rewardToken, amount, _a, _c, rewardToken, _totalAmount, _claimedAmount;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var gaugeContract, rewardTokens, rewards, _i, rewardTokens_5, rewardToken, _amount, rewardToken, _totalAmount, _claimedAmount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         if (this.gauge === ethers_1.ethers.constants.AddressZero) {
                             throw Error("claimableRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
@@ -1238,24 +1473,23 @@ var PoolTemplate = /** @class */ (function () {
                         gaugeContract = curve_1.curve.contracts[this.gauge].contract;
                         return [4 /*yield*/, this.rewardTokens()];
                     case 1:
-                        rewardTokens = _d.sent();
+                        rewardTokens = _a.sent();
                         rewards = [];
                         if (!('claimable_reward(address,address)' in gaugeContract)) return [3 /*break*/, 6];
-                        _i = 0, rewardTokens_2 = rewardTokens;
-                        _d.label = 2;
+                        _i = 0, rewardTokens_5 = rewardTokens;
+                        _a.label = 2;
                     case 2:
-                        if (!(_i < rewardTokens_2.length)) return [3 /*break*/, 5];
-                        rewardToken = rewardTokens_2[_i];
-                        _c = (_a = ethers_1.ethers.utils).formatUnits;
-                        return [4 /*yield*/, gaugeContract.claimable_reward(address, rewardToken, curve_1.curve.constantOptions)];
+                        if (!(_i < rewardTokens_5.length)) return [3 /*break*/, 5];
+                        rewardToken = rewardTokens_5[_i];
+                        return [4 /*yield*/, gaugeContract.claimable_reward(address, rewardToken.token, curve_1.curve.constantOptions)];
                     case 3:
-                        amount = _c.apply(_a, [_d.sent(), rewardToken.decimals]);
+                        _amount = _a.sent();
                         rewards.push({
                             token: rewardToken.token,
                             symbol: rewardToken.symbol,
-                            amount: amount,
+                            amount: ethers_1.ethers.utils.formatUnits(_amount, rewardToken.decimals),
                         });
-                        _d.label = 4;
+                        _a.label = 4;
                     case 4:
                         _i++;
                         return [3 /*break*/, 2];
@@ -1265,16 +1499,16 @@ var PoolTemplate = /** @class */ (function () {
                         rewardToken = rewardTokens[0];
                         return [4 /*yield*/, gaugeContract.claimable_reward(address, curve_1.curve.constantOptions)];
                     case 7:
-                        _totalAmount = _d.sent();
+                        _totalAmount = _a.sent();
                         return [4 /*yield*/, gaugeContract.claimed_rewards_for(address, curve_1.curve.constantOptions)];
                     case 8:
-                        _claimedAmount = _d.sent();
+                        _claimedAmount = _a.sent();
                         rewards.push({
                             token: rewardToken.token,
                             symbol: rewardToken.symbol,
                             amount: ethers_1.ethers.utils.formatUnits(_totalAmount.sub(_claimedAmount), rewardToken.decimals),
                         });
-                        _d.label = 9;
+                        _a.label = 9;
                     case 9: return [2 /*return*/, rewards];
                 }
             });
@@ -2205,6 +2439,158 @@ var PoolTemplate = /** @class */ (function () {
             });
         });
     };
+    // ---------------- USER BALANCES, BASE PROFIT AND SHARE ----------------
+    PoolTemplate.prototype._userLpTotalBalance = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lpBalances, lpTotalBalanceBN;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.walletLpTokenBalances(address)];
+                    case 1:
+                        lpBalances = _a.sent();
+                        lpTotalBalanceBN = (0, utils_1.BN)(lpBalances.lpToken);
+                        if ('gauge' in lpBalances)
+                            lpTotalBalanceBN = lpTotalBalanceBN.plus((0, utils_1.BN)(lpBalances.gauge));
+                        return [2 /*return*/, lpTotalBalanceBN.toString()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.userBalances = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var lpTotalBalanceBN;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = address || curve_1.curve.signerAddress;
+                        if (!address)
+                            throw Error("Need to connect wallet or pass address into args");
+                        return [4 /*yield*/, this._userLpTotalBalance(address)];
+                    case 1:
+                        lpTotalBalanceBN = _a.sent();
+                        return [4 /*yield*/, this.withdrawExpected(lpTotalBalanceBN.toString())];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.userWrappedBalances = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var lpTotalBalanceBN;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = address || curve_1.curve.signerAddress;
+                        if (!address)
+                            throw Error("Need to connect wallet or pass address into args");
+                        return [4 /*yield*/, this._userLpTotalBalance(address)];
+                    case 1:
+                        lpTotalBalanceBN = _a.sent();
+                        return [4 /*yield*/, this.withdrawWrappedExpected(lpTotalBalanceBN.toString())];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.userLiquidityUSD = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var balances, promises, _i, _a, addr, prices, totalLiquidity;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userBalances(address)];
+                    case 1:
+                        balances = _c.sent();
+                        promises = [];
+                        for (_i = 0, _a = this.underlyingCoinAddresses; _i < _a.length; _i++) {
+                            addr = _a[_i];
+                            promises.push((0, utils_1._getUsdRate)(addr));
+                        }
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 2:
+                        prices = _c.sent();
+                        totalLiquidity = balances.reduce(function (liquidity, b, i) { return liquidity + (Number(b) * prices[i]); }, 0);
+                        return [2 /*return*/, totalLiquidity.toFixed(8)];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.baseProfit = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var apyData, apyBN, totalLiquidityBN, _a, annualProfitBN, monthlyProfitBN, weeklyProfitBN, daylyProfitBN;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.statsBaseApy()];
+                    case 1:
+                        apyData = _c.sent();
+                        if (!('week' in apyData))
+                            return [2 /*return*/, { day: "0", week: "0", month: "0", year: "0" }];
+                        apyBN = (0, utils_1.BN)(apyData.week).div(100);
+                        _a = utils_1.BN;
+                        return [4 /*yield*/, this.userLiquidityUSD(address)];
+                    case 2:
+                        totalLiquidityBN = _a.apply(void 0, [_c.sent()]);
+                        annualProfitBN = apyBN.times(totalLiquidityBN);
+                        monthlyProfitBN = annualProfitBN.div(12);
+                        weeklyProfitBN = annualProfitBN.div(52);
+                        daylyProfitBN = annualProfitBN.div(365);
+                        return [2 /*return*/, {
+                                day: daylyProfitBN.toString(),
+                                week: weeklyProfitBN.toString(),
+                                month: monthlyProfitBN.toString(),
+                                year: annualProfitBN.toString(),
+                            }];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.userShare = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var withGauge, userLpBalance, userLpTotalBalanceBN, totalLp, gaugeLp, _a, _c;
+            var _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        withGauge = this.gauge !== ethers_1.ethers.constants.AddressZero;
+                        address = address || curve_1.curve.signerAddress;
+                        if (!address)
+                            throw Error("Need to connect wallet or pass address into args");
+                        return [4 /*yield*/, this.walletLpTokenBalances(address)];
+                    case 1:
+                        userLpBalance = _e.sent();
+                        userLpTotalBalanceBN = (0, utils_1.BN)(userLpBalance.lpToken);
+                        if (withGauge)
+                            userLpTotalBalanceBN = userLpTotalBalanceBN.plus((0, utils_1.BN)(userLpBalance.gauge));
+                        if (!withGauge) return [3 /*break*/, 3];
+                        return [4 /*yield*/, curve_1.curve.multicallProvider.all([
+                                curve_1.curve.contracts[this.lpToken].multicallContract.totalSupply(),
+                                curve_1.curve.contracts[this.gauge].multicallContract.totalSupply(),
+                            ])];
+                    case 2:
+                        _d = (_e.sent()).map(function (_supply) { return ethers_1.ethers.utils.formatUnits(_supply); }), totalLp = _d[0], gaugeLp = _d[1];
+                        return [3 /*break*/, 5];
+                    case 3:
+                        _c = (_a = ethers_1.ethers.utils).formatUnits;
+                        return [4 /*yield*/, curve_1.curve.contracts[this.lpToken].contract.totalSupply()];
+                    case 4:
+                        totalLp = _c.apply(_a, [_e.sent()]);
+                        _e.label = 5;
+                    case 5: return [2 /*return*/, {
+                            lpUser: userLpTotalBalanceBN.toString(),
+                            lpTotal: totalLp,
+                            lpShare: userLpTotalBalanceBN.div(totalLp).times(100).toString(),
+                            gaugeUser: userLpBalance.gauge,
+                            gaugeTotal: gaugeLp,
+                            gaugeShare: withGauge ? (0, utils_1.BN)(userLpBalance.gauge).div((0, utils_1.BN)(gaugeLp)).times(100).toString() : undefined,
+                        }];
+                }
+            });
+        });
+    };
     // ---------------- SWAP ----------------
     PoolTemplate.prototype._swapExpected = function (i, j, _amount) {
         return __awaiter(this, void 0, void 0, function () {

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.2",
+  "version": "2.4.0",
   "description": "JavaScript library for curve.fi",
   "main": "lib/index.js",
   "author": "Macket",