@curvefi/api 2.16.3 → 2.18.0

package/lib/index.d.ts

@@ -17,6 +17,8 @@ declare function init(providerType: 'JsonRpc' | 'Web3' | 'Infura' | 'Alchemy', p
 }): Promise<void>;
 declare function fetchFactoryPools(useApi?: boolean): Promise<void>;
 declare function fetchCryptoFactoryPools(useApi?: boolean): Promise<void>;
+declare function fetchRecentlyDeployedFactoryPool(poolAddress: string): Promise<string>;
+declare function fetchRecentlyDeployedCryptoFactoryPool(poolAddress: string): Promise<string>;
 declare function setCustomFeeData(customFeeData: {
     gasPrice?: number;
     maxFeePerGas?: number;
@@ -42,6 +44,32 @@ declare const curve: {
     getAllowance: (coins: string[], address: string, spender: string) => Promise<string[]>;
     hasAllowance: (coins: string[], amounts: (string | number)[], address: string, spender: string) => Promise<boolean>;
     ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string) => Promise<string[]>;
+    factory: {
+        deployPlainPool: (name: string, symbol: string, coins: string[], A: number, fee: number, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3) => Promise<ethers.ContractTransaction>;
+        deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: number, fee: number, implementationIdx: 0 | 1) => Promise<ethers.ContractTransaction>;
+        deployGauge: (poolAddress: string) => Promise<ethers.ContractTransaction>;
+        getDeployedPlainPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
+        getDeployedMetaPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
+        getDeployedGaugeAddress: (tx: ethers.ContractTransaction) => Promise<string>;
+        fetchRecentlyDeployedPool: typeof fetchRecentlyDeployedFactoryPool;
+        estimateGas: {
+            deployPlainPool: (name: string, symbol: string, coins: string[], A: number, fee: number, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3) => Promise<number>;
+            deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: number, fee: number, implementationIdx: 0 | 1) => Promise<number>;
+            deployGauge: (poolAddress: string) => Promise<number>;
+        };
+    };
+    cryptoFactory: {
+        deployPool: (name: string, symbol: string, coins: string[], A: number, gamma: number, midFee: number, outFee: number, allowedExtraProfit: number, feeGamma: number, adjustmentStep: number, maHalfTime: number, initialPrice: number) => Promise<ethers.ContractTransaction>;
+        deployGauge: (poolAddress: string) => Promise<ethers.ContractTransaction>;
+        getDeployed: (tx: ethers.ContractTransaction) => Promise<string>;
+        getDeployedPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
+        getDeployedGaugeAddress: (tx: ethers.ContractTransaction) => Promise<string>;
+        fetchRecentlyDeployedPool: typeof fetchRecentlyDeployedCryptoFactoryPool;
+        estimateGas: {
+            deployPool: (name: string, symbol: string, coins: string[], A: number, gamma: number, midFee: number, outFee: number, allowedExtraProfit: number, feeGamma: number, adjustmentStep: number, maHalfTime: number, initialPrice: number) => Promise<number>;
+            deployGauge: (poolAddress: string) => Promise<number>;
+        };
+    };
     estimateGas: {
         ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string) => Promise<number>;
     };

package/lib/index.js

@@ -42,6 +42,7 @@ var router_1 = require("./router");
 var curve_1 = require("./curve");
 var boosting_1 = require("./boosting");
 var utils_2 = require("./utils");
+var deploy_1 = require("./factory/deploy");
 function init(providerType, providerSettings, options) {
     if (options === void 0) { options = {}; }
     return __awaiter(this, void 0, void 0, function () {
@@ -85,6 +86,26 @@ function fetchCryptoFactoryPools(useApi) {
         });
     });
 }
+function fetchRecentlyDeployedFactoryPool(poolAddress) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, curve_1.curve.fetchRecentlyDeployedFactoryPool(poolAddress)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+function fetchRecentlyDeployedCryptoFactoryPool(poolAddress) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, curve_1.curve.fetchRecentlyDeployedCryptoFactoryPool(poolAddress)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
 function setCustomFeeData(customFeeData) {
     curve_1.curve.setCustomFeeData(customFeeData);
 }
@@ -108,6 +129,40 @@ var curve = {
     getAllowance: utils_2.getAllowance,
     hasAllowance: utils_2.hasAllowance,
     ensureAllowance: utils_2.ensureAllowance,
+    factory: {
+        deployPlainPool: deploy_1.deployStablePlainPool,
+        deployMetaPool: deploy_1.deployStableMetaPool,
+        deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, (0, deploy_1.deployGauge)(poolAddress, false)];
+        }); }); },
+        getDeployedPlainPoolAddress: deploy_1.getDeployedStablePlainPoolAddress,
+        getDeployedMetaPoolAddress: deploy_1.getDeployedStableMetaPoolAddress,
+        getDeployedGaugeAddress: deploy_1.getDeployedGaugeAddress,
+        fetchRecentlyDeployedPool: fetchRecentlyDeployedFactoryPool,
+        estimateGas: {
+            deployPlainPool: deploy_1.deployStablePlainPoolEstimateGas,
+            deployMetaPool: deploy_1.deployStableMetaPoolEstimateGas,
+            deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/, (0, deploy_1.deployGaugeEstimateGas)(poolAddress, false)];
+            }); }); },
+        },
+    },
+    cryptoFactory: {
+        deployPool: deploy_1.deployCryptoPool,
+        deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, (0, deploy_1.deployGauge)(poolAddress, true)];
+        }); }); },
+        getDeployed: deploy_1.getDeployedStablePlainPoolAddress,
+        getDeployedPoolAddress: deploy_1.getDeployedCryptoPoolAddress,
+        getDeployedGaugeAddress: deploy_1.getDeployedGaugeAddress,
+        fetchRecentlyDeployedPool: fetchRecentlyDeployedCryptoFactoryPool,
+        estimateGas: {
+            deployPool: deploy_1.deployCryptoPoolEstimateGas,
+            deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/, (0, deploy_1.deployGaugeEstimateGas)(poolAddress, true)];
+            }); }); },
+        },
+    },
     estimateGas: {
         ensureAllowance: utils_2.ensureAllowanceEstimateGas,
     },

package/lib/pools/PoolTemplate.js

@@ -1240,7 +1240,7 @@ var PoolTemplate = /** @class */ (function () {
                         return [4 /*yield*/, curve_1.curve.contracts[this.address].contract.price_scale(curve_1.curve.constantOptions)];
                     case 1:
                         priceScaleBN = _c.apply(void 0, [_d.sent()]);
-                        return [2 /*return*/, [amount1BN.toFixed(decimals[0]), amount1BN.div(priceScaleBN).toFixed(decimals[1])]];
+                        return [2 /*return*/, [(0, utils_1._cutZeros)(amount1BN.toFixed(decimals[0])), (0, utils_1._cutZeros)(amount1BN.div(priceScaleBN).toFixed(decimals[1]))]];
                 }
             });
         });

package/lib/pools/utils.d.ts

@@ -1,7 +1,13 @@
-import { ethers } from "ethers";
 export declare const getPoolList: () => string[];
 export declare const getFactoryPoolList: () => string[];
 export declare const getCryptoFactoryPoolList: () => string[];
-export declare const _getUserLpBalances: (pools: string[], address: string, useCache: boolean) => Promise<ethers.BigNumber[]>;
-export declare const getUserPoolList: (address?: string) => Promise<string[]>;
+export declare const getUserPoolListByLiquidity: (address?: string) => Promise<string[]>;
 export declare const getUserLiquidityUSD: (pools: string[], address?: string) => Promise<string[]>;
+export declare const getUserPoolListByClaimable: (address?: string) => Promise<string[]>;
+export declare const getUserClaimable: (pools: string[], address?: string) => Promise<{
+    token: string;
+    symbol: string;
+    amount: string;
+    price: number;
+}[][]>;
+export declare const getUserPoolList: (address?: string) => Promise<string[]>;

package/lib/pools/utils.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -44,27 +55,32 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUserLiquidityUSD = exports.getUserPoolList = exports._getUserLpBalances = exports.getCryptoFactoryPoolList = exports.getFactoryPoolList = exports.getPoolList = void 0;
+exports.getUserPoolList = exports.getUserClaimable = exports.getUserPoolListByClaimable = exports.getUserLiquidityUSD = exports.getUserPoolListByLiquidity = exports.getCryptoFactoryPoolList = exports.getFactoryPoolList = exports.getPoolList = void 0;
 var ethers_1 = require("ethers");
 var poolConstructor_1 = require("./poolConstructor");
 var curve_1 = require("../curve");
 var utils_1 = require("../utils");
+var ERC20_json_1 = __importDefault(require("../constants/abis/ERC20.json"));
 var getPoolList = function () { return Object.keys(curve_1.curve.constants.POOLS_DATA); };
 exports.getPoolList = getPoolList;
 var getFactoryPoolList = function () { return Object.keys(curve_1.curve.constants.FACTORY_POOLS_DATA); };
 exports.getFactoryPoolList = getFactoryPoolList;
 var getCryptoFactoryPoolList = function () { return Object.keys(curve_1.curve.constants.CRYPTO_FACTORY_POOLS_DATA); };
 exports.getCryptoFactoryPoolList = getCryptoFactoryPoolList;
-var _userLpBalance = {};
-var _isUserLpBalanceExpired = function (address, poolId) { var _a, _b; return (((_b = (_a = _userLpBalance[address]) === null || _a === void 0 ? void 0 : _a[poolId]) === null || _b === void 0 ? void 0 : _b.time) || 0) + 600000 < Date.now(); };
+// _userLpBalance: { address: { poolId: { _lpBalance: 0, time: 0 } } }
+var _userLpBalanceCache = {};
+var _isUserLpBalanceCacheExpired = function (address, poolId) { var _a, _b; return (((_b = (_a = _userLpBalanceCache[address]) === null || _a === void 0 ? void 0 : _a[poolId]) === null || _b === void 0 ? void 0 : _b.time) || 0) + 600000 < Date.now(); };
 var _getUserLpBalances = function (pools, address, useCache) { return __awaiter(void 0, void 0, void 0, function () {
     var poolsToFetch, calls, _i, poolsToFetch_1, poolId, pool, _rawBalances, _a, poolsToFetch_2, poolId, pool, _balance, _lpBalances, _b, pools_1, poolId;
     var _c;
     return __generator(this, function (_d) {
         switch (_d.label) {
             case 0:
-                poolsToFetch = useCache ? pools.filter(function (poolId) { return _isUserLpBalanceExpired(address, poolId); }) : pools;
+                poolsToFetch = useCache ? pools.filter(function (poolId) { return _isUserLpBalanceCacheExpired(address, poolId); }) : pools;
                 if (!(poolsToFetch.length > 0)) return [3 /*break*/, 2];
                 calls = [];
                 for (_i = 0, poolsToFetch_1 = poolsToFetch; _i < poolsToFetch_1.length; _i++) {
@@ -83,23 +99,22 @@ var _getUserLpBalances = function (pools, address, useCache) { return __awaiter(
                     _balance = _rawBalances.shift();
                     if (pool.gauge !== ethers_1.ethers.constants.AddressZero)
                         _balance = _balance.add(_rawBalances.shift());
-                    if (!_userLpBalance[address])
-                        _userLpBalance[address] = {};
-                    _userLpBalance[address][poolId] = { '_lpBalance': _balance, 'time': Date.now() };
+                    if (!_userLpBalanceCache[address])
+                        _userLpBalanceCache[address] = {};
+                    _userLpBalanceCache[address][poolId] = { '_lpBalance': _balance, 'time': Date.now() };
                 }
                 _d.label = 2;
             case 2:
                 _lpBalances = [];
                 for (_b = 0, pools_1 = pools; _b < pools_1.length; _b++) {
                     poolId = pools_1[_b];
-                    _lpBalances.push((_c = _userLpBalance[address]) === null || _c === void 0 ? void 0 : _c[poolId]._lpBalance);
+                    _lpBalances.push((_c = _userLpBalanceCache[address]) === null || _c === void 0 ? void 0 : _c[poolId]._lpBalance);
                 }
                 return [2 /*return*/, _lpBalances];
         }
     });
 }); };
-exports._getUserLpBalances = _getUserLpBalances;
-var getUserPoolList = function (address) {
+var getUserPoolListByLiquidity = function (address) {
     if (address === void 0) { address = curve_1.curve.signerAddress; }
     return __awaiter(void 0, void 0, void 0, function () {
         var pools, _lpBalances, userPoolList, i;
@@ -107,7 +122,7 @@ var getUserPoolList = function (address) {
             switch (_a.label) {
                 case 0:
                     pools = __spreadArray(__spreadArray(__spreadArray([], (0, exports.getPoolList)(), true), (0, exports.getFactoryPoolList)(), true), (0, exports.getCryptoFactoryPoolList)(), true);
-                    return [4 /*yield*/, (0, exports._getUserLpBalances)(pools, address, false)];
+                    return [4 /*yield*/, _getUserLpBalances(pools, address, false)];
                 case 1:
                     _lpBalances = _a.sent();
                     userPoolList = [];
@@ -121,14 +136,14 @@ var getUserPoolList = function (address) {
         });
     });
 };
-exports.getUserPoolList = getUserPoolList;
+exports.getUserPoolListByLiquidity = getUserPoolListByLiquidity;
 var getUserLiquidityUSD = function (pools, address) {
     if (address === void 0) { address = curve_1.curve.signerAddress; }
     return __awaiter(void 0, void 0, void 0, function () {
         var _lpBalances, userLiquidityUSD, i, pool, price;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, (0, exports._getUserLpBalances)(pools, address, true)];
+                case 0: return [4 /*yield*/, _getUserLpBalances(pools, address, true)];
                 case 1:
                     _lpBalances = _a.sent();
                     userLiquidityUSD = [];
@@ -151,3 +166,233 @@ var getUserLiquidityUSD = function (pools, address) {
     });
 };
 exports.getUserLiquidityUSD = getUserLiquidityUSD;
+// _userClaimable: { address: { poolId: { rewards: [ { token: '0x111...', 'symbol': 'TST', '', 'amount': 0 } ], time: 0 } }
+var _userClaimableCache = {};
+var _isUserClaimableCacheExpired = function (address, poolId) { var _a, _b; return (((_b = (_a = _userClaimableCache[address]) === null || _a === void 0 ? void 0 : _a[poolId]) === null || _b === void 0 ? void 0 : _b.time) || 0) + 600000 < Date.now(); };
+var _getUserClaimable = function (pools, address, useCache) { return __awaiter(void 0, void 0, void 0, function () {
+    var poolsToFetch, hasCrvReward, _i, poolsToFetch_3, poolId, pool, gaugeContract, rewardCount, _a, poolsToFetch_4, poolId, pool, gaugeContract, rewardTokenCalls, i, pool, count, gaugeContract, rewardContract, rewardMulticallContract, method, rawRewardTokens, rewardTokens, i, j, rewardAddress, rewardInfoCalls, i, poolId, pool, gaugeContract, gaugeMulticallContract, _b, _c, token, tokenMulticallContract, rawRewardInfo, i, poolId, pool, gaugeContract, token, symbol, decimals, _amount, amount, _d, _e, token, symbol, decimals, _amount, _claimedAmount, amount, _claimable, _f, pools_2, poolId;
+    var _g;
+    var _h;
+    return __generator(this, function (_j) {
+        switch (_j.label) {
+            case 0:
+                poolsToFetch = useCache ? pools.filter(function (poolId) { return _isUserClaimableCacheExpired(address, poolId); }) : pools;
+                if (!(poolsToFetch.length > 0)) return [3 /*break*/, 3];
+                hasCrvReward = [];
+                for (_i = 0, poolsToFetch_3 = poolsToFetch; _i < poolsToFetch_3.length; _i++) {
+                    poolId = poolsToFetch_3[_i];
+                    pool = (0, poolConstructor_1.getPool)(poolId);
+                    if (curve_1.curve.chainId === 2222 || pool.gauge === ethers_1.ethers.constants.AddressZero) { // TODO remove this for Kava
+                        hasCrvReward.push(false);
+                        continue;
+                    }
+                    gaugeContract = curve_1.curve.contracts[pool.gauge].contract;
+                    hasCrvReward.push('inflation_rate()' in gaugeContract || 'inflation_rate(uint256)' in gaugeContract);
+                }
+                rewardCount = [];
+                for (_a = 0, poolsToFetch_4 = poolsToFetch; _a < poolsToFetch_4.length; _a++) {
+                    poolId = poolsToFetch_4[_a];
+                    pool = (0, poolConstructor_1.getPool)(poolId);
+                    if (pool.gauge === ethers_1.ethers.constants.AddressZero) {
+                        rewardCount.push(0);
+                        continue;
+                    }
+                    gaugeContract = curve_1.curve.contracts[pool.gauge].contract;
+                    if ("reward_tokens(uint256)" in gaugeContract) { // gauge_v2, gauge_v3, gauge_v4, gauge_v5, gauge_factory, gauge_rewards_only, gauge_child
+                        rewardCount.push(8);
+                    }
+                    else if ('claimable_reward(address)' in gaugeContract) { // gauge_synthetix
+                        rewardCount.push(-1);
+                    }
+                    else { // gauge
+                        rewardCount.push(0);
+                    }
+                }
+                rewardTokenCalls = [];
+                for (i = 0; i < poolsToFetch.length; i++) {
+                    pool = (0, poolConstructor_1.getPool)(poolsToFetch[i]);
+                    if (rewardCount[i] !== -1) { // no_gauge, gauge, gauge_v2, gauge_v3, gauge_v4, gauge_v5, gauge_factory, gauge_rewards_only, gauge_child
+                        for (count = 0; count < rewardCount[i]; count++) {
+                            gaugeContract = curve_1.curve.contracts[pool.gauge].multicallContract;
+                            rewardTokenCalls.push(gaugeContract.reward_tokens(count));
+                        }
+                    }
+                    else { // gauge_synthetix
+                        rewardCount[i] = 1;
+                        rewardContract = curve_1.curve.contracts[pool.sRewardContract].contract;
+                        rewardMulticallContract = curve_1.curve.contracts[pool.sRewardContract].multicallContract;
+                        method = "snx()" in rewardContract ? "snx" : "rewardsToken" // susd, tbtc : dusd, musd, rsv, sbtc
+                        ;
+                        rewardTokenCalls.push(rewardMulticallContract[method]());
+                    }
+                }
+                return [4 /*yield*/, curve_1.curve.multicallProvider.all(rewardTokenCalls)];
+            case 1:
+                rawRewardTokens = (_j.sent()).map(function (t) { return t.toLowerCase(); });
+                rewardTokens = {};
+                for (i = 0; i < poolsToFetch.length; i++) {
+                    rewardTokens[poolsToFetch[i]] = [];
+                    for (j = 0; j < rewardCount[i]; j++) {
+                        rewardAddress = rawRewardTokens.shift();
+                        if (rewardAddress === ethers_1.ethers.constants.AddressZero)
+                            continue;
+                        rewardTokens[poolsToFetch[i]].push(rewardAddress);
+                    }
+                }
+                rewardInfoCalls = [];
+                for (i = 0; i < poolsToFetch.length; i++) {
+                    poolId = poolsToFetch[i];
+                    pool = (0, poolConstructor_1.getPool)(poolId);
+                    if (pool.gauge === ethers_1.ethers.constants.AddressZero)
+                        continue;
+                    gaugeContract = curve_1.curve.contracts[pool.gauge].contract;
+                    gaugeMulticallContract = curve_1.curve.contracts[pool.gauge].multicallContract;
+                    if (hasCrvReward[i]) {
+                        rewardInfoCalls.push(gaugeMulticallContract.claimable_tokens(address));
+                    }
+                    for (_b = 0, _c = rewardTokens[poolId]; _b < _c.length; _b++) {
+                        token = _c[_b];
+                        (0, utils_1._setContracts)(token, ERC20_json_1.default);
+                        tokenMulticallContract = curve_1.curve.contracts[token].multicallContract;
+                        rewardInfoCalls.push(tokenMulticallContract.symbol(), tokenMulticallContract.decimals());
+                        if ('claimable_reward(address,address)' in gaugeContract) {
+                            rewardInfoCalls.push(gaugeMulticallContract.claimable_reward(address, token));
+                        }
+                        else if ('claimable_reward(address)' in gaugeContract) { // Synthetix Gauge
+                            rewardInfoCalls.push(gaugeMulticallContract.claimable_reward(address), gaugeMulticallContract.claimed_rewards_for(address));
+                        }
+                    }
+                }
+                return [4 /*yield*/, curve_1.curve.multicallProvider.all(rewardInfoCalls)];
+            case 2:
+                rawRewardInfo = _j.sent();
+                for (i = 0; i < poolsToFetch.length; i++) {
+                    poolId = poolsToFetch[i];
+                    pool = (0, poolConstructor_1.getPool)(poolId);
+                    if (!_userClaimableCache[address])
+                        _userClaimableCache[address] = (_g = {}, _g[poolId] = { rewards: [], time: Date.now() }, _g);
+                    if (!_userClaimableCache[address][poolId])
+                        _userClaimableCache[address][poolId] = { rewards: [], time: Date.now() };
+                    if (pool.gauge === ethers_1.ethers.constants.AddressZero)
+                        continue;
+                    gaugeContract = curve_1.curve.contracts[pool.gauge].contract;
+                    if (hasCrvReward[i]) {
+                        token = curve_1.curve.constants.ALIASES.crv;
+                        symbol = 'CRV';
+                        decimals = 18;
+                        _amount = rawRewardInfo.shift();
+                        amount = ethers_1.ethers.utils.formatUnits(_amount, decimals);
+                        if (Number(amount) > 0)
+                            _userClaimableCache[address][poolId].rewards.push({ token: token, symbol: symbol, amount: amount });
+                    }
+                    for (_d = 0, _e = rewardTokens[poolId]; _d < _e.length; _d++) {
+                        token = _e[_d];
+                        symbol = rawRewardInfo.shift();
+                        decimals = rawRewardInfo.shift();
+                        _amount = rawRewardInfo.shift();
+                        if ('claimable_reward(address)' in gaugeContract) {
+                            _claimedAmount = rawRewardInfo.shift();
+                            _amount = _amount.sub(_claimedAmount);
+                        }
+                        amount = ethers_1.ethers.utils.formatUnits(_amount, decimals);
+                        if (Number(amount) > 0)
+                            _userClaimableCache[address][poolId].rewards.push({ token: token, symbol: symbol, amount: amount });
+                    }
+                }
+                _j.label = 3;
+            case 3:
+                _claimable = [];
+                for (_f = 0, pools_2 = pools; _f < pools_2.length; _f++) {
+                    poolId = pools_2[_f];
+                    _claimable.push((_h = _userClaimableCache[address]) === null || _h === void 0 ? void 0 : _h[poolId].rewards);
+                }
+                return [2 /*return*/, _claimable];
+        }
+    });
+}); };
+var getUserPoolListByClaimable = function (address) {
+    if (address === void 0) { address = curve_1.curve.signerAddress; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var pools, _claimable, userPoolList, i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    pools = __spreadArray(__spreadArray(__spreadArray([], (0, exports.getPoolList)(), true), (0, exports.getFactoryPoolList)(), true), (0, exports.getCryptoFactoryPoolList)(), true);
+                    return [4 /*yield*/, _getUserClaimable(pools, address, false)];
+                case 1:
+                    _claimable = _a.sent();
+                    userPoolList = [];
+                    for (i = 0; i < pools.length; i++) {
+                        if (_claimable[i].length > 0) {
+                            userPoolList.push(pools[i]);
+                        }
+                    }
+                    return [2 /*return*/, userPoolList];
+            }
+        });
+    });
+};
+exports.getUserPoolListByClaimable = getUserPoolListByClaimable;
+var getUserClaimable = function (pools, address) {
+    if (address === void 0) { address = curve_1.curve.signerAddress; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _claimable, claimableWithPrice, i, _i, _a, c, price;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, _getUserClaimable(pools, address, true)];
+                case 1:
+                    _claimable = _b.sent();
+                    claimableWithPrice = [];
+                    i = 0;
+                    _b.label = 2;
+                case 2:
+                    if (!(i < pools.length)) return [3 /*break*/, 7];
+                    claimableWithPrice.push([]);
+                    _i = 0, _a = _claimable[i];
+                    _b.label = 3;
+                case 3:
+                    if (!(_i < _a.length)) return [3 /*break*/, 6];
+                    c = _a[_i];
+                    return [4 /*yield*/, (0, utils_1._getUsdRate)(c.token)];
+                case 4:
+                    price = _b.sent();
+                    claimableWithPrice[claimableWithPrice.length - 1].push(__assign(__assign({}, c), { price: price }));
+                    _b.label = 5;
+                case 5:
+                    _i++;
+                    return [3 /*break*/, 3];
+                case 6:
+                    i++;
+                    return [3 /*break*/, 2];
+                case 7: return [2 /*return*/, claimableWithPrice];
+            }
+        });
+    });
+};
+exports.getUserClaimable = getUserClaimable;
+var getUserPoolList = function (address) {
+    if (address === void 0) { address = curve_1.curve.signerAddress; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var pools, _a, _lpBalances, _claimable, userPoolList, i;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    pools = __spreadArray(__spreadArray(__spreadArray([], (0, exports.getPoolList)(), true), (0, exports.getFactoryPoolList)(), true), (0, exports.getCryptoFactoryPoolList)(), true);
+                    return [4 /*yield*/, Promise.all([
+                            _getUserLpBalances(pools, address, false),
+                            _getUserClaimable(pools, address, false),
+                        ])];
+                case 1:
+                    _a = _b.sent(), _lpBalances = _a[0], _claimable = _a[1];
+                    userPoolList = [];
+                    for (i = 0; i < pools.length; i++) {
+                        if (_lpBalances[i].gt(0) || _claimable[i].length > 0) {
+                            userPoolList.push(pools[i]);
+                        }
+                    }
+                    return [2 /*return*/, userPoolList];
+            }
+        });
+    });
+};
+exports.getUserPoolList = getUserPoolList;

package/lib/utils.js

@@ -454,7 +454,10 @@ var _getUsdRate = function (assetId) { return __awaiter(void 0, void 0, void 0,
     var _a, _b;
     return __generator(this, function (_c) {
         switch (_c.label) {
-            case 0: return [4 /*yield*/, (0, exports._getUsdPricesFromApi)()];
+            case 0:
+                if (curve_1.curve.chainId === 1 && assetId.toLowerCase() === '0x8762db106b2c2a0bccb3a80d1ed41273552616e8')
+                    return [2 /*return*/, 0]; // RSR
+                return [4 /*yield*/, (0, exports._getUsdPricesFromApi)()];
             case 1:
                 pricesFromApi = _c.sent();
                 if (assetId.toLowerCase() in pricesFromApi)
@@ -513,10 +516,10 @@ var _getUsdRate = function (assetId) { return __awaiter(void 0, void 0, void 0,
             case 2:
                 response = _c.sent();
                 try {
-                    _usdRatesCache[assetId] = { 'rate': (_b = response.data[assetId]['usd']) !== null && _b !== void 0 ? _b : 1, 'time': Date.now() };
+                    _usdRatesCache[assetId] = { 'rate': (_b = response.data[assetId]['usd']) !== null && _b !== void 0 ? _b : 0, 'time': Date.now() };
                 }
                 catch (err) { // TODO pay attention!
-                    _usdRatesCache[assetId] = { 'rate': 1, 'time': Date.now() };
+                    _usdRatesCache[assetId] = { 'rate': 0, 'time': Date.now() };
                 }
                 _c.label = 3;
             case 3: return [2 /*return*/, _usdRatesCache[assetId]['rate']];

package/package.json

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