@curvefi/api 2.52.5 → 2.53.1

package/lib/pools/PoolTemplate.js

@@ -56,8 +56,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import memoize from "memoizee";
 import { _getPoolsFromApi, _getSubgraphData, _getFactoryAPYsAndVolumes, _getLegacyAPYsAndVolumes } from '../external-api.js';
-import { _getCoinAddresses, _getBalances, _prepareAddresses, _ensureAllowance, _getUsdRate, hasAllowance, ensureAllowance, ensureAllowanceEstimateGas, BN, toBN, toStringFromBN, parseUnits, getEthIndex, fromBN, _cutZeros, _setContracts, _get_small_x, _get_price_impact, checkNumber, _getCrvApyFromApi, _getRewardsFromApi, mulBy1_3, smartNumber, DIGas, } from '../utils.js';
-import { curve as _curve, curve } from "../curve.js";
+import { _getCoinAddresses, _getBalances, _prepareAddresses, _ensureAllowance, _getUsdRate, hasAllowance, ensureAllowance, ensureAllowanceEstimateGas, BN, toBN, toStringFromBN, parseUnits, getEthIndex, fromBN, _cutZeros, _setContracts, _get_small_x, _get_price_impact, checkNumber, _getCrvApyFromApi, _getRewardsFromApi, mulBy1_3, smartNumber, DIGas, _getAddress, isMethodExist, } from '../utils.js';
+import { curve } from "../curve.js";
 import ERC20Abi from '../constants/abis/ERC20.json' assert { type: 'json' };
 var DAY = 86400;
 var WEEK = 7 * DAY;
@@ -293,30 +293,19 @@ var PoolTemplate = /** @class */ (function () {
                 }
             });
         }); };
-        this.statsTokenApy = function (useApi) {
-            if (useApi === void 0) { useApi = true; }
+        this._calcTokenApy = function (futureWorkingSupplyBN) {
+            if (futureWorkingSupplyBN === void 0) { futureWorkingSupplyBN = null; }
             return __awaiter(_this, void 0, void 0, function () {
-                var isDisabledChain, crvAPYs, poolCrvApy, totalLiquidityUSD, inflationRateBN, workingSupplyBN, totalSupplyBN, gaugeContract, lpTokenContract, crvContract, currentWeek, _c, gaugeContract, lpTokenContract, gaugeControllerContract, weightBN, rateBN, crvPrice, baseApyBN, boostedApyBN;
+                var totalLiquidityUSD, inflationRateBN, workingSupplyBN, totalSupplyBN, gaugeContract, lpTokenContract, crvContract, currentWeek, _c, gaugeContract, lpTokenContract, gaugeControllerContract, weightBN, rateBN, crvPrice, baseApyBN, boostedApyBN;
                 var _d, _e;
-                var _f;
-                return __generator(this, function (_g) {
-                    switch (_g.label) {
-                        case 0:
-                            if (this.rewardsOnly())
-                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
-                            isDisabledChain = [1313161554].includes(curve.chainId);
-                            if (!(useApi && !isDisabledChain)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, _getCrvApyFromApi()];
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0: return [4 /*yield*/, this.statsTotalLiquidity()];
                         case 1:
-                            crvAPYs = _g.sent();
-                            poolCrvApy = (_f = crvAPYs[this.gauge]) !== null && _f !== void 0 ? _f : [0, 0];
-                            return [2 /*return*/, [poolCrvApy[0], poolCrvApy[1]]];
-                        case 2: return [4 /*yield*/, this.statsTotalLiquidity()];
-                        case 3:
-                            totalLiquidityUSD = _g.sent();
+                            totalLiquidityUSD = _f.sent();
                             if (Number(totalLiquidityUSD) === 0)
                                 return [2 /*return*/, [0, 0]];
-                            if (!(curve.chainId !== 1)) return [3 /*break*/, 7];
+                            if (!(curve.chainId !== 1)) return [3 /*break*/, 5];
                             gaugeContract = curve.contracts[this.gauge].multicallContract;
                             lpTokenContract = curve.contracts[this.lpToken].multicallContract;
                             crvContract = curve.contracts[curve.constants.ALIASES.crv].contract;
@@ -326,16 +315,16 @@ var PoolTemplate = /** @class */ (function () {
                                     gaugeContract.working_supply(),
                                     lpTokenContract.totalSupply(),
                                 ])];
-                        case 4:
-                            _d = (_g.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _d[0], workingSupplyBN = _d[1], totalSupplyBN = _d[2];
-                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 6];
+                        case 2:
+                            _d = (_f.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _d[0], workingSupplyBN = _d[1], totalSupplyBN = _d[2];
+                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 4];
                             _c = toBN;
                             return [4 /*yield*/, crvContract.balanceOf(this.gauge, curve.constantOptions)];
+                        case 3:
+                            inflationRateBN = _c.apply(void 0, [_f.sent()]).div(WEEK);
+                            _f.label = 4;
+                        case 4: return [3 /*break*/, 7];
                         case 5:
-                            inflationRateBN = _c.apply(void 0, [_g.sent()]).div(WEEK);
-                            _g.label = 6;
-                        case 6: return [3 /*break*/, 9];
-                        case 7:
                             gaugeContract = curve.contracts[this.gauge].multicallContract;
                             lpTokenContract = curve.contracts[this.lpToken].multicallContract;
                             gaugeControllerContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
@@ -346,17 +335,19 @@ var PoolTemplate = /** @class */ (function () {
                                     gaugeContract.working_supply(),
                                     lpTokenContract.totalSupply(),
                                 ])];
-                        case 8:
-                            _e = (_g.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _e[0], weightBN = _e[1], workingSupplyBN = _e[2], totalSupplyBN = _e[3];
+                        case 6:
+                            _e = (_f.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _e[0], weightBN = _e[1], workingSupplyBN = _e[2], totalSupplyBN = _e[3];
                             inflationRateBN = inflationRateBN.times(weightBN);
-                            _g.label = 9;
-                        case 9:
+                            _f.label = 7;
+                        case 7:
                             if (inflationRateBN.eq(0))
                                 return [2 /*return*/, [0, 0]];
-                            rateBN = inflationRateBN.times(31536000).times(0.4).div(workingSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD));
+                            if (futureWorkingSupplyBN !== null)
+                                workingSupplyBN = futureWorkingSupplyBN;
+                            rateBN = inflationRateBN.times(31536000).div(workingSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)).times(0.4);
                             return [4 /*yield*/, _getUsdRate(curve.constants.ALIASES.crv)];
-                        case 10:
-                            crvPrice = _g.sent();
+                        case 8:
+                            crvPrice = _f.sent();
                             baseApyBN = rateBN.times(crvPrice);
                             boostedApyBN = baseApyBN.times(2.5);
                             return [2 /*return*/, [baseApyBN.times(100).toNumber(), boostedApyBN.times(100).toNumber()]];
@@ -364,6 +355,29 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
+        this.statsTokenApy = function (useApi) {
+            if (useApi === void 0) { useApi = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var isDisabledChain, crvAPYs, poolCrvApy;
+                var _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            isDisabledChain = [1313161554].includes(curve.chainId);
+                            if (!(useApi && !isDisabledChain)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, _getCrvApyFromApi()];
+                        case 1:
+                            crvAPYs = _d.sent();
+                            poolCrvApy = (_c = crvAPYs[this.gauge]) !== null && _c !== void 0 ? _c : [0, 0];
+                            return [2 /*return*/, [poolCrvApy[0], poolCrvApy[1]]];
+                        case 2: return [4 /*yield*/, this._calcTokenApy()];
+                        case 3: return [2 /*return*/, _d.sent()];
+                    }
+                });
+            });
+        };
         this.statsRewardsApy = function (useApi) {
             if (useApi === void 0) { useApi = true; }
             return __awaiter(_this, void 0, void 0, function () {
@@ -592,7 +606,7 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
-        this.boost = function (address) {
+        this.userBoost = function (address) {
             if (address === void 0) { address = ""; }
             return __awaiter(_this, void 0, void 0, function () {
                 var gaugeContract, _c, workingBalanceBN, balanceBN, boostBN;
@@ -601,9 +615,9 @@ var PoolTemplate = /** @class */ (function () {
                         case 0:
                             if (this.gauge === curve.constants.ZERO_ADDRESS)
                                 throw Error("".concat(this.name, " doesn't have gauge"));
-                            address = address || curve.signerAddress;
-                            if (!address)
-                                throw Error("Need to connect wallet or pass address into args");
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            address = _getAddress(address);
                             gaugeContract = curve.contracts[this.gauge].multicallContract;
                             return [4 /*yield*/, curve.multicallProvider.all([
                                     gaugeContract.working_balances(address),
@@ -621,27 +635,106 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
+        this._userFutureBoostAndWorkingSupply = function (address) { return __awaiter(_this, void 0, void 0, function () {
+            var veContractMulticall, gaugeContractMulticall, calls, _c, _votingBalance, _votingTotal, _gaugeBalance, _gaugeTotal, _workingBalance, _workingSupply, _futureWorkingBalance, _futureWorkingSupply, futureWorkingBalanceBN, balanceBN, boostBN;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        veContractMulticall = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
+                        gaugeContractMulticall = curve.contracts[this.gauge].multicallContract;
+                        calls = [
+                            veContractMulticall.balanceOf(address),
+                            veContractMulticall.totalSupply(),
+                            gaugeContractMulticall.balanceOf(address),
+                            gaugeContractMulticall.totalSupply(),
+                            gaugeContractMulticall.working_balances(address),
+                            gaugeContractMulticall.working_supply(),
+                        ];
+                        return [4 /*yield*/, curve.multicallProvider.all(calls)];
+                    case 1:
+                        _c = _d.sent(), _votingBalance = _c[0], _votingTotal = _c[1], _gaugeBalance = _c[2], _gaugeTotal = _c[3], _workingBalance = _c[4], _workingSupply = _c[5];
+                        _futureWorkingBalance = _gaugeBalance * BigInt(40) / BigInt(100);
+                        if (_votingTotal > BigInt(0)) {
+                            _futureWorkingBalance += _gaugeTotal * _votingBalance / _votingTotal * BigInt(60) / BigInt(100);
+                        }
+                        if (_futureWorkingBalance > _gaugeBalance)
+                            _futureWorkingBalance = _gaugeBalance;
+                        _futureWorkingSupply = _workingSupply - _workingBalance + _futureWorkingBalance;
+                        futureWorkingBalanceBN = toBN(_futureWorkingBalance);
+                        balanceBN = toBN(_gaugeBalance);
+                        boostBN = futureWorkingBalanceBN.div(0.4).div(balanceBN);
+                        return [2 /*return*/, [boostBN, toBN(_futureWorkingSupply)]];
+                }
+            });
+        }); };
+        this.userFutureBoost = function (address) {
+            if (address === void 0) { address = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var boostBN;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            address = _getAddress(address);
+                            return [4 /*yield*/, this._userFutureBoostAndWorkingSupply(address)];
+                        case 1:
+                            boostBN = (_c.sent())[0];
+                            if (boostBN.lt(1))
+                                return [2 /*return*/, '1.0'];
+                            if (boostBN.gt(2.5))
+                                return [2 /*return*/, '2.5'];
+                            return [2 /*return*/, boostBN.toFixed(4).replace(/([0-9])0+$/, '$1')];
+                    }
+                });
+            });
+        };
         this.userCrvApy = function (address) {
             if (address === void 0) { address = ""; }
             return __awaiter(_this, void 0, void 0, function () {
-                var _c, baseApy, maxApy, boost;
+                var _c, minApy, maxApy, boost;
                 return __generator(this, function (_d) {
                     switch (_d.label) {
                         case 0:
-                            address = address || curve.signerAddress;
-                            if (!address)
-                                throw Error("Need to connect wallet or pass address into args");
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            address = _getAddress(address);
                             return [4 /*yield*/, this.statsTokenApy()];
                         case 1:
-                            _c = _d.sent(), baseApy = _c[0], maxApy = _c[1];
-                            return [4 /*yield*/, this.boost(address)];
+                            _c = _d.sent(), minApy = _c[0], maxApy = _c[1];
+                            return [4 /*yield*/, this.userBoost(address)];
                         case 2:
                             boost = _d.sent();
                             if (boost == "2.5")
                                 return [2 /*return*/, maxApy];
                             if (boost === "NaN")
                                 return [2 /*return*/, NaN];
-                            return [2 /*return*/, BN(baseApy).times(BN(boost)).toNumber()];
+                            return [2 /*return*/, BN(minApy).times(BN(boost)).toNumber()];
+                    }
+                });
+            });
+        };
+        this.userFutureCrvApy = function (address) {
+            if (address === void 0) { address = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _c, boostBN, futureWorkingSupplyBN, _d, minApy, maxApy;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            if (this.rewardsOnly())
+                                throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                            address = _getAddress(address);
+                            return [4 /*yield*/, this._userFutureBoostAndWorkingSupply(address)];
+                        case 1:
+                            _c = _e.sent(), boostBN = _c[0], futureWorkingSupplyBN = _c[1];
+                            return [4 /*yield*/, this._calcTokenApy(futureWorkingSupplyBN)];
+                        case 2:
+                            _d = _e.sent(), minApy = _d[0], maxApy = _d[1];
+                            if (boostBN.lt(1))
+                                return [2 /*return*/, minApy];
+                            if (boostBN.gt(2.5))
+                                return [2 /*return*/, maxApy];
+                            return [2 /*return*/, BN(minApy).times(boostBN).toNumber()];
                     }
                 });
             });
@@ -825,7 +918,7 @@ var PoolTemplate = /** @class */ (function () {
                             return [3 /*break*/, 3];
                         case 6: return [3 /*break*/, 14];
                         case 7:
-                            if (!(this.sRewardContract && "rewardRate()" in _curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1)) return [3 /*break*/, 10];
+                            if (!(this.sRewardContract && "rewardRate()" in curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1)) return [3 /*break*/, 10];
                             rewardToken = rewardTokens[0];
                             sRewardContract = curve.contracts[this.sRewardContract].multicallContract;
                             return [4 /*yield*/, curve.multicallProvider.all([
@@ -1052,6 +1145,14 @@ var PoolTemplate = /** @class */ (function () {
                 });
             });
         };
+        this._stored_rates = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, curve.contracts[this.address].contract.stored_rates()];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        }); };
         this._underlyingPrices = function () { return __awaiter(_this, void 0, void 0, function () {
             var promises, _i, _c, addr;
             return __generator(this, function (_d) {
@@ -1103,6 +1204,7 @@ var PoolTemplate = /** @class */ (function () {
         this.isFake = poolData.is_fake || false;
         this.isFactory = poolData.is_factory || false;
         this.isMetaFactory = (this.isMeta && this.isFactory) || this.zap === '0xa79828df1850e8a3a3064576f380d90aecdd3359';
+        this.isStableNg = poolData.is_stable_ng || false;
         this.isLlamma = poolData.is_llamma || false;
         this.basePool = poolData.base_pool || '';
         this.metaCoinIdx = this.isMeta ? (_c = poolData.meta_coin_idx) !== null && _c !== void 0 ? _c : poolData.wrapped_coins.length - 1 : -1;
@@ -1403,34 +1505,45 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.depositBonus = function (amounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var amountsBN, prices, _c, pricesBN, balancesBN, balancedAmounts, expectedBN, _d, balancedExpectedBN, _e;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
+            var amountsBN, prices, isUseStoredRates, result, pricesBN, balancesBN, balancedAmounts, expectedBN, _c, balancedExpectedBN, _d;
+            var _this = this;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         amountsBN = amounts.map(BN);
-                        if (!(this.isCrypto || this.id === 'wsteth' || this.id === 'factory-crvusd-24')) return [3 /*break*/, 2];
+                        prices = [];
+                        isUseStoredRates = isMethodExist(curve.contracts[this.address].contract, 'stored_rates') && this.isPlain;
+                        if (!(this.isCrypto || this.id === 'wsteth')) return [3 /*break*/, 2];
                         return [4 /*yield*/, this._underlyingPrices()];
                     case 1:
-                        _c = _f.sent();
-                        return [3 /*break*/, 3];
+                        prices = _e.sent();
+                        return [3 /*break*/, 5];
                     case 2:
-                        _c = this.underlyingCoins.map(function () { return 1; });
-                        _f.label = 3;
+                        if (!isUseStoredRates) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._stored_rates()];
                     case 3:
-                        prices = _c;
+                        result = _e.sent();
+                        result.forEach(function (item, index) {
+                            prices.push(Number(item) / (Math.pow(10, (36 - _this.underlyingDecimals[index]))));
+                        });
+                        return [3 /*break*/, 5];
+                    case 4:
+                        prices = this.underlyingCoins.map(function () { return 1; });
+                        _e.label = 5;
+                    case 5:
                         pricesBN = prices.map(BN);
                         return [4 /*yield*/, this.stats.underlyingBalances()];
-                    case 4:
-                        balancesBN = (_f.sent()).map(BN);
+                    case 6:
+                        balancesBN = (_e.sent()).map(BN);
                         balancedAmounts = this._balancedAmountsWithSameValue(amountsBN, pricesBN, balancesBN);
-                        _d = BN;
+                        _c = BN;
                         return [4 /*yield*/, this.depositExpected(amounts)];
-                    case 5:
-                        expectedBN = _d.apply(void 0, [_f.sent()]);
-                        _e = BN;
+                    case 7:
+                        expectedBN = _c.apply(void 0, [_e.sent()]);
+                        _d = BN;
                         return [4 /*yield*/, this.depositExpected(balancedAmounts)];
-                    case 6:
-                        balancedExpectedBN = _e.apply(void 0, [_f.sent()]);
+                    case 8:
+                        balancedExpectedBN = _d.apply(void 0, [_e.sent()]);
                         return [2 /*return*/, String(expectedBN.minus(balancedExpectedBN).div(balancedExpectedBN).times(100))];
                 }
             });

package/lib/utils.d.ts

@@ -23,6 +23,7 @@ export declare const _getCoinAddresses: (...coins: string[] | string[][]) => str
 export declare const _getCoinDecimals: (...coinAddresses: string[] | string[][]) => number[];
 export declare const _getBalances: (coins: string[], addresses: string[]) => Promise<IDict<string[]>>;
 export declare const _prepareAddresses: (addresses: string[] | string[][]) => string[];
+export declare const _getAddress: (address: string) => string;
 export declare const getBalances: (coins: string[], ...addresses: string[] | string[][]) => Promise<IDict<string[]> | string[]>;
 export declare const _getAllowance: (coins: string[], address: string, spender: string) => Promise<bigint[]>;
 export declare const getAllowance: (coins: string[], address: string, spender: string) => Promise<string[]>;
@@ -56,5 +57,6 @@ export declare const getCoinsData: (...coins: string[] | string[][]) => Promise<
 export declare const hasDepositAndStake: () => boolean;
 export declare const hasRouter: () => boolean;
 export declare const getCountArgsOfMethodByContract: (contract: Contract, methodName: string) => number;
+export declare const isMethodExist: (contract: Contract, methodName: string) => boolean;
 export declare const getPoolName: (name: string) => string;
 export declare const assetTypeNameHandler: (assetTypeName: string) => REFERENCE_ASSET;

package/lib/utils.js

@@ -234,6 +234,12 @@ export var _prepareAddresses = function (addresses) {
     addresses = addresses;
     return addresses.filter(function (val, idx, arr) { return arr.indexOf(val) === idx; });
 };
+export var _getAddress = function (address) {
+    address = address || curve.signerAddress;
+    if (!address)
+        throw Error("Need to connect wallet or pass address into args");
+    return address;
+};
 export var getBalances = function (coins) {
     var addresses = [];
     for (var _i = 1; _i < arguments.length; _i++) {
@@ -369,7 +375,7 @@ export var _ensureAllowance = function (coins, amounts, spender, isMax) {
 export var ensureAllowanceEstimateGas = function (coins, amounts, spender, isMax) {
     if (isMax === void 0) { isMax = true; }
     return __awaiter(void 0, void 0, void 0, function () {
-        var coinAddresses, decimals, _amounts, address, allowance, gas, i, contract, _approveAmount, currentGas_1, _a, currentGas, _b;
+        var coinAddresses, decimals, _amounts, address, _allowance, gas, i, contract, _approveAmount, currentGas, _a, currentGas, _b;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
@@ -379,22 +385,29 @@ export var ensureAllowanceEstimateGas = function (coins, amounts, spender, isMax
                     address = curve.signerAddress;
                     return [4 /*yield*/, _getAllowance(coinAddresses, address, spender)];
                 case 1:
-                    allowance = _c.sent();
+                    _allowance = _c.sent();
                     gas = [0, 0];
                     i = 0;
                     _c.label = 2;
                 case 2:
-                    if (!(i < allowance.length)) return [3 /*break*/, 7];
-                    if (!(allowance[i] < _amounts[i])) return [3 /*break*/, 6];
+                    if (!(i < _allowance.length)) return [3 /*break*/, 7];
+                    if (!(_allowance[i] < _amounts[i])) return [3 /*break*/, 6];
                     contract = curve.contracts[coinAddresses[i]].contract;
                     _approveAmount = isMax ? MAX_ALLOWANCE : _amounts[i];
-                    if (!(allowance[i] > curve.parseUnits("0"))) return [3 /*break*/, 4];
+                    if (!(_allowance[i] > curve.parseUnits("0"))) return [3 /*break*/, 4];
                     _a = smartNumber;
                     return [4 /*yield*/, contract.approve.estimateGas(spender, curve.parseUnits("0"), curve.constantOptions)];
                 case 3:
-                    currentGas_1 = _a.apply(void 0, [_c.sent()]);
-                    gas = gasSum(gas, currentGas_1);
-                    _c.label = 4;
+                    currentGas = _a.apply(void 0, [_c.sent()]);
+                    // For some coins (crv for example ) we can't estimate the second tx gas (approve: 0 --> amount), so we assume it will cost the same amount of gas
+                    if (typeof currentGas === "number") {
+                        currentGas = currentGas * 2;
+                    }
+                    else {
+                        currentGas = currentGas.map(function (g) { return g * 2; });
+                    }
+                    gas = gasSum(gas, currentGas);
+                    return [3 /*break*/, 6];
                 case 4:
                     _b = smartNumber;
                     return [4 /*yield*/, contract.approve.estimateGas(spender, _approveAmount, curve.constantOptions)];
@@ -429,10 +442,13 @@ export var ensureAllowance = function (coins, amounts, spender, isMax) {
 };
 export var getPoolIdBySwapAddress = function (swapAddress) {
     var poolsData = curve.getPoolsData();
-    return Object.entries(poolsData).filter(function (_a) {
+    var poolIds = Object.entries(poolsData).filter(function (_a) {
         var _ = _a[0], poolData = _a[1];
         return poolData.swap_address.toLowerCase() === swapAddress.toLowerCase();
-    })[0][0];
+    });
+    if (poolIds.length === 0)
+        return "";
+    return poolIds[0][0];
 };
 var _getTokenAddressBySwapAddress = function (swapAddress) {
     var poolsData = curve.getPoolsData();
@@ -898,6 +914,15 @@ export var getCountArgsOfMethodByContract = function (contract, methodName) {
         return -1;
     }
 };
+export var isMethodExist = function (contract, methodName) {
+    var func = contract.interface.fragments.find(function (item) { return item.name === methodName; });
+    if (func) {
+        return true;
+    }
+    else {
+        return false;
+    }
+};
 export var getPoolName = function (name) {
     var separatedName = name.split(": ");
     if (separatedName.length > 1) {

package/package.json

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