@curvefi/api 2.1.0 → 2.3.0

package/lib/interfaces.d.ts

@@ -3,33 +3,7 @@ import { Contract as MulticallContract, Provider as MulticallProvider } from "et
 export interface IDict<T> {
     [index: string]: T;
 }
-export interface ICurve {
-    provider: ethers.providers.Web3Provider | ethers.providers.JsonRpcProvider;
-    multicallProvider: MulticallProvider;
-    signer: ethers.Signer | null;
-    signerAddress: string;
-    chainId: number;
-    contracts: {
-        [index: string]: {
-            contract: Contract;
-            multicallContract: MulticallContract;
-        };
-    };
-    feeData: {
-        gasPrice?: number;
-        maxFeePerGas?: number;
-        maxPriorityFeePerGas?: number;
-    };
-    constantOptions: {
-        gasLimit: number;
-    };
-    options: {
-        gasPrice?: number | ethers.BigNumber;
-        maxFeePerGas?: number | ethers.BigNumber;
-        maxPriorityFeePerGas?: number | ethers.BigNumber;
-    };
-    constants: IDict<any>;
-}
+export declare type INetworkName = "ethereum" | "polygon" | "avalanche";
 export declare type REFERENCE_ASSET = 'USD' | 'EUR' | 'BTC' | 'ETH' | 'LINK' | 'CRYPTO' | 'OTHER';
 export interface IPoolData {
     name: string;
@@ -56,13 +30,47 @@ export interface IPoolData {
     underlying_decimals: number[];
     wrapped_decimals: number[];
     use_lending?: boolean[];
-    reward_tokens?: string[];
-    reward_decimals?: number[];
     swap_abi: any;
     gauge_abi: any;
     deposit_abi?: any;
     sCurveRewards_abi?: any;
 }
+export interface ICurve {
+    provider: ethers.providers.Web3Provider | ethers.providers.JsonRpcProvider;
+    multicallProvider: MulticallProvider;
+    signer: ethers.Signer | null;
+    signerAddress: string;
+    chainId: number;
+    contracts: {
+        [index: string]: {
+            contract: Contract;
+            multicallContract: MulticallContract;
+        };
+    };
+    feeData: {
+        gasPrice?: number;
+        maxFeePerGas?: number;
+        maxPriorityFeePerGas?: number;
+    };
+    constantOptions: {
+        gasLimit: number;
+    };
+    options: {
+        gasPrice?: number | ethers.BigNumber;
+        maxFeePerGas?: number | ethers.BigNumber;
+        maxPriorityFeePerGas?: number | ethers.BigNumber;
+    };
+    constants: {
+        NETWORK_NAME: INetworkName;
+        ALIASES: IDict<string>;
+        POOLS_DATA: IDict<IPoolData>;
+        FACTORY_POOLS_DATA: IDict<IPoolData>;
+        CRYPTO_FACTORY_POOLS_DATA: IDict<IPoolData>;
+        COINS: IDict<string>;
+        DECIMALS: IDict<number>;
+        GAUGES: string[];
+    };
+}
 export interface ICoinFromPoolDataApi {
     address: string;
     symbol: string;

package/lib/pools/PoolTemplate.d.ts

@@ -1,3 +1,4 @@
+import memoize from "memoizee";
 import { IDict, IReward } from '../interfaces';
 export declare class PoolTemplate {
     id: string;
@@ -9,6 +10,7 @@ export declare class PoolTemplate {
     lpToken: string;
     gauge: string;
     zap: string | null;
+    sRewardContract: string | null;
     rewardContract: string | null;
     isPlain: boolean;
     isLending: boolean;
@@ -25,7 +27,6 @@ export declare class PoolTemplate {
     underlyingDecimals: number[];
     wrappedDecimals: number[];
     useLending: boolean[];
-    rewardTokens: string[];
     estimateGas: {
         depositApprove: (amounts: (number | string)[]) => Promise<number>;
         deposit: (amounts: (number | string)[]) => Promise<number>;
@@ -122,6 +123,15 @@ export declare class PoolTemplate {
     claimableCrv(address?: string): Promise<string>;
     claimCrvEstimateGas(): Promise<number>;
     claimCrv(): Promise<string>;
+    rewardTokens: (() => Promise<{
+        token: string;
+        symbol: string;
+        decimals: number;
+    }[]>) & memoize.Memoized<() => Promise<{
+        token: string;
+        symbol: string;
+        decimals: number;
+    }[]>>;
     claimableRewards(address?: string): Promise<{
         token: string;
         symbol: string;

package/lib/pools/PoolTemplate.js

@@ -62,9 +62,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolTemplate = void 0;
 var ethers_1 = require("ethers");
 var bignumber_js_1 = __importDefault(require("bignumber.js"));
+var memoizee_1 = __importDefault(require("memoizee"));
 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 PoolTemplate = /** @class */ (function () {
     function PoolTemplate(id) {
         var _this = this;
@@ -119,7 +121,7 @@ var PoolTemplate = /** @class */ (function () {
                     switch (_c.label) {
                         case 0:
                             if (!useApi) return [3 /*break*/, 2];
-                            network = curve_1.curve.chainId === 137 ? "polygon" : "ethereum";
+                            network = curve_1.curve.constants.NETWORK_NAME;
                             poolType = !this.isFactory && !this.isCrypto ? "main" :
                                 !this.isFactory ? "crypto" :
                                     !(this.isCrypto && this.isFactory) ? "factory" :
@@ -158,7 +160,7 @@ var PoolTemplate = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        network = curve_1.curve.chainId === 137 ? "polygon" : "ethereum";
+                        network = curve_1.curve.constants.NETWORK_NAME;
                         return [4 /*yield*/, (0, external_api_1._getSubgraphData)(network)];
                     case 1:
                         poolsData = (_a.sent());
@@ -175,7 +177,7 @@ var PoolTemplate = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        network = curve_1.curve.chainId === 137 ? "polygon" : "ethereum";
+                        network = curve_1.curve.constants.NETWORK_NAME;
                         return [4 /*yield*/, (0, external_api_1._getSubgraphData)(network)];
                     case 1:
                         poolsData = (_a.sent());
@@ -190,36 +192,55 @@ var PoolTemplate = /** @class */ (function () {
             });
         }); };
         this.statsTokenApy = function () { return __awaiter(_this, void 0, void 0, function () {
-            var gaugeContract, lpTokenContract, gaugeControllerContract, totalLiquidityUSD, _a, inflation, weight, workingSupply, totalSupply, rate, crvRate, baseApy, boostedApy;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var totalLiquidityUSD, gaugeContract_1, crvContract, week, currentWeek, inflationRateBN, _a, _c, crvRate_1, apy, gaugeContract, lpTokenContract, gaugeControllerContract, _d, inflation, weight, workingSupply, totalSupply, rate, crvRate, baseApy, boostedApy;
+            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 (curve_1.curve.chainId === 137)
-                            throw Error("No such method on network with id ".concat(curve_1.curve.chainId, ". Use getRewardsApy instead"));
-                        gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
-                        lpTokenContract = curve_1.curve.contracts[this.lpToken].multicallContract;
-                        gaugeControllerContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.gauge_controller].multicallContract;
                         return [4 /*yield*/, this.statsTotalLiquidity()];
                     case 1:
-                        totalLiquidityUSD = _c.sent();
+                        totalLiquidityUSD = _e.sent();
                         if (Number(totalLiquidityUSD) === 0)
                             return [2 /*return*/, ["0", "0"]];
+                        if (!(curve_1.curve.chainId !== 1)) return [3 /*break*/, 6];
+                        gaugeContract_1 = curve_1.curve.contracts[this.gauge].contract;
+                        crvContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.crv].contract;
+                        week = 7 * 86400;
+                        currentWeek = Math.floor(Date.now() / 1000 / week);
+                        _a = utils_1.toBN;
+                        return [4 /*yield*/, gaugeContract_1.inflation_rate(currentWeek, curve_1.curve.constantOptions)];
+                    case 2:
+                        inflationRateBN = _a.apply(void 0, [_e.sent()]);
+                        if (!inflationRateBN.eq(0)) return [3 /*break*/, 4];
+                        _c = utils_1.toBN;
+                        return [4 /*yield*/, crvContract.balanceOf(this.gauge, curve_1.curve.constantOptions)];
+                    case 3:
+                        inflationRateBN = _c.apply(void 0, [_e.sent()]).div(week);
+                        _e.label = 4;
+                    case 4: return [4 /*yield*/, (0, utils_1._getUsdRate)(curve_1.curve.constants.ALIASES.crv)];
+                    case 5:
+                        crvRate_1 = _e.sent();
+                        apy = inflationRateBN.times(31536000).times(crvRate_1).div(Number(totalLiquidityUSD));
+                        return [2 /*return*/, [apy.times(100).toFixed(4), apy.times(100).toFixed(4)]];
+                    case 6:
+                        gaugeContract = curve_1.curve.contracts[this.gauge].multicallContract;
+                        lpTokenContract = curve_1.curve.contracts[this.lpToken].multicallContract;
+                        gaugeControllerContract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.gauge_controller].multicallContract;
                         return [4 /*yield*/, curve_1.curve.multicallProvider.all([
                                 gaugeContract.inflation_rate(),
                                 gaugeControllerContract.gauge_relative_weight(this.gauge),
                                 gaugeContract.working_supply(),
                                 lpTokenContract.totalSupply(),
                             ])];
-                    case 2:
-                        _a = (_c.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflation = _a[0], weight = _a[1], workingSupply = _a[2], totalSupply = _a[3];
+                    case 7:
+                        _d = (_e.sent()).map(function (value) { return (0, utils_1.toBN)(value); }), inflation = _d[0], weight = _d[1], workingSupply = _d[2], totalSupply = _d[3];
                         if (Number(workingSupply) === 0)
                             return [2 /*return*/, ["0", "0"]];
                         rate = inflation.times(weight).times(31536000).times(0.4).div(workingSupply).times(totalSupply).div(Number(totalLiquidityUSD));
                         return [4 /*yield*/, (0, utils_1._getUsdRate)(curve_1.curve.constants.ALIASES.crv)];
-                    case 3:
-                        crvRate = _c.sent();
+                    case 8:
+                        crvRate = _e.sent();
                         baseApy = rate.times(crvRate);
                         boostedApy = baseApy.times(2.5);
                         return [2 /*return*/, [baseApy.times(100).toFixed(4), boostedApy.times(100).toFixed(4)]];
@@ -227,47 +248,47 @@ var PoolTemplate = /** @class */ (function () {
             });
         }); };
         this.statsRewardsApy = function () { return __awaiter(_this, void 0, void 0, function () {
-            var apy, _i, _a, rewardToken, rewardContract, totalLiquidityUSD, crvRate, inflation, _c, baseApy, rewardTokenContract, symbol, network, promises, _d, mainPoolsRewards, allTypesExtendedPoolData, rewards, _e, _f, extendedPoolData, _g, _h, pool;
-            var _j;
-            return __generator(this, function (_k) {
-                switch (_k.label) {
+            var apy, rewardTokens, _i, rewardTokens_1, rewardToken, gaugeContract, totalLiquidityUSD, rewardRate, rewardData, periodFinish, inflation, baseApy, network, promises, _a, mainPoolsRewards, allTypesExtendedPoolData, rewards, _c, _d, extendedPoolData, _e, _f, pool;
+            var _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
                     case 0:
-                        if (!(curve_1.curve.chainId === 137)) return [3 /*break*/, 8];
+                        if (![137, 43114].includes(curve_1.curve.chainId)) return [3 /*break*/, 8];
                         apy = [];
-                        _i = 0, _a = this.rewardTokens;
-                        _k.label = 1;
+                        return [4 /*yield*/, this.rewardTokens()];
                     case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 7];
-                        rewardToken = _a[_i];
-                        rewardContract = curve_1.curve.contracts[this.rewardContract].contract;
-                        return [4 /*yield*/, this.statsTotalLiquidity()];
+                        rewardTokens = _h.sent();
+                        _i = 0, rewardTokens_1 = rewardTokens;
+                        _h.label = 2;
                     case 2:
-                        totalLiquidityUSD = _k.sent();
-                        return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken)];
+                        if (!(_i < rewardTokens_1.length)) return [3 /*break*/, 7];
+                        rewardToken = rewardTokens_1[_i];
+                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
+                        return [4 /*yield*/, this.statsTotalLiquidity()];
                     case 3:
-                        crvRate = _k.sent();
-                        _c = utils_1.toBN;
-                        return [4 /*yield*/, rewardContract.reward_data(curve_1.curve.constants.ALIASES.crv, curve_1.curve.constantOptions)];
+                        totalLiquidityUSD = _h.sent();
+                        return [4 /*yield*/, (0, utils_1._getUsdRate)(rewardToken.token)];
                     case 4:
-                        inflation = _c.apply(void 0, [(_k.sent()).rate]);
-                        baseApy = inflation.times(31536000).times(crvRate).div(Number(totalLiquidityUSD));
-                        rewardTokenContract = curve_1.curve.contracts[rewardToken].contract;
-                        return [4 /*yield*/, rewardTokenContract.symbol()];
+                        rewardRate = _h.sent();
+                        return [4 /*yield*/, gaugeContract.reward_data(rewardToken.token, curve_1.curve.constantOptions)];
                     case 5:
-                        symbol = _k.sent();
+                        rewardData = _h.sent();
+                        periodFinish = Number(ethers_1.ethers.utils.formatUnits(rewardData.period_finish, 0)) * 1000;
+                        inflation = (0, utils_1.toBN)(rewardData.rate, rewardToken.decimals);
+                        baseApy = periodFinish > Date.now() ? inflation.times(31536000).times(rewardRate).div(Number(totalLiquidityUSD)) : (0, utils_1.BN)(0);
                         apy.push({
                             gaugeAddress: this.gauge.toLowerCase(),
-                            tokenAddress: rewardToken,
-                            symbol: symbol,
+                            tokenAddress: rewardToken.token,
+                            symbol: rewardToken.symbol,
                             apy: Number(baseApy.times(100).toFixed(4)),
                         });
-                        _k.label = 6;
+                        _h.label = 6;
                     case 6:
                         _i++;
-                        return [3 /*break*/, 1];
+                        return [3 /*break*/, 2];
                     case 7: return [2 /*return*/, apy];
                     case 8:
-                        network = curve_1.curve.chainId === 137 ? "polygon" : "ethereum";
+                        network = curve_1.curve.constants.NETWORK_NAME;
                         promises = [
                             (0, external_api_1._getMainPoolsGaugeRewards)(),
                             (0, external_api_1._getPoolsFromApi)(network, "main"),
@@ -277,21 +298,87 @@ var PoolTemplate = /** @class */ (function () {
                         ];
                         return [4 /*yield*/, Promise.all(promises)];
                     case 9:
-                        _d = _k.sent(), mainPoolsRewards = _d[0], allTypesExtendedPoolData = _d.slice(1);
+                        _a = _h.sent(), mainPoolsRewards = _a[0], allTypesExtendedPoolData = _a.slice(1);
                         rewards = mainPoolsRewards;
-                        for (_e = 0, _f = allTypesExtendedPoolData; _e < _f.length; _e++) {
-                            extendedPoolData = _f[_e];
-                            for (_g = 0, _h = extendedPoolData.poolData; _g < _h.length; _g++) {
-                                pool = _h[_g];
+                        for (_c = 0, _d = allTypesExtendedPoolData; _c < _d.length; _c++) {
+                            extendedPoolData = _d[_c];
+                            for (_e = 0, _f = extendedPoolData.poolData; _e < _f.length; _e++) {
+                                pool = _f[_e];
                                 if (pool.gaugeAddress && pool.gaugeRewards) {
                                     rewards[pool.gaugeAddress.toLowerCase()] = pool.gaugeRewards;
                                 }
                             }
                         }
-                        return [2 /*return*/, (_j = rewards[this.gauge.toLowerCase()]) !== null && _j !== void 0 ? _j : []];
+                        return [2 /*return*/, (_g = rewards[this.gauge.toLowerCase()]) !== null && _g !== void 0 ? _g : []];
                 }
             });
         }); };
+        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) {
+                switch (_f.label) {
+                    case 0:
+                        if (this.gauge === ethers_1.ethers.constants.AddressZero)
+                            return [2 /*return*/, []];
+                        gaugeContract = curve_1.curve.contracts[this.gauge].contract;
+                        gaugeMulticallContract = curve_1.curve.contracts[this.gauge].multicallContract;
+                        if (!("reward_tokens(uint256)" in gaugeContract)) return [3 /*break*/, 5];
+                        rewardCount = 8;
+                        if (!("reward_count()" in gaugeContract)) return [3 /*break*/, 2];
+                        _a = Number;
+                        _d = (_c = ethers_1.ethers.utils).formatUnits;
+                        return [4 /*yield*/, gaugeContract.reward_count(curve_1.curve.constantOptions)];
+                    case 1:
+                        rewardCount = _a.apply(void 0, [_d.apply(_c, [_f.sent(), 0])]);
+                        _f.label = 2;
+                    case 2:
+                        tokenCalls = [];
+                        for (i = 0; i < rewardCount; i++) {
+                            tokenCalls.push(gaugeMulticallContract.reward_tokens(i));
+                        }
+                        return [4 /*yield*/, curve_1.curve.multicallProvider.all(tokenCalls)];
+                    case 3:
+                        tokens = (_f.sent())
+                            .filter(function (addr) { return addr !== ethers_1.ethers.constants.AddressZero; })
+                            .map(function (addr) { return addr.toLowerCase(); });
+                        tokenInfoCalls = [];
+                        for (_i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+                            token = tokens_1[_i];
+                            (0, utils_1._setContracts)(token, ERC20_json_1.default);
+                            tokenMulticallContract = curve_1.curve.contracts[token].multicallContract;
+                            tokenInfoCalls.push(tokenMulticallContract.symbol(), tokenMulticallContract.decimals());
+                        }
+                        return [4 /*yield*/, curve_1.curve.multicallProvider.all(tokenInfoCalls)];
+                    case 4:
+                        tokenInfo_1 = _f.sent();
+                        for (i = 0; i < tokens.length; i++) {
+                            curve_1.curve.constants.DECIMALS[tokens[i]] = tokenInfo_1[(i * 2) + 1];
+                        }
+                        return [2 /*return*/, tokens.map(function (token, i) { return ({ token: token, symbol: tokenInfo_1[i * 2], decimals: tokenInfo_1[(i * 2) + 1] }); })];
+                    case 5:
+                        if (!('claimable_reward(address)' in gaugeContract)) return [3 /*break*/, 8];
+                        rewardContract = curve_1.curve.contracts[this.sRewardContract].contract;
+                        method = "snx()" in rewardContract ? "snx" : "rewardsToken" // susd, tbtc : dusd, musd, rsv, sbtc
+                        ;
+                        return [4 /*yield*/, rewardContract[method](curve_1.curve.constantOptions)];
+                    case 6:
+                        token = (_f.sent()).toLowerCase();
+                        (0, utils_1._setContracts)(token, ERC20_json_1.default);
+                        tokenMulticallContract = curve_1.curve.contracts[token].multicallContract;
+                        return [4 /*yield*/, curve_1.curve.multicallProvider.all([
+                                tokenMulticallContract.symbol(),
+                                tokenMulticallContract.decimals(),
+                            ])];
+                    case 7:
+                        _e = _f.sent(), symbol = _e[0], decimals = _e[1];
+                        return [2 /*return*/, [{ token: token, symbol: symbol, decimals: decimals }]];
+                    case 8: return [2 /*return*/, []]; // gauge
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 30 * 60 * 1000, // 30m
+        });
         // ---------------- ... ----------------
         this.gaugeMaxBoostedDeposit = function () {
             var addresses = [];
@@ -637,6 +724,7 @@ var PoolTemplate = /** @class */ (function () {
         this.lpToken = poolData.token_address;
         this.gauge = poolData.gauge_address;
         this.zap = poolData.deposit_address || null;
+        this.sRewardContract = poolData.sCurveRewards_address || null;
         this.rewardContract = poolData.reward_contract || null;
         this.isPlain = poolData.is_plain || false;
         this.isLending = poolData.is_lending || false;
@@ -653,7 +741,6 @@ var PoolTemplate = /** @class */ (function () {
         this.underlyingDecimals = poolData.underlying_decimals;
         this.wrappedDecimals = poolData.wrapped_decimals;
         this.useLending = poolData.use_lending || poolData.underlying_coin_addresses.map(function () { return false; });
-        this.rewardTokens = poolData.reward_tokens || [];
         this.estimateGas = {
             depositApprove: this.depositApproveEstimateGas.bind(this),
             deposit: this.depositEstimateGas.bind(this),
@@ -1091,8 +1178,6 @@ var PoolTemplate = /** @class */ (function () {
                         if (this.gauge === ethers_1.ethers.constants.AddressZero) {
                             throw Error("claimableCrv method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
                         }
-                        if (curve_1.curve.chainId !== 1)
-                            throw Error("No such method on network with id ".concat(curve_1.curve.chainId, ". Use claimableRewards instead"));
                         address = address || curve_1.curve.signerAddress;
                         if (!address)
                             throw Error("Need to connect wallet or pass address into args");
@@ -1111,8 +1196,6 @@ var PoolTemplate = /** @class */ (function () {
                         if (this.gauge === ethers_1.ethers.constants.AddressZero) {
                             throw Error("claimCrv method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
                         }
-                        if (curve_1.curve.chainId !== 1)
-                            throw Error("No such method on network with id ".concat(curve_1.curve.chainId, ". Use claimRewards instead"));
                         return [4 /*yield*/, curve_1.curve.contracts[curve_1.curve.constants.ALIASES.minter].contract.estimateGas.mint(this.gauge, curve_1.curve.constantOptions)];
                     case 1: return [2 /*return*/, (_a.sent()).toNumber()];
                 }
@@ -1121,32 +1204,30 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.claimCrv = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var gasLimit;
+            var contract, gasLimit;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (this.gauge === ethers_1.ethers.constants.AddressZero) {
                             throw Error("claimCrv method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
                         }
-                        if (curve_1.curve.chainId !== 1)
-                            throw Error("No such method on network with id ".concat(curve_1.curve.chainId, ". Use claimRewards instead"));
-                        return [4 /*yield*/, curve_1.curve.contracts[curve_1.curve.constants.ALIASES.minter].contract.estimateGas.mint(this.gauge, curve_1.curve.constantOptions)];
+                        contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.minter].contract;
+                        return [4 /*yield*/, contract.estimateGas.mint(this.gauge, curve_1.curve.constantOptions)];
                     case 1:
                         gasLimit = (_a.sent()).mul(130).div(100);
-                        return [4 /*yield*/, curve_1.curve.contracts[curve_1.curve.constants.ALIASES.minter].contract.mint(this.gauge, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
+                        return [4 /*yield*/, contract.mint(this.gauge, __assign(__assign({}, curve_1.curve.options), { gasLimit: gasLimit }))];
                     case 2: return [2 /*return*/, (_a.sent()).hash];
                 }
             });
         });
     };
     // TODO 1. Fix aave and saave error
-    // TODO 2. Figure out Synthetix cumulative results
     PoolTemplate.prototype.claimableRewards = function (address) {
         if (address === void 0) { address = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var gaugeContract, rewards, _i, _a, rewardToken, rewardTokenContract, symbol, decimals, method, amount, _c, _d, rewardToken, rewardTokenContract, symbol, decimals, amount, _e, _f;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
+            var gaugeContract, rewardTokens, rewards, _i, rewardTokens_2, rewardToken, amount, _a, _c, rewardToken, _totalAmount, _claimedAmount;
+            return __generator(this, function (_d) {
+                switch (_d.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"));
@@ -1155,56 +1236,46 @@ var PoolTemplate = /** @class */ (function () {
                         if (!address)
                             throw Error("Need to connect wallet or pass address into args");
                         gaugeContract = curve_1.curve.contracts[this.gauge].contract;
-                        rewards = [];
-                        if (!('claimable_reward(address,address)' in gaugeContract)) return [3 /*break*/, 7];
-                        _i = 0, _a = this.rewardTokens;
-                        _g.label = 1;
+                        return [4 /*yield*/, this.rewardTokens()];
                     case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 6];
-                        rewardToken = _a[_i];
-                        rewardTokenContract = curve_1.curve.contracts[rewardToken].contract;
-                        return [4 /*yield*/, rewardTokenContract.symbol()];
+                        rewardTokens = _d.sent();
+                        rewards = [];
+                        if (!('claimable_reward(address,address)' in gaugeContract)) return [3 /*break*/, 6];
+                        _i = 0, rewardTokens_2 = rewardTokens;
+                        _d.label = 2;
                     case 2:
-                        symbol = _g.sent();
-                        return [4 /*yield*/, rewardTokenContract.decimals()];
+                        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)];
                     case 3:
-                        decimals = _g.sent();
-                        method = curve_1.curve.chainId === 1 ? "claimable_reward" : "claimable_reward_write";
-                        _d = (_c = ethers_1.ethers.utils).formatUnits;
-                        return [4 /*yield*/, gaugeContract[method](address, rewardToken, curve_1.curve.constantOptions)];
-                    case 4:
-                        amount = _d.apply(_c, [_g.sent(), decimals]);
+                        amount = _c.apply(_a, [_d.sent(), rewardToken.decimals]);
                         rewards.push({
-                            token: rewardToken,
-                            symbol: symbol,
+                            token: rewardToken.token,
+                            symbol: rewardToken.symbol,
                             amount: amount,
                         });
-                        _g.label = 5;
-                    case 5:
+                        _d.label = 4;
+                    case 4:
                         _i++;
-                        return [3 /*break*/, 1];
-                    case 6: return [3 /*break*/, 11];
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 9];
+                    case 6:
+                        if (!('claimable_reward(address)' in gaugeContract && rewardTokens.length > 0)) return [3 /*break*/, 9];
+                        rewardToken = rewardTokens[0];
+                        return [4 /*yield*/, gaugeContract.claimable_reward(address, curve_1.curve.constantOptions)];
                     case 7:
-                        if (!('claimable_reward(address)' in gaugeContract && this.rewardTokens.length > 0)) return [3 /*break*/, 11];
-                        rewardToken = this.rewardTokens[0];
-                        rewardTokenContract = curve_1.curve.contracts[rewardToken].contract;
-                        return [4 /*yield*/, rewardTokenContract.symbol()];
+                        _totalAmount = _d.sent();
+                        return [4 /*yield*/, gaugeContract.claimed_rewards_for(address, curve_1.curve.constantOptions)];
                     case 8:
-                        symbol = _g.sent();
-                        return [4 /*yield*/, rewardTokenContract.decimals()];
-                    case 9:
-                        decimals = _g.sent();
-                        _f = (_e = ethers_1.ethers.utils).formatUnits;
-                        return [4 /*yield*/, gaugeContract.claimable_reward(address, curve_1.curve.constantOptions)];
-                    case 10:
-                        amount = _f.apply(_e, [_g.sent(), decimals]);
+                        _claimedAmount = _d.sent();
                         rewards.push({
-                            token: rewardToken,
-                            symbol: symbol,
-                            amount: amount,
+                            token: rewardToken.token,
+                            symbol: rewardToken.symbol,
+                            amount: ethers_1.ethers.utils.formatUnits(_totalAmount.sub(_claimedAmount), rewardToken.decimals),
                         });
-                        _g.label = 11;
-                    case 11: return [2 /*return*/, rewards];
+                        _d.label = 9;
+                    case 9: return [2 /*return*/, rewards];
                 }
             });
         });
@@ -2182,7 +2253,7 @@ var PoolTemplate = /** @class */ (function () {
                         return [4 /*yield*/, this._swapExpected(i, j, _amount)];
                     case 1:
                         _output = _c.sent();
-                        target = (0, utils_1.BN)(1000000);
+                        target = (0, utils_1.BN)(Math.pow(10, 15));
                         amountIntBN = (0, utils_1.BN)(amount).times(Math.pow(10, inputCoinDecimals));
                         outputIntBN = (0, utils_1.toBN)(_output, 0);
                         k = bignumber_js_1.default.min(bignumber_js_1.default.max(target.div(amountIntBN), target.div(outputIntBN)), 0.2);
@@ -2206,7 +2277,7 @@ var PoolTemplate = /** @class */ (function () {
         });
     };
     PoolTemplate.prototype._swapContractAddress = function () {
-        return (this.isCrypto && this.isMeta) || (curve_1.curve.chainId === 137 && this.isMetaFactory) ? this.zap : this.address;
+        return (this.isCrypto && this.isMeta) || ([137, 43114].includes(curve_1.curve.chainId) && this.isMetaFactory) ? this.zap : this.address;
     };
     PoolTemplate.prototype.swapIsApproved = function (inputCoin, amount) {
         return __awaiter(this, void 0, void 0, function () {
@@ -2302,7 +2373,7 @@ var PoolTemplate = /** @class */ (function () {
                         return [4 /*yield*/, this._swapWrappedExpected(i, j, _amount)];
                     case 1:
                         _output = _c.sent();
-                        target = (0, utils_1.BN)(1000000);
+                        target = (0, utils_1.BN)(Math.pow(10, 15));
                         amountIntBN = (0, utils_1.BN)(amount).times(Math.pow(10, inputCoinDecimals));
                         outputIntBN = (0, utils_1.toBN)(_output, 0);
                         k = bignumber_js_1.default.min(bignumber_js_1.default.max(target.div(amountIntBN), target.div(outputIntBN)), 0.2);

package/lib/pools/poolConstructor.js

@@ -44,7 +44,7 @@ var getPool = function (poolId) {
         return Pool;
     }(PoolTemplate_1.PoolTemplate));
     // statsBalances
-    if (poolId === "atricrypto3") {
+    if (poolDummy.isFake) {
         Object.assign(Pool.prototype, poolBalancesMixin_1.poolBalancesAtricrypto3Mixin);
     }
     else if (poolDummy.isMeta) {
@@ -101,7 +101,7 @@ var getPool = function (poolId) {
         Object.assign(Pool.prototype, depositWrappedMixins_1.depositWrapped2argsMixin);
     }
     // withdrawExpected
-    if (poolId === 'atricrypto3') {
+    if (poolDummy.isFake) {
         Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawExpectedAtricrypto3Mixin);
     }
     else if (poolDummy.isMeta) {
@@ -207,7 +207,7 @@ var getPool = function (poolId) {
     if (poolId === 'tricrypto2') {
         Object.assign(Pool.prototype, swapMixins_1.swapTricrypto2Mixin);
     }
-    else if (curve_1.curve.chainId === 137 && poolDummy.isMetaFactory) {
+    else if ([137, 43114].includes(curve_1.curve.chainId) && poolDummy.isMetaFactory) {
         Object.assign(Pool.prototype, swapMixins_1.swapMetaFactoryMixin);
     }
     else {